@amoa/forge 0.1.0

package/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "@amoa/forge",
+  "version": "0.1.0",
+  "type": "module",
+  "exports": {
+    "./*": "./src/*"
+  }
+}

package/src/address.js

@@ -0,0 +1,4 @@
+export const string = ({ street, zipcode, city }) => {
+  const data = [street, `${zipcode} ${city}`].filter(Boolean).join(", ");
+  return data;
+};

package/src/arrays/index.js

@@ -0,0 +1,3 @@
+export const sort = (target, reference = []) => {
+  return target.toSorted((a, b) => (reference.indexOf(a) + 1 || a) - (reference.indexOf(b) + 1 || b));
+};

package/src/boolean/index.js

@@ -0,0 +1,3 @@
+export const translate = (value) => {
+  return value ? (value === "true" ? "Oui" : "Non") : undefined;
+};

package/src/classes.js

@@ -0,0 +1,19 @@
+const statufy = (current) => Object.entries(current).reduce((acc, [key, value]) => (value ? [...acc, key] : acc), []);
+
+export const build = (initial, ...args) => {
+  const classes = args.reduce(
+    (acc, current) => {
+      switch (typeof current) {
+        case "string":
+          return [...acc, current];
+        case "object":
+          const list = statufy(current);
+          return [...acc, ...list];
+        default:
+          return acc;
+      }
+    },
+    [initial]
+  );
+  return classes.join(" ");
+};

package/src/dates/date.js

@@ -0,0 +1,10 @@
+export const format = (value, options) => {
+  const date = new Date(value);
+  if (isNaN(date.getTime())) return value;
+  return date.toLocaleDateString("fr-FR", options);
+};
+
+export const name = (value) => {
+  const date = new Date(value);
+  return date.toLocaleDateString("fr-FR", { day: "numeric", month: "long", year: "numeric" });
+};

package/src/dates/day.js

@@ -0,0 +1,13 @@
+import * as Dates from "./date";
+
+export const labels = ["Lu", "Ma", "Me", "Je", "Ve", "Sa", "Di"];
+
+export const dayOfMonth = (value) => {
+  const options = { month: "long", day: "numeric" };
+  return Dates.format(value, options);
+};
+
+export const shift = (date = new Date(), shift) => {
+  const day = new Date(date);
+  return new Date(day.getFullYear(), day.getMonth(), day.getDate() + shift);
+};

package/src/dates/index.js

@@ -0,0 +1,66 @@
+export * as Day from "./day";
+export * as Month from "./month";
+export * as Year from "./year";
+export * as Time from "./time";
+export * as Date from "./date";
+import * as date from "./date";
+
+const values = {
+  second: 1e3,
+  minute: 6e4,
+  hour: 36e5,
+  day: 864e5
+};
+
+export const check = (value) => value && !isNaN(new Date(value));
+
+export const standardize = (value) => {
+  return date.format(value);
+};
+
+export const UTCString = (date) => {
+  const offset = new Date(date).getTimezoneOffset() * 60000;
+  const local = new Date(new Date(date) - offset).toISOString().slice(0, -1);
+  return local;
+};
+
+export const round = (method, date) => {
+  switch (method) {
+    case "hours":
+      return new Date(date).setHours(0, 0, 0, 0);
+  }
+};
+
+export const match = (...dates) => {
+  const [first, second] = dates.map((date) => round("hours", date));
+  return first === second;
+};
+
+export const precedes = (...dates) => {
+  const [earliest, latest] = dates.map((date) => round("hours", date));
+  return earliest < latest;
+};
+
+export const follows = (...dates) => {
+  const [latest, earliest] = dates.map((date) => round("hours", date));
+  return latest < earliest;
+};
+
+export const intercedes = (...dates) => {
+  const [earliest, middle, latest] = dates.map((date) => round("hours", date));
+  return earliest < middle && middle < latest;
+};
+
+export const adapt = (number) => {
+  return ("0" + number).slice(-2);
+};
+
+export const differ = (before, after, granularity = "day") => {
+  const difference = Math.abs(new Date(before).getTime() - new Date(after).getTime());
+  return Math.round(difference / values[granularity]);
+};
+
+export const valid = (arg) => {
+  const date = new Date(arg);
+  return !isNaN(date.getTime());
+};

package/src/dates/month.js

