@splendidlabz/utils 1.11.6 → 1.12.1

package/dist/esm/lib/strings/pluralize.js

@@ -1,5 +1,368 @@
-import pluralizeLib from "pluralize";
-const pluralize = pluralizeLib;
+function sanitizeRule(rule) {
+  if (typeof rule === "string") return new RegExp("^" + rule + "$", "i");
+  return rule;
+}
+function restoreCase(word, token) {
+  if (word === token) return token;
+  if (word === word.toLowerCase()) return token.toLowerCase();
+  if (word === word.toUpperCase()) return token.toUpperCase();
+  if (word[0] === word[0].toUpperCase()) {
+    return token.charAt(0).toUpperCase() + token.substr(1).toLowerCase();
+  }
+  return token.toLowerCase();
+}
+function interpolate(str, args) {
+  return str.replace(/\$(\d{1,2})/g, (match, index) => args[index] || "");
+}
+function replace(word, rule) {
+  return word.replace(rule[0], function(match, index) {
+    const result = interpolate(rule[1], arguments);
+    if (match === "") return restoreCase(word[index - 1], result);
+    return restoreCase(match, result);
+  });
+}
+function sanitizeWord(token, word, rules, uncountables) {
+  if (!token.length || uncountables.hasOwnProperty(token)) return word;
+  let len = rules.length;
+  while (len--) {
+    const rule = rules[len];
+    if (rule[0].test(word)) return replace(word, rule);
+  }
+  return word;
+}
+function replaceWord(replaceMap, keepMap, rules, uncountables) {
+  return function(word) {
+    const token = word.toLowerCase();
+    if (keepMap.hasOwnProperty(token)) return restoreCase(word, token);
+    if (replaceMap.hasOwnProperty(token)) {
+      return restoreCase(word, replaceMap[token]);
+    }
+    return sanitizeWord(token, word, rules, uncountables);
+  };
+}
+function checkWord(replaceMap, keepMap, rules, uncountables) {
+  return function(word) {
+    const token = word.toLowerCase();
+    if (keepMap.hasOwnProperty(token)) return true;
+    if (replaceMap.hasOwnProperty(token)) return false;
+    return sanitizeWord(token, token, rules, uncountables) === token;
+  };
+}
+const BASE_IRREGULAR = [
+  // Pronouns.
+  ["I", "we"],
+  ["me", "us"],
+  ["he", "they"],
+  ["she", "they"],
+  ["them", "them"],
+  ["myself", "ourselves"],
+  ["yourself", "yourselves"],
+  ["itself", "themselves"],
+  ["herself", "themselves"],
+  ["himself", "themselves"],
+  ["themself", "themselves"],
+  ["is", "are"],
+  ["was", "were"],
+  ["has", "have"],
+  ["this", "these"],
+  ["that", "those"],
+  // Words ending with a consonant and `o`.
+  ["echo", "echoes"],
+  ["dingo", "dingoes"],
+  ["volcano", "volcanoes"],
+  ["tornado", "tornadoes"],
+  ["torpedo", "torpedoes"],
+  // Ends with `us`.
+  ["genus", "genera"],
+  ["viscus", "viscera"],
+  // Ends with `ma`.
+  ["stigma", "stigmata"],
+  ["stoma", "stomata"],
+  ["dogma", "dogmata"],
+  ["lemma", "lemmata"],
+  ["schema", "schemata"],
+  ["anathema", "anathemata"],
+  // Other irregular rules.
+  ["ox", "oxen"],
+  ["axe", "axes"],
+  ["die", "dice"],
+  ["yes", "yeses"],
+  ["foot", "feet"],
+  ["eave", "eaves"],
+  ["goose", "geese"],
+  ["tooth", "teeth"],
+  ["quiz", "quizzes"],
+  ["human", "humans"],
+  ["proof", "proofs"],
+  ["carve", "carves"],
+  ["valve", "valves"],
+  ["looey", "looies"],
+  ["thief", "thieves"],
+  ["groove", "grooves"],
+  ["pickaxe", "pickaxes"],
+  ["passerby", "passersby"]
+];
+const BASE_PLURAL = [
+  [/s?$/i, "s"],
+  // eslint-disable-next-line no-control-regex
+  [/[^\u0000-\u007F]$/i, "$0"],
+  [/([^aeiou]ese)$/i, "$1"],
+  [/(ax|test)is$/i, "$1es"],
+  [/(alias|[^aou]us|t[lm]as|gas|ris)$/i, "$1es"],
+  [/(e[mn]u)s?$/i, "$1s"],
+  [/([^l]ias|[aeiou]las|[ejzr]as|[iu]am)$/i, "$1"],
+  [
+    /(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i,
+    "$1i"
+  ],
+  [/(alumn|alg|vertebr)(?:a|ae)$/i, "$1ae"],
+  [/(seraph|cherub)(?:im)?$/i, "$1im"],
+  [/(her|at|gr)o$/i, "$1oes"],
+  [
+    /(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|automat|quor)(?:a|um)$/i,
+    "$1a"
+  ],
+  [
+    /(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)(?:a|on)$/i,
+    "$1a"
+  ],
+  [/sis$/i, "ses"],
+  [/(?:(kni|wi|li)fe|(ar|l|ea|eo|oa|hoo)f)$/i, "$1$2ves"],
+  [/([^aeiouy]|qu)y$/i, "$1ies"],
+  [/([^ch][ieo][ln])ey$/i, "$1ies"],
+  [/(x|ch|ss|sh|zz)$/i, "$1es"],
+  [/(matr|cod|mur|sil|vert|ind|append)(?:ix|ex)$/i, "$1ices"],
+  [/\b((?:tit)?m|l)(?:ice|ouse)$/i, "$1ice"],
+  [/(pe)(?:rson|ople)$/i, "$1ople"],
+  [/(child)(?:ren)?$/i, "$1ren"],
+  [/eaux$/i, "$0"],
+  [/m[ae]n$/i, "men"],
+  ["thou", "you"]
+];
+const BASE_SINGULAR = [
+  [/s$/i, ""],
+  [/(ss)$/i, "$1"],
+  [/(wi|kni|(?:after|half|high|low|mid|non|night|[^\w]|^)li)ves$/i, "$1fe"],
+  [/(ar|(?:wo|[ae])l|[eo][ao])ves$/i, "$1f"],
+  [/ies$/i, "y"],
+  [
+    /\b([pl]|zomb|(?:neck|cross)?t|coll|faer|food|gen|goon|group|lass|talk|goal|cut)ies$/i,
+    "$1ie"
+  ],
+  [/\b(mon|smil)ies$/i, "$1ey"],
+  [/\b((?:tit)?m|l)ice$/i, "$1ouse"],
+  [/(seraph|cherub)im$/i, "$1"],
+  [
+    /(x|ch|ss|sh|zz|tto|go|cho|alias|[^aou]us|t[lm]as|gas|(?:her|at|gr)o|[aeiou]ris)(?:es)?$/i,
+    "$1"
+  ],
+  [
+    /(analy|diagno|parenthe|progno|synop|the|empha|cri|ne)(?:sis|ses)$/i,
+    "$1sis"
+  ],
+  [/(movie|twelve|abuse|e[mn]u)s$/i, "$1"],
+  [/(test)(?:is|es)$/i, "$1is"],
+  [
+    /(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i,
+    "$1us"
+  ],
+  [
+    /(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|quor)a$/i,
+    "$1um"
+  ],
+  [
+    /(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)a$/i,
+    "$1on"
+  ],
+  [/(alumn|alg|vertebr)ae$/i, "$1a"],
+  [/(cod|mur|sil|vert|ind)ices$/i, "$1ex"],
+  [/(matr|append)ices$/i, "$1ix"],
+  [/(pe)(rson|ople)$/i, "$1rson"],
+  [/(child)ren$/i, "$1"],
+  [/(eau)x?$/i, "$1"],
+  [/men$/i, "man"]
+];
+const BASE_UNCOUNTABLE = [
+  // Singular words with no plurals.
+  "adulthood",
+  "advice",
+  "agenda",
+  "aid",
+  "aircraft",
+  "alcohol",
+  "ammo",
+  "analytics",
+  "anime",
+  "athletics",
+  "audio",
+  "bison",
+  "blood",
+  "bream",
+  "buffalo",
+  "butter",
+  "carp",
+  "cash",
+  "chassis",
+  "chess",
+  "clothing",
+  "cod",
+  "commerce",
+  "cooperation",
+  "corps",
+  "debris",
+  "diabetes",
+  "digestion",
+  "elk",
+  "energy",
+  "equipment",
+  "excretion",
+  "expertise",
+  "firmware",
+  "flounder",
+  "fun",
+  "gallows",
+  "garbage",
+  "graffiti",
+  "hardware",
+  "headquarters",
+  "health",
+  "herpes",
+  "highjinks",
+  "homework",
+  "housework",
+  "information",
+  "jeans",
+  "justice",
+  "kudos",
+  "labour",
+  "literature",
+  "machinery",
+  "mackerel",
+  "mail",
+  "media",
+  "mews",
+  "moose",
+  "music",
+  "mud",
+  "manga",
+  "news",
+  "only",
+  "personnel",
+  "pike",
+  "plankton",
+  "pliers",
+  "police",
+  "pollution",
+  "premises",
+  "rain",
+  "research",
+  "rice",
+  "salmon",
+  "scissors",
+  "series",
+  "sewage",
+  "shambles",
+  "shrimp",
+  "software",
+  "species",
+  "staff",
+  "swine",
+  "tennis",
+  "traffic",
+  "transportation",
+  "trout",
+  "tuna",
+  "wealth",
+  "welfare",
+  "whiting",
+  "wildebeest",
+  "wildlife",
+  "you",
+  /pok[eé]mon$/i,
+  // Regexes.
+  /[^aeiou]ese$/i,
+  // "chinese", "japanese"
+  /deer$/i,
+  // "deer", "reindeer"
+  /fish$/i,
+  // "fish", "blowfish", "angelfish"
+  /measles$/i,
+  /o[iu]s$/i,
+  // "carnivorous"
+  /pox$/i,
+  // "chickpox", "smallpox"
+  /sheep$/i
+];
+function createPluralize(config = {}) {
+  const pluralRules = [];
+  const singularRules = [];
+  const uncountables = {};
+  const irregularPlurals = {};
+  const irregularSingles = {};
+  for (const [single, plur] of [
+    ...BASE_IRREGULAR,
+    ...config.irregular || []
+  ]) {
+    irregularSingles[single.toLowerCase()] = plur.toLowerCase();
+    irregularPlurals[plur.toLowerCase()] = single.toLowerCase();
+  }
+  for (const [rule, replacement] of [...BASE_PLURAL, ...config.plural || []]) {
+    pluralRules.push([sanitizeRule(rule), replacement]);
+  }
+  for (const [rule, replacement] of [
+    ...BASE_SINGULAR,
+    ...config.singular || []
+  ]) {
+    singularRules.push([sanitizeRule(rule), replacement]);
+  }
+  for (const word of [...BASE_UNCOUNTABLE, ...config.uncountable || []]) {
+    if (typeof word === "string") {
+      uncountables[word.toLowerCase()] = true;
+    } else {
+      pluralRules.push([sanitizeRule(word), "$0"]);
+      singularRules.push([sanitizeRule(word), "$0"]);
+    }
+  }
+  const plural2 = replaceWord(
+    irregularSingles,
+    irregularPlurals,
+    pluralRules,
+    uncountables
+  );
+  const singular2 = replaceWord(
+    irregularPlurals,
+    irregularSingles,
+    singularRules,
+    uncountables
+  );
+  const isPlural2 = checkWord(
+    irregularSingles,
+    irregularPlurals,
+    pluralRules,
+    uncountables
+  );
+  const isSingular2 = checkWord(
+    irregularPlurals,
+    irregularSingles,
+    singularRules,
+    uncountables
+  );
+  function pluralize2(word, count, inclusive) {
+    const out = count === 1 ? singular2(word) : plural2(word);
+    return (inclusive ? count + " " : "") + out;
+  }
+  return Object.assign(pluralize2, { plural: plural2, singular: singular2, isPlural: isPlural2, isSingular: isSingular2 });
+}
+const pluralize = createPluralize();
+const plural = pluralize.plural;
+const singular = pluralize.singular;
+const isPlural = pluralize.isPlural;
+const isSingular = pluralize.isSingular;
 export {
-  pluralize
+  createPluralize,
+  isPlural,
+  isSingular,
+  plural,
+  pluralize,
+  singular
 };

package/dist/esm/lib/strings/query-string.js

@@ -2,15 +2,38 @@ function toQueryString(object) {
   const searchParams = new URLSearchParams(object);
   return searchParams.toString();
 }
-function plural(count, noun, suffix = "s") {
-  console.warn("plural is deprecated. Use pluralize instead");
-  return `${count} ${noun}${count !== 1 ? suffix : ""}`;
+function parseQueryString(string = "") {
+  const query = string.startsWith("?") ? string.slice(1) : string;
+  const result = {};
+  if (!query) return result;
+  const decode = (str) => decodeURIComponent(str.replace(/\+/g, " "));
+  const keyToPath = (key) => key.replace(/\]/g, "").split("[").map(decode);
+  for (const pair of query.split("&")) {
+    if (!pair) continue;
+    const eq = pair.indexOf("=");
+    const path = keyToPath(eq === -1 ? pair : pair.slice(0, eq));
+    const value = decode(eq === -1 ? "" : pair.slice(eq + 1));
+    let current = result;
+    path.forEach((key, i) => {
+      const index = Array.isArray(current) ? Number(key) : key;
+      if (i === path.length - 1) {
+        if (key === "") current.push(value);
+        else current[index] = value;
+        return;
+      }
+      const next = path[i + 1];
+      const childIsArray = next === "" || /^\d+$/.test(next);
+      if (current[index] == null) current[index] = childIsArray ? [] : {};
+      current = current[index];
+    });
+  }
+  return result;
 }
 function stripNumbers(string) {
   return string.replace(/\d*/, "");
 }
 export {
-  plural,
+  parseQueryString,
   stripNumbers,
   toQueryString
 };

package/dist/types/lib/http/index.d.cts

@@ -0,0 +1 @@
+export { statusText, statusTexts } from './status-text.cjs';

package/dist/types/lib/http/status-text.d.cts

@@ -0,0 +1,73 @@
+/**
+ * Reason phrase for an HTTP status code.
+ * @param {number} code - HTTP status code.
+ * @returns {string|undefined} The reason phrase, or undefined if unknown.
+ */
+declare function statusText(code: number): string | undefined;
+declare const statusTexts: {
+    100: string;
+    101: string;
+    102: string;
+    103: string;
+    200: string;
+    201: string;
+    202: string;
+    203: string;
+    204: string;
+    205: string;
+    206: string;
+    207: string;
+    208: string;
+    226: string;
+    300: string;
+    301: string;
+    302: string;
+    303: string;
+    304: string;
+    305: string;
+    307: string;
+    308: string;
+    400: string;
+    401: string;
+    402: string;
+    403: string;
+    404: string;
+    405: string;
+    406: string;
+    407: string;
+    408: string;
+    409: string;
+    410: string;
+    411: string;
+    412: string;
+    413: string;
+    414: string;
+    415: string;
+    416: string;
+    417: string;
+    418: string;
+    421: string;
+    422: string;
+    423: string;
+    424: string;
+    425: string;
+    426: string;
+    428: string;
+    429: string;
+    431: string;
+    451: string;
+    500: string;
+    501: string;
+    502: string;
+    503: string;
+    504: string;
+    505: string;
+    506: string;
+    507: string;
+    508: string;
+    509: string;
+    510: string;
+    511: string;
+};
+
+export { statusText, statusTexts };

package/dist/types/lib/index.d.cts

@@ -17,6 +17,7 @@ export { compose, composeAsync, curry, pipe, pipeAsync, times } from './function
 export { throttle } from './functions/throttle.cjs';
 export { delay, timeout, wait } from './functions/timeout.cjs';
 export { isHashedValue } from './hash.cjs';
+export { statusText, statusTexts } from './http/status-text.cjs';
 export { splitUnit } from './numbers/index.cjs';
 export { camelCaseKeys } from './objects/camelcase-keys.cjs';
 export { isEmpty, notEmpty } from './objects/empty.cjs';
@@ -36,8 +37,8 @@ export { createSSE, parseSSE } from './sse.cjs';
 export { toCamel, toKebab, toLower, toPascal, toSentence, toSlug, toTitle, toUpper } from './strings/convert-case/convert-case.cjs';
 export { markdown, treatMarkdownWhitespace } from './strings/markdown.cjs';
 export { parseFullName } from './strings/name.cjs';
-export { pluralize } from './strings/pluralize.cjs';
-export { plural, stripNumbers, toQueryString } from './strings/query-string.cjs';
+export { createPluralize, isPlural, isSingular, plural, pluralize, singular } from './strings/pluralize.cjs';
+export { parseQueryString, stripNumbers, toQueryString } from './strings/query-string.cjs';
 export { toStyleString } from './style/index.cjs';
 export { getSymbol, getSymbolValue } from './symbols/symbols.cjs';
 export { toDegrees, toRadians } from './numbers/math.cjs';

package/dist/types/lib/strings/index.d.cts

@@ -1,5 +1,5 @@
 export { toCamel, toKebab, toLower, toPascal, toSentence, toSlug, toTitle, toUpper } from './convert-case/convert-case.cjs';
 export { markdown, treatMarkdownWhitespace } from './markdown.cjs';
 export { parseFullName } from './name.cjs';
-export { pluralize } from './pluralize.cjs';
-export { plural, stripNumbers, toQueryString } from './query-string.cjs';
+export { createPluralize, isPlural, isSingular, plural, pluralize, singular } from './pluralize.cjs';
+export { parseQueryString, stripNumbers, toQueryString } from './query-string.cjs';

package/dist/types/lib/strings/pluralize.d.cts

@@ -1,3 +1,25 @@
-declare const pluralize: any;
+/**
+ * Create a pluralizer with its own rule tables. Config rules are appended to
+ * the English base and take precedence (newest matching rule wins).
+ *
+ * @param  {Object} [config]
+ * @param  {Array}  [config.plural]      - `[rule, replacement]` pairs.
+ * @param  {Array}  [config.singular]    - `[rule, replacement]` pairs.
+ * @param  {Array}  [config.irregular]   - `[single, plural]` pairs.
+ * @param  {Array}  [config.uncountable] - words or regexes with no plural.
+ * @return {Function} A callable `pluralize` with `.plural`, `.singular`,
+ *                    `.isPlural`, `.isSingular` attached.
+ */
+declare function createPluralize(config?: {
+    plural?: any[];
+    singular?: any[];
+    irregular?: any[];
+    uncountable?: any[];
+}): Function;
+declare const pluralize: Function;
+declare const plural: any;
+declare const singular: any;
+declare const isPlural: any;
+declare const isSingular: any;
 
-export { pluralize };
+export { createPluralize, isPlural, isSingular, plural, pluralize, singular };

package/dist/types/lib/strings/query-string.d.cts

@@ -4,7 +4,15 @@
  * @returns
  */
 declare function toQueryString(object: any): string;
-declare function plural(count: any, noun: any, suffix?: string): string;
+/**
+ * Parses a query string into an object, expanding bracket-notation keys into
+ * nested objects and arrays (e.g. `order[charges][0][reference]=23`). Decodes
+ * percent-encoding and treats `+` as a space. Mirrors the subset of `qs.parse`
+ * needed for form-urlencoded webhook payloads.
+ * @param {string} [string]
+ * @returns {Object}
+ */
+declare function parseQueryString(string?: string): any;
 declare function stripNumbers(string: any): any;
 
-export { plural, stripNumbers, toQueryString };
+export { parseQueryString, stripNumbers, toQueryString };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splendidlabz/utils",
-  "version": "1.11.6",
+  "version": "1.12.1",
   "description": "",
   "type": "module",
   "homepage": "https://splendidlabz.com/docs/utils",
@@ -64,12 +64,10 @@
     "marked": "^18.0.2",
     "marked-gfm-heading-id": "^4.1.4",
     "marked-mangle": "^1.1.13",
-    "pluralize": "^8.0.0",
-    "sanitize-html": "^2.17.3",
-    "statuses": "^2.0.2"
+    "sanitize-html": "^2.17.3"
   },
   "devDependencies": {
-    "@splendidlabz/eslint-config": "2.1.4",
+    "@splendidlabz/eslint-config": "2.1.5",
     "jsdom": "^29.0.2",
     "np": "^11.1.0",
     "tsup": "^8.5.1",