{"version":3,"file":"index.mjs","sources":["../src/enums/ReturnTypeEnums.ts","../src/enums/ThresholdTypeEnums.ts","../src/lib/fillDefaultOptions.ts","../src/lib/getSimilarity.ts","../src/lib/normalizeString.ts","../src/lib/matchItemProcessor.ts","../src/lib/resultProcessor.ts","../src/index.ts"],"sourcesContent":["export enum ReturnTypeEnums {\n  ALL_CLOSEST_MATCHES = 'all-closest-matches',\n  ALL_MATCHES = 'all-matches',\n  ALL_SORTED_MATCHES = 'all-sorted-matches',\n  FIRST_CLOSEST_MATCH = 'first-closest-match',\n  FIRST_MATCH = 'first-match',\n}\n","export enum ThresholdTypeEnums {\n  EDIT_DISTANCE = 'edit-distance',\n  SIMILARITY = 'similarity',\n}\n","import { ReturnTypeEnums } from '../enums/ReturnTypeEnums.js'\nimport { ThresholdTypeEnums } from '../enums/ThresholdTypeEnums.js'\nimport type { Options } from '../types.js'\n\nconst fillDefaultOptions = (options?: Partial<Options>): Options => {\n  const optionsWithDefaultValues = {\n    caseSensitive: false,\n    deburr: true,\n    matchPath: [],\n    returnType: ReturnTypeEnums.FIRST_CLOSEST_MATCH,\n    thresholdType: ThresholdTypeEnums.SIMILARITY,\n    trimSpaces: true,\n    ...options,\n  }\n\n  if (\n    !Object.values(ReturnTypeEnums).includes(\n      optionsWithDefaultValues.returnType,\n    )\n  ) {\n    throw new TypeError('unknown returnType')\n  }\n  if (\n    !Object.values(ThresholdTypeEnums).includes(\n      optionsWithDefaultValues.thresholdType,\n    )\n  ) {\n    throw new TypeError('unknown thresholdType')\n  }\n\n  switch (optionsWithDefaultValues.thresholdType) {\n    case ThresholdTypeEnums.EDIT_DISTANCE:\n      return {\n        threshold: 20,\n        ...optionsWithDefaultValues,\n      }\n\n    case ThresholdTypeEnums.SIMILARITY:\n      return {\n        threshold: 0.4,\n        ...optionsWithDefaultValues,\n      }\n  }\n}\nexport default fillDefaultOptions\n","import { distance } from 'fastest-levenshtein'\n\n/**\n * Using edit distance between `a` and `b` to calculate similarity\n *\n * @param {string} a - `input`\n * @param {string} b - String from `matchList`\n * @returns {number} similarity between `a` and `b`\n */\nconst getSimilarity = (a: string, b: string): number => {\n  if (!a || !b) return 0\n  if (a === b) return 1\n\n  const editDistance = distance(a, b)\n  const longestLength = Math.max(a.length, b.length)\n\n  return (longestLength - editDistance) / longestLength\n}\n\nexport default getSimilarity\n","import deburr from 'lodash.deburr'\n\nimport type { Options } from '../types.js'\n\n/**\n * Normalize a string\n *\n * @param {string} str - any string\n * @param {object} options - options that allows you to modify the behavior\n * @returns {string} - normalized string\n */\nconst normalizeString = (str: string, options: Options): string => {\n  let s = str\n\n  if (options.trimSpaces) {\n    s = s.trim().replaceAll(/\\s+/gu, ' ')\n  }\n\n  if (options.deburr) {\n    s = deburr(s)\n  }\n\n  if (!options.caseSensitive) {\n    s = s.toLowerCase()\n  }\n\n  return s\n}\n\nexport default normalizeString\n","import type { MatchItem, Options } from '../types.js'\nimport normalizeString from './normalizeString.js'\n\nconst getMatchItemStr = (\n  matchItem: MatchItem,\n  matchPath: Options['matchPath'],\n): string => {\n  const matchItemStr =\n    matchPath.length > 0\n      ? matchPath.reduce<unknown>((acc, prop) => {\n          // @ts-expect-error skip redundant type check\n          return acc?.[prop]\n        }, matchItem)\n      : matchItem\n  if (typeof matchItemStr !== 'string') return ''\n  return matchItemStr\n}\n\n/**\n * Process matchItem according to options\n *\n * @param {object | string} matchItem - Item for matching with `input`\n * @param {object} options - options that allows you to modify the behavior\n * @returns {string} - processed matchItem\n */\nconst matchItemProcessor = (matchItem: MatchItem, options: Options): string => {\n  const { matchPath } = options\n\n  const matchItemStr = getMatchItemStr(matchItem, matchPath)\n\n  return normalizeString(matchItemStr, options)\n}\n\nexport default matchItemProcessor\n","import { ReturnTypeEnums } from '../enums/ReturnTypeEnums.js'\n\n/**\n * Generate result\n *\n * @param {object[] | string[]} matchList - List for matching with `input`\n * @param {number[]} matchedIndexes - indexes of matchList that need to be returned as result\n * @param {ReturnTypeEnums} returnType - how the result will response to user\n * @returns {Array | null | object | string} - matched result(s), return object if `match` is `{Object[]}`\n */\nconst resultProcessor = <T>(\n  matchList: ReadonlyArray<T>,\n  matchedIndexes: ReadonlyArray<number>,\n  returnType: ReturnTypeEnums,\n  // eslint-disable-next-line functional/prefer-immutable-types\n): Array<T> | T | null => {\n  switch (returnType) {\n    case ReturnTypeEnums.ALL_CLOSEST_MATCHES:\n    case ReturnTypeEnums.ALL_MATCHES:\n    case ReturnTypeEnums.ALL_SORTED_MATCHES:\n      return matchedIndexes.map((matchedIndex) => matchList[matchedIndex]!)\n\n    case ReturnTypeEnums.FIRST_CLOSEST_MATCH:\n    case ReturnTypeEnums.FIRST_MATCH: {\n      const matchedIndex = matchedIndexes[0]\n      if (matchedIndex === undefined) return null\n      return matchList[matchedIndex]!\n    }\n  }\n}\n\nexport default resultProcessor\n","import { distance } from 'fastest-levenshtein'\n\nimport { ReturnTypeEnums } from './enums/ReturnTypeEnums.js'\nimport { ThresholdTypeEnums } from './enums/ThresholdTypeEnums.js'\nimport fillDefaultOptions from './lib/fillDefaultOptions.js'\nimport getSimilarity from './lib/getSimilarity.js'\nimport matchItemProcessor from './lib/matchItemProcessor.js'\nimport normalizeString from './lib/normalizeString.js'\nimport resultProcessor from './lib/resultProcessor.js'\nimport type { MatchItem, Options } from './types.js'\n\nfunction didYouMean<T extends MatchItem>(\n  input: string,\n  matchList: ReadonlyArray<T>,\n  options?: Partial<Options> & {\n    readonly returnType?:\n      | ReturnTypeEnums.FIRST_CLOSEST_MATCH\n      | ReturnTypeEnums.FIRST_MATCH\n  },\n): T | null\nfunction didYouMean<T extends MatchItem>(\n  input: string,\n  matchList: ReadonlyArray<T>,\n  options: Partial<Options> & {\n    readonly returnType:\n      | ReturnTypeEnums.ALL_CLOSEST_MATCHES\n      | ReturnTypeEnums.ALL_MATCHES\n      | ReturnTypeEnums.ALL_SORTED_MATCHES\n  },\n  // eslint-disable-next-line functional/prefer-immutable-types\n): T[]\n/**\n * Main function for didyoumean2\n *\n * @param {string} input - string that you are not sure and want to match with `matchList`\n * @param {object[] | string[]} matchList - List for matching with `input`\n * @param {null | object | undefined} options - options that allows you to modify the behavior\n * @returns {Array | null | object | string} - matched result(s), return object if `match` is `{Object[]}`\n */\nfunction didYouMean<T extends MatchItem>(\n  input: string,\n  matchList: ReadonlyArray<T>,\n  options?: Partial<Options>,\n  // eslint-disable-next-line functional/prefer-immutable-types\n): Array<T> | T | null {\n  /*+++++++++++++++++++\n   + Initiate options +\n   +++++++++++++++++++*/\n\n  const optionsWithDefaults = fillDefaultOptions(options)\n\n  const { returnType, threshold, thresholdType } = optionsWithDefaults\n\n  /*++++++++++++++++++++\n   + Deal with options +\n   ++++++++++++++++++++*/\n\n  const normalizedInput = normalizeString(input, optionsWithDefaults)\n\n  let checkIfMatched: (score: number) => boolean // Validate if score is matched\n  let scoreProcessor: (matchItem: T) => number // Get score\n  switch (thresholdType) {\n    case ThresholdTypeEnums.EDIT_DISTANCE:\n      checkIfMatched = (score: number) => score <= threshold\n      scoreProcessor = (matchItem: T) =>\n        distance(\n          normalizedInput,\n          matchItemProcessor(matchItem, optionsWithDefaults),\n        )\n      break\n\n    case ThresholdTypeEnums.SIMILARITY:\n      checkIfMatched = (score: number) => score >= threshold\n      scoreProcessor = (matchItem: T) =>\n        getSimilarity(\n          normalizedInput,\n          matchItemProcessor(matchItem, optionsWithDefaults),\n        )\n      break\n  }\n\n  /*+++++++++++\n   + Matching +\n   +++++++++++*/\n\n  // eslint-disable-next-line functional/prefer-immutable-types\n  const matchedIndexes: number[] = []\n\n  switch (returnType) {\n    case ReturnTypeEnums.ALL_CLOSEST_MATCHES:\n    case ReturnTypeEnums.FIRST_CLOSEST_MATCH: {\n      // eslint-disable-next-line functional/prefer-immutable-types\n      const scores: number[] = []\n\n      let marginValue: number\n      switch (thresholdType) {\n        case ThresholdTypeEnums.EDIT_DISTANCE:\n          // Process score and save the smallest score\n          marginValue = Number.POSITIVE_INFINITY\n          for (const matchItem of matchList) {\n            const score = scoreProcessor(matchItem)\n\n            if (marginValue > score) marginValue = score\n\n            scores.push(score)\n          }\n          break\n\n        case ThresholdTypeEnums.SIMILARITY:\n          // Process score and save the largest score\n          marginValue = 0\n          for (const matchItem of matchList) {\n            const score = scoreProcessor(matchItem)\n\n            if (marginValue < score) marginValue = score\n\n            scores.push(score)\n          }\n          break\n      }\n\n      for (const [i, score] of scores.entries()) {\n        if (checkIfMatched(score) && score === marginValue) {\n          matchedIndexes.push(i)\n        }\n      }\n\n      break\n    }\n\n    case ReturnTypeEnums.ALL_MATCHES:\n      for (const [i, matchItem] of matchList.entries()) {\n        const score = scoreProcessor(matchItem)\n\n        // save all indexes of matched scores\n        if (checkIfMatched(score)) {\n          matchedIndexes.push(i)\n        }\n      }\n\n      break\n\n    case ReturnTypeEnums.ALL_SORTED_MATCHES: {\n      // eslint-disable-next-line functional/prefer-immutable-types\n      const unsortedResults: Readonly<{\n        score: number\n        index: number\n      }>[] = []\n      for (const [i, matchItem] of matchList.entries()) {\n        const score = scoreProcessor(matchItem)\n\n        // save all indexes of matched scores\n        if (checkIfMatched(score)) {\n          unsortedResults.push({\n            score,\n            index: i,\n          })\n        }\n      }\n\n      switch (thresholdType) {\n        case ThresholdTypeEnums.EDIT_DISTANCE:\n          unsortedResults.sort((a, b) => a.score - b.score)\n          break\n\n        case ThresholdTypeEnums.SIMILARITY:\n          unsortedResults.sort((a, b) => b.score - a.score)\n          break\n      }\n\n      for (const unsortedResult of unsortedResults) {\n        matchedIndexes.push(unsortedResult.index)\n      }\n\n      break\n    }\n\n    case ReturnTypeEnums.FIRST_MATCH:\n      for (const [i, matchItem] of matchList.entries()) {\n        const score = scoreProcessor(matchItem)\n\n        // Return once matched, performance is main target in this returnType\n        if (checkIfMatched(score)) {\n          matchedIndexes.push(i)\n          break\n        }\n      }\n\n      break\n  }\n\n  /*+++++++++++++++++++++++\n   + Process return value +\n   +++++++++++++++++++++++*/\n\n  return resultProcessor(matchList, matchedIndexes, returnType)\n}\n\nexport default didYouMean\n\nexport { ReturnTypeEnums } from './enums/ReturnTypeEnums.js'\nexport { ThresholdTypeEnums } from './enums/ThresholdTypeEnums.js'\n"],"names":["ReturnTypeEnums","ThresholdTypeEnums","fillDefaultOptions","options","optionsWithDefaultValues","caseSensitive","deburr","matchPath","returnType","FIRST_CLOSEST_MATCH","thresholdType","SIMILARITY","trimSpaces","Object","values","includes","TypeError","EDIT_DISTANCE","threshold","getSimilarity","a","b","editDistance","distance","longestLength","Math","max","length","normalizeString","str","s","trim","replaceAll","toLowerCase","getMatchItemStr","matchItem","matchItemStr","reduce","acc","prop","matchItemProcessor","resultProcessor","matchList","matchedIndexes","ALL_CLOSEST_MATCHES","ALL_MATCHES","ALL_SORTED_MATCHES","map","matchedIndex","FIRST_MATCH","undefined","didYouMean","input","optionsWithDefaults","normalizedInput","checkIfMatched","scoreProcessor","score","scores","marginValue","Number","POSITIVE_INFINITY","push","i","entries","unsortedResults","index","sort","unsortedResult"],"mappings":"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"}