@@ -0,0 +1,56 @@
+import * as Dates from "@amoa/forge/dates";
+
+export const labels = [
+  "Janvier",
+  "Février",
+  "Mars",
+  "Avril",
+  "Mai",
+  "Juin",
+  "Juillet",
+  "Août",
+  "Septembre",
+  "Octobre",
+  "Novembre",
+  "Décembre"
+];
+
+export const name = (value) => Dates.Date.format(value, { month: "long" });
+
+export const day = (date = new Date(), day) => {
+  const reference = new Date(date);
+  return new Date(reference.getFullYear(), reference.getMonth(), day + 1);
+};
+
+export const days = (date = new Date()) => {
+  const day = new Date(date);
+  return new Date(day.getFullYear(), day.getMonth() + 1, 0).getDate();
+};
+
+export const first = (date = new Date()) => {
+  const day = new Date(date);
+  return new Date(day.getFullYear(), day.getMonth(), 1);
+};
+
+export const last = (date = new Date()) => {
+  const day = new Date(date);
+  return new Date(day.getFullYear(), day.getMonth() + 1, 0);
+};
+
+export const previous = (date = new Date()) => {
+  const day = new Date(date);
+  return new Date(day.getFullYear(), day.getMonth() - 1);
+};
+
+export const next = (date = new Date()) => {
+  const day = new Date(date);
+  return new Date(day.getFullYear(), day.getMonth() + 1);
+};
+
+export const match = (...dates) => {
+  const [first, second] = dates.map((date) => ({
+    month: date.getMonth(),
+    year: date.getFullYear()
+  }));
+  return first.year === second.year && first.month === second.month;
+};

package/src/dates/time.js

@@ -0,0 +1,10 @@
+export const format = (value, options) => {
+  const date = new Date(value);
+  if (isNaN(date.getTime())) return value;
+  return date.toLocaleTimeString("fr-FR", options);
+};
+
+export const get = (value) => {
+  const options = { timeStyle: "short" };
+  return format(value, options);
+};

package/src/dates/year.js

@@ -0,0 +1,24 @@
+import * as Dates from "@amoa/forge/dates";
+
+const year = new Date().getFullYear();
+
+export const match = (...dates) => {
+  const [first, second] = dates.map((date) => date.getFullYear());
+  return first === second;
+};
+
+export const get = (count = 12, since, until) => {
+  const lower = Dates.check(since) && since.getFullYear();
+  const upper = Dates.check(until) && until.getFullYear();
+
+  const [start, end] = (() => {
+    if (lower && upper) return [lower, upper];
+    if (lower) return [lower, lower + count];
+    if (upper) return [upper - count + 1, upper + 1];
+    return [year - Math.round(count / 2), year + Math.round(count / 2)];
+  })();
+
+  return Array(end - start)
+    .fill()
+    .map((_, index) => start + index);
+};

package/src/fetcher/index.js

@@ -0,0 +1,65 @@
+import * as QueryString from "./querystring";
+
+const HEADERS = {
+  "Content-Type": "application/json; charset=utf-8"
+};
+
+export const fetcher =
+  (method) =>
+  async (_url, body, params = {}, _headers = {}) => {
+    const headers = { ...HEADERS, ..._headers };
+
+    const qs = QueryString.build(params);
+    const url = qs.length === 0 ? _url : `${_url}?${qs}`;
+
+    const reqOpts = {
+      method: method || "POST",
+      headers,
+      body: method !== "GET" && body !== undefined ? JSON.stringify(body) : undefined
+    };
+
+    const response = await fetch(url, reqOpts);
+
+    if (response.ok && response.status === 204) return;
+
+    const resJSON = await response.json();
+
+    if (response.ok === false) return Promise.reject(resJSON.error);
+    return resJSON;
+  };
+
+export const upload = async (url, file, headers) => {
+  if (!file) return;
+  const reqOpts = { method: "POST", headers, body: file };
+  const response = await fetch(url, reqOpts);
+  if (response.ok && response.status === 204) return;
+  const content = await response.json();
+  if (response.ok === false) return Promise.reject(content.error);
+  return content;
+};
+
+export const download = async (url, params = {}, headers = {}) => {
+  const reqOpts = { method: "GET", headers };
+  const response = await fetch(url, reqOpts);
+  if (response.ok && response.status === 204) return;
+  const content = await response.blob();
+  if (response.ok === false) return Promise.reject(content.error);
+  return content;
+};
+
+export const stream = async (_url, params = {}, headers = {}) => {
+  const reqOpts = { method: "GET", headers };
+  const qs = QueryString.build(params);
+  const url = qs.length === 0 ? _url : `${_url}?${qs}`;
+  const response = await fetch(url, reqOpts);
+  if (response.ok && response.status === 204) return;
+  const content = response.body;
+  const blob = await new Response(content).blob();
+  if (response.ok === false) return Promise.reject(blob.error);
+  return blob;
+};
+
+export const get = (url, params, headers) => fetcher("GET")(url, undefined, params, headers);
+export const put = fetcher("PUT");
+export const post = fetcher("POST");
+export const remove = fetcher("DELETE");

package/src/fetcher/querystring.js

@@ -0,0 +1,12 @@
+export const build = (params, prefix = "") =>
+  Object.entries(params)
+    .reduce((acc, [key, value]) => {
+      if (value === undefined || value === null) return acc;
+
+      const header = prefix ? (Array.isArray(params) ? `${prefix}[]` : `${prefix}[${key}]`) : key;
+      const complex = typeof value === "object" && !(value instanceof Date);
+      const param = complex ? build(value, header) : `${header}=${encodeURIComponent(value)}`;
+
+      return param ? [...acc, param] : acc;
+    }, [])
+    .join("&");

package/src/files.js

