chore(devdeps): update pnpm to v10.16.0 (#2793) (#2800)

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

Author: radhi-nasser-scaleway

.changeset/lazy-games-create.md

@@ -0,0 +1,5 @@
+---
+"@scaleway/fuzzy-search": major
+---
+
+feat: create fuzzy search package

README.md

@@ -37,7 +37,6 @@ scaleway-lib is a set of NPM packages used at Scaleway.
   ![npm bundle size](https://packagephobia.com/badge?p=@scaleway/cookie-consent)
   ![npm](https://img.shields.io/npm/v/@scaleway/cookie-consent)
 
-
 - [`@scaleway/countries`](./packages_deprecated/countries/README.md): ISO 3166/3166-2 coutries JSON database.
 
   ![npm](https://img.shields.io/npm/dm/@scaleway/countries)
@@ -104,6 +103,12 @@ scaleway-lib is a set of NPM packages used at Scaleway.
   ![npm bundle size](https://packagephobia.com/badge?p=@scaleway/regex)
   ![npm](https://img.shields.io/npm/v/@scaleway/regex)
 
+- [`@scaleway/fuzzy-search`](./packages/fuzzy-search/README.md): fuzzy search utility
+
+  ![npm](https://img.shields.io/npm/dm/@scaleway/fuzzy-search)
+  ![npm bundle size](https://packagephobia.com/badge?p=@scaleway/fuzzy-search)
+  ![npm](https://img.shields.io/npm/v/@scaleway/fuzzy-search)
+
 - [`@scaleway/jest-helpers`](./packages/jest-helpers/README.md): utilities jest functions.
 
   ![npm](https://img.shields.io/npm/dm/@scaleway/jest-helpers)

packages/fuzzy-search/.eslintignore

@@ -0,0 +1,4 @@
+dist/
+coverage/
+node_modules
+.reports/

packages/fuzzy-search/.npmignore

@@ -0,0 +1,3 @@
+**/__tests__/**
+src
+!.npmignore

packages/fuzzy-search/CHANGELOG.md

@@ -0,0 +1 @@
+# Change Log

packages/fuzzy-search/README.md

@@ -0,0 +1,19 @@
+# `@scaleway/fuzzy-search`
+
+A fuzzy search utility
+
+---
+
+## Install
+
+```bash
+$ pnpm add @scaleway/fuzzy-search
+```
+
+## Usage
+
+```js
+import { isFuzzyMatch } from "@scaleway/fuzzy-search";
+
+const match = isFuzzyMatch("test", "tests");
+```

packages/fuzzy-search/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@scaleway/fuzzy-search",
+  "version": "0.0.1",
+  "description": "A small utility to use fuzzy search",
+  "type": "module",
+  "engines": {
+    "node": ">=20.x"
+  },
+  "main": "./dist/index.cjs",
+  "sideEffects": false,
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "prebuild": "shx rm -rf dist",
+    "typecheck": "tsc --noEmit",
+    "type:generate": "tsc --declaration -p tsconfig.build.json",
+    "build": "vite build --config vite.config.ts && pnpm run type:generate",
+    "build:profile": "npx vite-bundle-visualizer -c vite.config.ts",
+    "lint": "eslint --report-unused-disable-directives --cache --cache-strategy content --ext ts,tsx .",
+    "test:unit": "vitest --run --config vite.config.ts",
+    "test:unit:coverage": "pnpm test:unit --coverage"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/scaleway/scaleway-lib",
+    "directory": "packages/fuzzy-search"
+  },
+  "license": "MIT"
+}

packages/fuzzy-search/src/__tests__/index.test.tsx

@@ -0,0 +1,54 @@
+import { describe, expect, test } from 'vitest'
+import { isFuzzyMatch, levenshteinDistance, normalizeString } from ".."
+
+describe('fuzzySearch', () => {
+  describe('normalizeString', () => {
+    test('returns correct string', () => {
+      expect(normalizeString('île-de-France')).toBe('ile de france')
+    })
+  })
+
+  describe('levenshteinDistance', () => {
+    test('returns correct lenvenshtein distance', () => {
+      expect(levenshteinDistance('test', 'test')).toBe(0)
+
+      expect(levenshteinDistance('tests', 'test')).toBe(1)
+      expect(levenshteinDistance('test', 'tests')).toBe(1)
+
+      expect(levenshteinDistance('tset', 'test')).toBe(2)
+
+      expect(levenshteinDistance('hello', 'test')).toBe(4)
+
+      expect(levenshteinDistance('', 'test')).toBe(4)
+      expect(levenshteinDistance('test', '0')).toBe(4)
+    })
+  })
+  describe('fuzzySearch', () => {
+    test('with default distance (1)', () => {
+      expect(isFuzzyMatch('test', 'test')).toBeTruthy()
+      expect(isFuzzyMatch('tests', 'test')).toBeFalsy()
+      expect(isFuzzyMatch('test', 'tests')).toBeTruthy()
+      expect(isFuzzyMatch('tset', 'test')).toBeFalsy()
+      expect(isFuzzyMatch('hello', 'test')).toBeFalsy()
+      expect(isFuzzyMatch('', 'test')).toBeTruthy()
+    })
+
+    test('with distance = 0 (exact match)', () => {
+      expect(isFuzzyMatch('test', 'test', 0)).toBeTruthy()
+      expect(isFuzzyMatch('tests', 'test', 0)).toBeFalsy()
+      expect(isFuzzyMatch('test', 'tests', 0)).toBeTruthy()
+      expect(isFuzzyMatch('tset', 'test', 0)).toBeFalsy()
+      expect(isFuzzyMatch('hello', 'test', 0)).toBeFalsy()
+      expect(isFuzzyMatch('', 'test')).toBeTruthy()
+    })
+
+    test('with distance = 2 (swap tolerant)', () => {
+      expect(isFuzzyMatch('test', 'test', 2)).toBeTruthy()
+      expect(isFuzzyMatch('tests', 'test', 2)).toBeFalsy()
+      expect(isFuzzyMatch('test', 'tests', 2)).toBeTruthy()
+      expect(isFuzzyMatch('tset', 'test', 2)).toBeTruthy()
+      expect(isFuzzyMatch('hello', 'test', 2)).toBeFalsy()
+      expect(isFuzzyMatch('', 'test')).toBeTruthy()
+    })
+  })
+})

packages/fuzzy-search/src/index.ts

@@ -0,0 +1,69 @@
+// Remove accent & uppercase
+export const normalizeString = (string: string) =>
+  string
+    .normalize('NFD')
+    .replace(/[\u0300-\u036F]/g, '')
+    .replace(/-/g, ' ')
+    .toLowerCase()
+
+export const levenshteinDistance = (query: string, slice: string): number => {
+  if (query.length === 0) {
+    return slice.length
+  }
+  if (slice.length === 0) {
+    return query.length
+  }
+  const distancesArray: number[][] = []
+  for (let i = 0; i <= slice.length; i += 1) {
+    distancesArray[i] = [i]
+    for (let j = 1; j <= query.length; j += 1) {
+      const prev = distancesArray[i - 1] ?? []
+      const curr = distancesArray[i] ?? []
+      curr[j] =
+        i === 0
+          ? j
+          : Math.min(
+              (prev[j] ?? 0) + 1,
+              (curr[j - 1] ?? 0) + 1,
+              (prev[j - 1] ?? 0) + (query[j - 1] === slice[i - 1] ? 0 : 1),
+            )
+    }
+  }
+
+  return distancesArray[slice.length]?.[query.length] ?? 0
+}
+
+/**
+ * Return `true` if there is a fuzz match in a substring
+ * By default, allow distance of 1 (which mean, 1 character difference for a match)
+ * @example isFuzzyMatch("merr", "mercury") = true
+ * isFuzzyMatch("cry", "mercury") = true
+ * isFuzzyMatch("mrcury", "mercury") = true
+ * isFuzzyMatch("mrecury", "mercury") = false
+ * isFuzzyMatch("mrecury", "mercury", 2) = true
+ */
+export const isFuzzyMatch = (
+  query: string,
+  target: string,
+  maxDistance = 1,
+): boolean => {
+  const normQuery = normalizeString(query)
+  const normTarget = normalizeString(target)
+
+  if (normQuery.length === 0) {
+    return true
+  }
+  if (normQuery.length > normTarget.length) {
+    return false
+  }
+
+  for (let i = 0; i <= normTarget.length - normQuery.length; i += 1) {
+    const slice = normTarget.slice(i, i + normQuery.length)
+    const dist = levenshteinDistance(normQuery, slice)
+    if (dist <= maxDistance) {
+      return true
+    }
+  }
+
+  return false
+}

packages/fuzzy-search/tsconfig.build.json

@@ -0,0 +1,16 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": false,
+    "emitDeclarationOnly": true,
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "exclude": [
+    "*.config.ts",
+    "*.setup.ts",
+    "**/__tests__",
+    "**/__mocks__",
+    "src/**/*.test.tsx"
+  ]
+}