@@ -0,0 +1,23 @@
+import * as Dates from "@amoa/forge/dates";
+import * as Strings from "@amoa/forge/strings";
+
+import * as File from "@amoa/ingots/file/api";
+
+export const extract = (file, title) => {
+  const url = window.URL.createObjectURL(file);
+  const link = document.createElement("a");
+  link.href = url;
+  link.setAttribute("download", title);
+  link.click();
+};
+
+export const download = async (token, id, title) => {
+  const file = await File.download(token, id);
+  extract(file, title);
+};
+
+export const archive = async (file, condominium, creation) => {
+  const date = Dates.Date.format(creation).replace("/", "-");
+  const title = `mondeviscopro_devis_${Strings.serialize(condominium)}_${date}.zip`;
+  extract(file, title);
+};

package/src/filters.js

@@ -0,0 +1,51 @@
+import * as Strings from "@amoa/forge/strings";
+
+const dates = (data, key, filter) => {
+  const { before, after } = filter;
+  const preceding = before ? before > new Date(data[key]) : true;
+  const following = after ? after < new Date(data[key]) : true;
+  return preceding && following;
+};
+
+export const search = (data, search) => {
+  if (!search) return data;
+  const words = Strings.serialize(search).split("-").filter(Boolean);
+  const { precise, shallow } = data.reduce(
+    (acc, data) => {
+      const flattened = Strings.extract(data);
+      const transform = Strings.transform(flattened);
+      const precise = Strings.serialize(transform).includes(Strings.serialize(search));
+      const shallow = words.filter((item) => Strings.serialize(transform.join(" ")).includes(item));
+      if (precise) return { ...acc, precise: [...acc.precise, data] };
+      if (shallow.length) return { ...acc, shallow: [...acc.shallow, data] };
+      return acc;
+    },
+    { precise: [], shallow: [] }
+  );
+  return precise.length ? precise : shallow;
+};
+
+export const filter = (data, filters, reference) => {
+  if (!Object.keys(filters).length) return data;
+  return data.reduce((acc, item) => {
+    const check = Object.entries(filters).every(([key, list]) => {
+      if (Array.isArray(list)) {
+        const { together } = reference?.find((filter) => (filter.key = key)) || {};
+        const flat = list.map((value) => together?.[value] || value).flat();
+        return flat.includes(item[key]);
+      }
+      if (typeof list === "object") {
+        const { kind, ...filter } = list;
+        if (kind === "dates") return dates(item, key, filter);
+      }
+    });
+    return check ? [...acc, item] : acc;
+  }, []);
+};
+
+export const sort = (data, { key, direction, order }) => {
+  return data.toSorted((a, b) => {
+    if (!order) return a[key] < b[key] === direction ? -1 : 1;
+    return order.indexOf(a[key]) < order.indexOf(b[key]) === direction ? -1 : 1;
+  });
+};

package/src/functions/index.js

@@ -0,0 +1,20 @@
+export const throttle = (callback, delay = 300) => {
+  let last = 0;
+  let timeout = null;
+
+  return (...args) => {
+    const now = Date.now();
+
+    if (now - last >= delay) {
+      last = now;
+      callback(...args);
+    } else if (!timeout) {
+      const remaining = delay - (now - last);
+      timeout = setTimeout(() => {
+        last = Date.now();
+        timeout = null;
+        callback(...args);
+      }, remaining);
+    }
+  };
+};

package/src/maths.js

@@ -0,0 +1,16 @@
+export const percentage = (reference, number, mode = "standard") => {
+  switch (mode) {
+    case "reverse":
+      return (parseFloat(number) * parseFloat(reference)) / 100;
+    case "standard":
+    default:
+      return (100.0 * parseFloat(number)) / parseFloat(reference);
+  }
+};
+
+export const random = (range) => Math.floor(Math.random() * range);
+
+export const modulo = (a, b) => {
+  const m = a % b;
+  return m < 0 ? (b < 0 ? m - b : m + b) : m;
+};

package/src/numbers/index.js

@@ -0,0 +1,35 @@
+export const string = (number) => {
+  if (!number) return number;
+  const [integer, decimal] = number.toFixed(2).split(/[.,](?=[^.,]*$)/);
+  const separated = [...integer]
+    .toReversed()
+    .reduce((acc, digit, index) => (!((index + 1) % 3) ? [...acc, digit, " "] : [...acc, digit]), [])
+    .toReversed()
+    .join("")
+    .trim();
+  return +decimal === 0 ? separated : [separated, ",", decimal].join("");
+};
+
+export const shake = (min, max) => {
+  if (!max) return min;
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+};
+
+export const parse = (number) => {
+  if (!number) return number;
+  const string = number
+    .toString()
+    .replace(/[^0-9.,]/g, "")
+    .replace(",", ".");
+  const parsed = parseFloat(string);
+  return isNaN(parsed) ? number : parsed;
+};
+
+export const split = (number) => {
+  if (!number) return [];
+  return Array.from({ length: Math.round(number) }, (_, index) => Math.min(1, number - index));
+};
+
+export const check = (value) => {
+  return typeof value === "number" && !isNaN(value);
+};

package/src/pattern/index.js

@@ -0,0 +1,9 @@
+import * as Methods from "./methods";
+
+export const generate = (pattern) => {
+  return Object.entries(pattern).reduce((acc, [key, value]) => {
+    if (Array.isArray(value)) return { ...acc, [key]: value.map((subvalue) => generate(subvalue)) };
+    if (typeof value === "object" && value !== null) return { ...acc, [key]: generate(value) };
+    return { ...acc, [key]: Methods[value]() };
+  }, {});
+};

package/src/pattern/methods.js

@@ -0,0 +1,24 @@
+import * as UUID from "@amoa/forge/uuid";
+import * as Strings from "@amoa/forge/strings";
+import * as Numbers from "@amoa/forge/numbers";
+import * as Dates from "@amoa/forge/dates";
+
+const STEPS = ["ATTENTION", "PAYING", "BILLED", "CANCELLED", "CLOSED"];
+
+export const uuid = () => UUID.generate();
+
+export const address = () => Strings.shake(undefined, 30, 50);
+
+export const company = () => Strings.shake(undefined, 10, 30);
+
+export const datetime = () => Dates.UTCString(new Date());
+
+export const service = () => Strings.shake(undefined, 8, 42);
+
+export const step = () => STEPS[Numbers.shake(0, STEPS.length - 1)];
+
+export const number = () => Numbers.shake(50, 800) * 10;
+
+export const digit = () => Numbers.shake(1, 10);
+
+export const person = () => Strings.shake(undefined, 20, 42);

package/src/refs.js

@@ -0,0 +1,11 @@
+import React from "react";
+
+export const merge = (...refs) => {
+  return (value) => {
+    for (const ref of refs) {
+      if (!ref) continue;
+      if (typeof ref === "function") ref(value);
+      else if (typeof ref === "object" && "current" in ref) ref.current = value;
+    }
+  };
+};

package/src/strings/characters.js

@@ -0,0 +1,58 @@
+const CHARACTERS = [
+  "a",
+  "b",
+  "c",
+  "d",
+  "e",
+  "f",
+  "g",
+  "h",
+  "j",
+  "k",
+  "m",
+  "n",
+  "p",
+  "q",
+  "r",
+  "s",
+  "t",
+  "u",
+  "v",
+  "w",
+  "x",
+  "y",
+  "z",
+  "A",
+  "B",
+  "C",
+  "D",
+  "E",
+  "F",
+  "G",
+  "H",
+  "J",
+  "K",
+  "M",
+  "N",
+  "P",
+  "Q",
+  "R",
+  "S",
+  "T",
+  "U",
+  "V",
+  "W",
+  "X",
+  "Y",
+  "Z",
+  "2",
+  "3",
+  "4",
+  "5",
+  "6",
+  "7",
+  "8",
+  "9"
+];
+
+export default CHARACTERS;

package/src/strings/diacritics.js

@@ -0,0 +1,245 @@
+const DIACRITICS_REMOVAL_MAP = [
+  {
+    base: "A",
+    letters:
+      "\u0041\u24B6\uFF21\u00C0\u00C1\u00C2\u1EA6\u1EA4\u1EAA\u1EA8\u00C3\u0100\u0102\u1EB0\u1EAE\u1EB4\u1EB2\u0226\u01E0\u00C4\u01DE\u1EA2\u00C5\u01FA\u01CD\u0200\u0202\u1EA0\u1EAC\u1EB6\u1E00\u0104\u023A\u2C6F",
+  },
+  { base: "AA", letters: "\uA732" },
+  { base: "AE", letters: "\u00C6\u01FC\u01E2" },
+  { base: "AO", letters: "\uA734" },
+  { base: "AU", letters: "\uA736" },
+  { base: "AV", letters: "\uA738\uA73A" },
+  { base: "AY", letters: "\uA73C" },
+  {
+    base: "B",
+    letters: "\u0042\u24B7\uFF22\u1E02\u1E04\u1E06\u0243\u0182\u0181",
+  },
+  {
+    base: "C",
+    letters:
+      "\u0043\u24B8\uFF23\u0106\u0108\u010A\u010C\u00C7\u1E08\u0187\u023B\uA73E",
+  },
+  {
+    base: "D",
+    letters:
+      "\u0044\u24B9\uFF24\u1E0A\u010E\u1E0C\u1E10\u1E12\u1E0E\u0110\u018B\u018A\u0189\uA779\u00D0",
+  },
+  { base: "DZ", letters: "\u01F1\u01C4" },
+  { base: "Dz", letters: "\u01F2\u01C5" },
+  {
+    base: "E",
+    letters:
+      "\u0045\u24BA\uFF25\u00C8\u00C9\u00CA\u1EC0\u1EBE\u1EC4\u1EC2\u1EBC\u0112\u1E14\u1E16\u0114\u0116\u00CB\u1EBA\u011A\u0204\u0206\u1EB8\u1EC6\u0228\u1E1C\u0118\u1E18\u1E1A\u0190\u018E",
+  },
+  { base: "F", letters: "\u0046\u24BB\uFF26\u1E1E\u0191\uA77B" },
+  {
+    base: "G",
+    letters:
+      "\u0047\u24BC\uFF27\u01F4\u011C\u1E20\u011E\u0120\u01E6\u0122\u01E4\u0193\uA7A0\uA77D\uA77E",
+  },
+  {
+    base: "H",
+    letters:
+      "\u0048\u24BD\uFF28\u0124\u1E22\u1E26\u021E\u1E24\u1E28\u1E2A\u0126\u2C67\u2C75\uA78D",
+  },
+  {
+    base: "I",
+    letters:
+      "\u0049\u24BE\uFF29\u00CC\u00CD\u00CE\u0128\u012A\u012C\u0130\u00CF\u1E2E\u1EC8\u01CF\u0208\u020A\u1ECA\u012E\u1E2C\u0197",
+  },
+  { base: "J", letters: "\u004A\u24BF\uFF2A\u0134\u0248" },
+  {
+    base: "K",
+    letters:
+      "\u004B\u24C0\uFF2B\u1E30\u01E8\u1E32\u0136\u1E34\u0198\u2C69\uA740\uA742\uA744\uA7A2",
+  },
+  {
+    base: "L",
+    letters:
+      "\u004C\u24C1\uFF2C\u013F\u0139\u013D\u1E36\u1E38\u013B\u1E3C\u1E3A\u0141\u023D\u2C62\u2C60\uA748\uA746\uA780",
+  },
+  { base: "LJ", letters: "\u01C7" },
+  { base: "Lj", letters: "\u01C8" },
+  { base: "M", letters: "\u004D\u24C2\uFF2D\u1E3E\u1E40\u1E42\u2C6E\u019C" },
+  {
+    base: "N",
+    letters:
+      "\u004E\u24C3\uFF2E\u01F8\u0143\u00D1\u1E44\u0147\u1E46\u0145\u1E4A\u1E48\u0220\u019D\uA790\uA7A4",
+  },
+  { base: "NJ", letters: "\u01CA" },
+  { base: "Nj", letters: "\u01CB" },
+  {
+    base: "O",
+    letters:
+      "\u004F\u24C4\uFF2F\u00D2\u00D3\u00D4\u1ED2\u1ED0\u1ED6\u1ED4\u00D5\u1E4C\u022C\u1E4E\u014C\u1E50\u1E52\u014E\u022E\u0230\u00D6\u022A\u1ECE\u0150\u01D1\u020C\u020E\u01A0\u1EDC\u1EDA\u1EE0\u1EDE\u1EE2\u1ECC\u1ED8\u01EA\u01EC\u00D8\u01FE\u0186\u019F\uA74A\uA74C",
+  },
+  { base: "OI", letters: "\u01A2" },
+  { base: "OO", letters: "\uA74E" },
+  { base: "OU", letters: "\u0222" },
+  { base: "OE", letters: "\u008C\u0152" },
+  { base: "oe", letters: "\u009C\u0153" },
+  {
+    base: "P",
+    letters: "\u0050\u24C5\uFF30\u1E54\u1E56\u01A4\u2C63\uA750\uA752\uA754",
+  },
+  { base: "Q", letters: "\u0051\u24C6\uFF31\uA756\uA758\u024A" },
+  {
+    base: "R",
+    letters:
+      "\u0052\u24C7\uFF32\u0154\u1E58\u0158\u0210\u0212\u1E5A\u1E5C\u0156\u1E5E\u024C\u2C64\uA75A\uA7A6\uA782",
+  },
+  {
+    base: "S",
+    letters:
+      "\u0053\u24C8\uFF33\u1E9E\u015A\u1E64\u015C\u1E60\u0160\u1E66\u1E62\u1E68\u0218\u015E\u2C7E\uA7A8\uA784",
+  },
+  {
+    base: "T",
+    letters:
+      "\u0054\u24C9\uFF34\u1E6A\u0164\u1E6C\u021A\u0162\u1E70\u1E6E\u0166\u01AC\u01AE\u023E\uA786",
+  },
+  { base: "TZ", letters: "\uA728" },
+  {
+    base: "U",
+    letters:
+      "\u0055\u24CA\uFF35\u00D9\u00DA\u00DB\u0168\u1E78\u016A\u1E7A\u016C\u00DC\u01DB\u01D7\u01D5\u01D9\u1EE6\u016E\u0170\u01D3\u0214\u0216\u01AF\u1EEA\u1EE8\u1EEE\u1EEC\u1EF0\u1EE4\u1E72\u0172\u1E76\u1E74\u0244",
+  },
+  { base: "V", letters: "\u0056\u24CB\uFF36\u1E7C\u1E7E\u01B2\uA75E\u0245" },
+  { base: "VY", letters: "\uA760" },
+  {
+    base: "W",
+    letters: "\u0057\u24CC\uFF37\u1E80\u1E82\u0174\u1E86\u1E84\u1E88\u2C72",
+  },
+  { base: "X", letters: "\u0058\u24CD\uFF38\u1E8A\u1E8C" },
+  {
+    base: "Y",
+    letters:
+      "\u0059\u24CE\uFF39\u1EF2\u00DD\u0176\u1EF8\u0232\u1E8E\u0178\u1EF6\u1EF4\u01B3\u024E\u1EFE",
+  },
+  {
+    base: "Z",
+    letters:
+      "\u005A\u24CF\uFF3A\u0179\u1E90\u017B\u017D\u1E92\u1E94\u01B5\u0224\u2C7F\u2C6B\uA762",
+  },
+  {
+    base: "a",
+    letters:
+      "\u0061\u24D0\uFF41\u1E9A\u00E0\u00E1\u00E2\u1EA7\u1EA5\u1EAB\u1EA9\u00E3\u0101\u0103\u1EB1\u1EAF\u1EB5\u1EB3\u0227\u01E1\u00E4\u01DF\u1EA3\u00E5\u01FB\u01CE\u0201\u0203\u1EA1\u1EAD\u1EB7\u1E01\u0105\u2C65\u0250",
+  },
+  { base: "aa", letters: "\uA733" },
+  { base: "ae", letters: "\u00E6\u01FD\u01E3" },
+  { base: "ao", letters: "\uA735" },
+  { base: "au", letters: "\uA737" },
+  { base: "av", letters: "\uA739\uA73B" },
+  { base: "ay", letters: "\uA73D" },
+  {
+    base: "b",
+    letters: "\u0062\u24D1\uFF42\u1E03\u1E05\u1E07\u0180\u0183\u0253",
+  },
+  {
+    base: "c",
+    letters:
+      "\u0063\u24D2\uFF43\u0107\u0109\u010B\u010D\u00E7\u1E09\u0188\u023C\uA73F\u2184",
+  },
+  {
+    base: "d",
+    letters:
+      "\u0064\u24D3\uFF44\u1E0B\u010F\u1E0D\u1E11\u1E13\u1E0F\u0111\u018C\u0256\u0257\uA77A",
+  },
+  { base: "dz", letters: "\u01F3\u01C6" },
+  {
+    base: "e",
+    letters:
+      "\u0065\u24D4\uFF45\u00E8\u00E9\u00EA\u1EC1\u1EBF\u1EC5\u1EC3\u1EBD\u0113\u1E15\u1E17\u0115\u0117\u00EB\u1EBB\u011B\u0205\u0207\u1EB9\u1EC7\u0229\u1E1D\u0119\u1E19\u1E1B\u0247\u025B\u01DD",
+  },
+  { base: "f", letters: "\u0066\u24D5\uFF46\u1E1F\u0192\uA77C" },
+  {
+    base: "g",
+    letters:
+      "\u0067\u24D6\uFF47\u01F5\u011D\u1E21\u011F\u0121\u01E7\u0123\u01E5\u0260\uA7A1\u1D79\uA77F",
+  },
+  {
+    base: "h",
+    letters:
+      "\u0068\u24D7\uFF48\u0125\u1E23\u1E27\u021F\u1E25\u1E29\u1E2B\u1E96\u0127\u2C68\u2C76\u0265",
+  },
+  { base: "hv", letters: "\u0195" },
+  {
+    base: "i",
+    letters:
+      "\u0069\u24D8\uFF49\u00EC\u00ED\u00EE\u0129\u012B\u012D\u00EF\u1E2F\u1EC9\u01D0\u0209\u020B\u1ECB\u012F\u1E2D\u0268\u0131",
+  },
+  { base: "j", letters: "\u006A\u24D9\uFF4A\u0135\u01F0\u0249" },
+  {
+    base: "k",
+    letters:
+      "\u006B\u24DA\uFF4B\u1E31\u01E9\u1E33\u0137\u1E35\u0199\u2C6A\uA741\uA743\uA745\uA7A3",
+  },
+  {
+    base: "l",
+    letters:
+      "\u006C\u24DB\uFF4C\u0140\u013A\u013E\u1E37\u1E39\u013C\u1E3D\u1E3B\u017F\u0142\u019A\u026B\u2C61\uA749\uA781\uA747",
+  },
+  { base: "lj", letters: "\u01C9" },
+  { base: "m", letters: "\u006D\u24DC\uFF4D\u1E3F\u1E41\u1E43\u0271\u026F" },
+  {
+    base: "n",
+    letters:
+      "\u006E\u24DD\uFF4E\u01F9\u0144\u00F1\u1E45\u0148\u1E47\u0146\u1E4B\u1E49\u019E\u0272\u0149\uA791\uA7A5",
+  },
+  { base: "nj", letters: "\u01CC" },
+  {
+    base: "o",
+    letters:
+      "\u006F\u24DE\uFF4F\u00F2\u00F3\u00F4\u1ED3\u1ED1\u1ED7\u1ED5\u00F5\u1E4D\u022D\u1E4F\u014D\u1E51\u1E53\u014F\u022F\u0231\u00F6\u022B\u1ECF\u0151\u01D2\u020D\u020F\u01A1\u1EDD\u1EDB\u1EE1\u1EDF\u1EE3\u1ECD\u1ED9\u01EB\u01ED\u00F8\u01FF\u0254\uA74B\uA74D\u0275",
+  },
+  { base: "oi", letters: "\u01A3" },
+  { base: "ou", letters: "\u0223" },
+  { base: "oo", letters: "\uA74F" },
+  {
+    base: "p",
+    letters: "\u0070\u24DF\uFF50\u1E55\u1E57\u01A5\u1D7D\uA751\uA753\uA755",
+  },
+  { base: "q", letters: "\u0071\u24E0\uFF51\u024B\uA757\uA759" },
+  {
+    base: "r",
+    letters:
+      "\u0072\u24E1\uFF52\u0155\u1E59\u0159\u0211\u0213\u1E5B\u1E5D\u0157\u1E5F\u024D\u027D\uA75B\uA7A7\uA783",
+  },
+  {
+    base: "s",
+    letters:
+      "\u0073\u24E2\uFF53\u00DF\u015B\u1E65\u015D\u1E61\u0161\u1E67\u1E63\u1E69\u0219\u015F\u023F\uA7A9\uA785\u1E9B",
+  },
+  {
+    base: "t",
+    letters:
+      "\u0074\u24E3\uFF54\u1E6B\u1E97\u0165\u1E6D\u021B\u0163\u1E71\u1E6F\u0167\u01AD\u0288\u2C66\uA787",
+  },
+  { base: "tz", letters: "\uA729" },
+  {
+    base: "u",
+    letters:
+      "\u0075\u24E4\uFF55\u00F9\u00FA\u00FB\u0169\u1E79\u016B\u1E7B\u016D\u00FC\u01DC\u01D8\u01D6\u01DA\u1EE7\u016F\u0171\u01D4\u0215\u0217\u01B0\u1EEB\u1EE9\u1EEF\u1EED\u1EF1\u1EE5\u1E73\u0173\u1E77\u1E75\u0289",
+  },
+  { base: "v", letters: "\u0076\u24E5\uFF56\u1E7D\u1E7F\u028B\uA75F\u028C" },
+  { base: "vy", letters: "\uA761" },
+  {
+    base: "w",
+    letters:
+      "\u0077\u24E6\uFF57\u1E81\u1E83\u0175\u1E87\u1E85\u1E98\u1E89\u2C73",
+  },
+  { base: "x", letters: "\u0078\u24E7\uFF58\u1E8B\u1E8D" },
+  {
+    base: "y",
+    letters:
+      "\u0079\u24E8\uFF59\u1EF3\u00FD\u0177\u1EF9\u0233\u1E8F\u00FF\u1EF7\u1E99\u1EF5\u01B4\u024F\u1EFF",
+  },
+  {
+    base: "z",
+    letters:
+      "\u007A\u24E9\uFF5A\u017A\u1E91\u017C\u017E\u1E93\u1E95\u01B6\u0225\u0240\u2C6C\uA763",
+  },
+];
+
+export default DIACRITICS_REMOVAL_MAP;

package/src/strings/index.js

@@ -0,0 +1,107 @@
+import * as Dates from "@amoa/forge/dates";
+import * as Numbers from "@amoa/forge/numbers";
+import * as Search from "@amoa/forge/strings/search";
+
+import DIACRITICS_REMOVAL_MAP from "./diacritics";
+import CHARACTERS from "./characters";
+import PLURALS from "./plurals";
+
+const diacritics = DIACRITICS_REMOVAL_MAP.reduce((acc, { base, letters }) => {
+  const range = [...letters].reduce((acc, letter) => {
+    return { ...acc, [letter]: base };
+  }, {});
+  return { ...acc, ...range };
+}, {});
+
+export const serialize = (...strings) => {
+  const flattened = strings.reduce((acc, current) => {
+    switch (typeof current) {
+      case "string":
+        return current.trim() !== "" ? [...acc, current] : acc;
+      case "number":
+        return acc;
+      case "object":
+        return [...acc, Object.values(current).join("-")];
+    }
+  }, []);
+  return flattened
+    .join("-")
+    .replace(/[^\u0000-\u007E]/g, (letter) => diacritics[letter] || letter)
+    .replace(/[.,\/#!$%\^&\*;:{}=_`~()]/g, "")
+    .replace(/[^a-zA-Z0-9]+/g, "-")
+    .replace(/\s{2,}/g, " ")
+    .replace(/\s/g, "-")
+    .toLowerCase();
+};
+
+export const extract = (data) => {
+  if (data === null) return [];
+  switch (typeof data) {
+    case "string":
+    case "number":
+      return [data];
+    case "object":
+      const iterable = Array.isArray(data) ? data : Object.values(data);
+      return iterable.reduce((acc, item) => [...acc, ...extract(item)], []);
+  }
+  return [];
+};
+
+export const plurialize = (word, count) => {
+  const format = new Intl.PluralRules("fr-FR", { type: "cardinal" });
+  const plural = PLURALS[word];
+  if (!plural) return "⚠️ No Plural Found ⚠️";
+  return PLURALS[word][format.select(count)];
+};
+
+export const transform = (...args) => {
+  const result = args.flatMap((arg) => {
+    if (Array.isArray(arg)) return arg.map((item) => transform(item));
+    if (typeof arg === "number") return `${arg}`;
+    if (Dates.valid(arg)) return [Dates.Date.format(arg), Dates.Day.dayOfMonth(arg)];
+    return serialize(arg);
+  });
+  return result.flat();
+};
+
+export const interpolate = (template = "", ...args) => {
+  const line = template.replace(/{(\d+)}/g, (match, index) => args[index] || match);
+  return line;
+};
+
+export const mix = (characters = CHARACTERS) => characters[Math.floor(Math.random() * characters.length)];
+
+export const shake = (characters = CHARACTERS, min, max) =>
+  Array(Numbers.shake(min, max))
+    .fill("")
+    .map(() => mix(characters))
+    .join("");
+
+export const search = (data, text) => {
+  if (!text) return data;
+
+  const query = serialize(text);
+
+  const { precise, shallow, fuzzy } = data.reduce(
+    (acc, item) => {
+      const flattened = extract(item);
+      const transformed = transform(flattened);
+      const serialized = serialize(transformed.join(" "));
+
+      const precise = Search.precise(serialized, query);
+      const shallow = Search.shallow(serialized, query);
+      const fuzzy = Search.fuzzy(serialized, query);
+
+      return precise
+        ? { ...acc, precise: [...acc.precise, item] }
+        : shallow
+          ? { ...acc, shallow: [...acc.shallow, item] }
+          : fuzzy
+            ? { ...acc, fuzzy: [...acc.fuzzy, item] }
+            : acc;
+    },
+    { precise: [], shallow: [], fuzzy: [] }
+  );
+
+  return precise.length ? precise : shallow.length ? shallow : fuzzy;
+};

package/src/strings/plurals.js

@@ -0,0 +1,36 @@
+const PLURALS = {
+  day: {
+    one: "jour",
+    other: "jours"
+  },
+  lead: {
+    one: "lead",
+    other: "leads"
+  },
+  application: {
+    one: "demande",
+    other: "demandes"
+  },
+  tendering: {
+    one: "appel d'offre",
+    other: "appels d'offres"
+  },
+  structure: {
+    one: "bâtiment",
+    other: "bâtiments"
+  },
+  apartment: {
+    one: "appartment",
+    other: "appartments"
+  },
+  shop: {
+    one: "commerce",
+    other: "commerces"
+  },
+  application: {
+    one: "demande",
+    other: "demandes"
+  }
+};
+
+export default PLURALS;

package/src/strings/search.js

@@ -0,0 +1,16 @@
+export const precise = (serialization, query) => serialization.includes(query);
+
+export const shallow = (serialization, query) => {
+  const words = query.split("-").filter(Boolean);
+  return words.some((word) => serialization.includes(word));
+};
+
+export const fuzzy = (serialization, query) => {
+  const lowercase = query.toLowerCase();
+  let iteration = 0; // Don't try this home - Vincent
+
+  return [...serialization.toLowerCase()].some((character) => {
+    if (character === lowercase[iteration]) iteration++;
+    return iteration === lowercase.length;
+  });
+};

package/src/token.js

@@ -0,0 +1,10 @@
+const b64DecodeUnicode = (str) => decodeURIComponent(encodeURIComponent(Buffer.from(str, "base64")));
+
+export const parse = (token) => {
+  const [header, payload] = token.split(".");
+  try {
+    return JSON.parse(b64DecodeUnicode(payload));
+  } catch (e) {
+    throw Error("Jeton de sécurité invalide");
+  }
+};

package/src/uuid.js

@@ -0,0 +1,7 @@
+export const generate = () => {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (chain) => {
+    const random = (Math.random() * 16) | 0;
+    const value = chain === "x" ? random : (random & 0x3) | 0x8;
+    return value.toString(16);
+  });
+};

package/src/validation.js

@@ -0,0 +1,2 @@
+export const EMAIL =
+  /([-!#-'*+/-9=?A-Z^-~]+(\.[-!#-'*+/-9=?A-Z^-~]+)*|"([]!#-[^-~ \t]|(\\[\t -~]))+")@([0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?(\.[0-9A-Za-z]([0-9A-Za-z-]{0,61}[0-9A-Za-z])?)*|\[((25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3}|IPv6:((((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){6}|::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){5}|[0-9A-Fa-f]{0,4}::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){4}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):)?(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){3}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,2}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){2}|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,3}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,4}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::)((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,5}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3})|(((0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}):){0,6}(0|[1-9A-Fa-f][0-9A-Fa-f]{0,3}))?::)|(?!IPv6:)[0-9A-Za-z-]*[0-9A-Za-z]:[!-Z^-~]+)])/;