@bccampus/utils 0.2.3 → 0.3.0

package/dist/string/pluralize/pluralize.js

@@ -2,209 +2,162 @@ import { IRREGULAR_WORDS } from "./rules/irregular.js";
 import { PLURALIZATION_RULES } from "./rules/pluralization.js";
 import { SINGULARIZATION_RULES } from "./rules/singularization.js";
 import { UNCOUNTABLE_WORDS } from "./rules/uncountable.js";
-const TagIndexRegExp = /\$(\d{1,2})/g;
-class Pluralize {
-  // Rule storage - pluralize and singularize need to be run sequentially,
-  // while other rules can be optimized using an object for instant lookups.
-  pluralRules = [];
-  singularRules = [];
-  uncountables = {};
-  irregularPlurals = {};
-  irregularSingles = {};
-  constructor() {
-    for (let index = 0; index < IRREGULAR_WORDS.length; index += 1) {
-      this.addIrregularRule(
-        IRREGULAR_WORDS[index][0],
-        IRREGULAR_WORDS[index][1]
-      );
-    }
-    for (let index = 0; index < PLURALIZATION_RULES.length; index += 1) {
-      this.addPluralRule(
-        PLURALIZATION_RULES[index][0],
-        PLURALIZATION_RULES[index][1]
-      );
-    }
-    for (let index = 0; index < SINGULARIZATION_RULES.length; index += 1) {
-      this.addSingularRule(
-        SINGULARIZATION_RULES[index][0],
-        SINGULARIZATION_RULES[index][1]
-      );
-    }
-    for (let index = 0; index < UNCOUNTABLE_WORDS.length; index += 1) {
-      this.addUncountableRule(UNCOUNTABLE_WORDS[index]);
-    }
-  }
-  /**
-   * Add a pluralization rule to the collection.
-   */
-  addPluralRule(rule, replacement) {
-    this.pluralRules.push([this.sanitizeRule(rule), replacement]);
-  }
-  /**
-   * Add a singularization rule to the collection.
-   */
-  addSingularRule(rule, replacement) {
-    this.singularRules.push([this.sanitizeRule(rule), replacement]);
-  }
-  /**
-   * Add an uncountable word rule.
-   */
-  addUncountableRule(word) {
-    if (typeof word === "string") {
-      this.uncountables[word.toLowerCase()] = true;
-      return;
-    }
-    this.addPluralRule(word, "$0");
-    this.addSingularRule(word, "$0");
-  }
-  /**
-   * Add an irregular word definition.
-   *
-   * @param {string} single
-   * @param {string} plural
-   */
-  addIrregularRule(single, plural) {
-    plural = plural.toLowerCase();
-    single = single.toLowerCase();
-    this.irregularSingles[single] = plural;
-    this.irregularPlurals[plural] = single;
-  }
-  /**
-   * Sanitize a pluralization rule to a usable regular expression.
-   */
-  sanitizeRule(rule) {
-    if (typeof rule === "string") {
-      return new RegExp(`^${rule}$`, "i");
-    }
-    return rule;
-  }
-  /**
-   * Pass in a word token to produce a function that can replicate the case on
-   * another word.
-   */
-  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();
-  }
-  /**
-   * Interpolate a regexp string.
-   *
-   * @param  {string} str
-   * @param  {Array}  args
-   * @return {string}
-   */
-  interpolate(str, args) {
-    return str.replace(TagIndexRegExp, (match, index) => {
-      return args[index] || "";
-    });
-  }
-  /**
-   * Replace a word using a rule.
-   */
-  replace(word, rule) {
-    return word.replace(rule[0], (match, index, ...args) => {
-      const result = this.interpolate(rule[1], args);
-      if (match === "") {
-        return this.restoreCase(word[index - 1], result);
-      }
-      return this.restoreCase(match, result);
-    });
-  }
-  /**
-   * Sanitize a word by passing in the word and sanitization rules.
-   */
-  sanitizeWord(token, word, rules) {
-    if (!token.length || this.uncountables[token]) {
-      return word;
-    }
-    let len = rules.length;
-    while (len--) {
-      const rule = rules[len];
-      if (typeof rule[0] === "string" || rule[0].test(word))
-        return this.replace(word, rule);
-    }
-    return word;
-  }
-  /**
-   * Replace a word with the updated word.
-   */
-  old_replaceWord(replaceMap, keepMap, rules) {
-    return (word) => {
-      const token = word.toLowerCase();
-      if (keepMap[token]) {
-        return this.restoreCase(word, token);
-      }
-      if (replaceMap[token]) {
-        return this.restoreCase(word, replaceMap[token]);
-      }
-      return this.sanitizeWord(token, word, rules);
-    };
-  }
-  /**
-   * Replace a word with the updated word.
-   */
-  replaceWord(word, direction) {
-    const replaceMap = direction === "SingularToPlural" ? this.irregularSingles : this.irregularPlurals;
-    const keepMap = direction === "SingularToPlural" ? this.irregularPlurals : this.irregularSingles;
-    const rules = direction === "SingularToPlural" ? this.pluralRules : this.singularRules;
-    const token = word.toLowerCase();
-    if (keepMap[token]) {
-      return this.restoreCase(word, token);
-    }
-    if (replaceMap[token]) {
-      return this.restoreCase(word, replaceMap[token]);
-    }
-    return this.sanitizeWord(token, word, rules);
-  }
-  /**
-   * Check if a word is part of the map.
-   */
-  checkWord(word, reason) {
-    const replaceMap = reason === "Plurality" ? this.irregularSingles : this.irregularPlurals;
-    const keepMap = reason === "Plurality" ? this.irregularPlurals : this.irregularSingles;
-    const rules = reason === "Singularity" ? this.pluralRules : this.singularRules;
-    const token = word.toLowerCase();
-    if (keepMap[token]) return true;
-    if (replaceMap[token]) return false;
-    return this.sanitizeWord(token, token, rules) === token;
-  }
-  /**
-   * Pluralize or singularize a word based on the passed in count.
-   */
-  pluralize(word, count, inclusive) {
-    const pluralized = count === 1 ? this.singular(word) : this.plural(word);
-    return (inclusive ? `${count} ` : "") + pluralized;
-  }
-  /**
-   * Pluralize a word.
-   */
-  plural(singularWord) {
-    return this.replaceWord(singularWord, "SingularToPlural");
-  }
-  /**
-   * Check if a word is plural.
-   */
-  isPlural(word) {
-    this.checkWord(word, "Plurality");
-  }
-  /**
-   * Singularize a word.
-   */
-  singular(pluralWord) {
-    return this.replaceWord(pluralWord, "PluralToSingular");
-  }
-  /**
-   * Check if a word is singular.
-   */
-  isSingular(word) {
-    this.checkWord(word, "Singularity");
-  }
-}
-export {
-  Pluralize
+//#region src/string/pluralize/pluralize.ts
+var TagIndexRegExp = /\$(\d{1,2})/g;
+var Pluralize = class {
+	pluralRules = [];
+	singularRules = [];
+	uncountables = {};
+	irregularPlurals = {};
+	irregularSingles = {};
+	constructor() {
+		for (let index = 0; index < IRREGULAR_WORDS.length; index += 1) this.addIrregularRule(IRREGULAR_WORDS[index][0], IRREGULAR_WORDS[index][1]);
+		for (let index = 0; index < PLURALIZATION_RULES.length; index += 1) this.addPluralRule(PLURALIZATION_RULES[index][0], PLURALIZATION_RULES[index][1]);
+		for (let index = 0; index < SINGULARIZATION_RULES.length; index += 1) this.addSingularRule(SINGULARIZATION_RULES[index][0], SINGULARIZATION_RULES[index][1]);
+		for (let index = 0; index < UNCOUNTABLE_WORDS.length; index += 1) this.addUncountableRule(UNCOUNTABLE_WORDS[index]);
+	}
+	/**
+	* Add a pluralization rule to the collection.
+	*/
+	addPluralRule(rule, replacement) {
+		this.pluralRules.push([this.sanitizeRule(rule), replacement]);
+	}
+	/**
+	* Add a singularization rule to the collection.
+	*/
+	addSingularRule(rule, replacement) {
+		this.singularRules.push([this.sanitizeRule(rule), replacement]);
+	}
+	/**
+	* Add an uncountable word rule.
+	*/
+	addUncountableRule(word) {
+		if (typeof word === "string") {
+			this.uncountables[word.toLowerCase()] = true;
+			return;
+		}
+		this.addPluralRule(word, "$0");
+		this.addSingularRule(word, "$0");
+	}
+	/**
+	* Add an irregular word definition.
+	*
+	* @param {string} single
+	* @param {string} plural
+	*/
+	addIrregularRule(single, plural) {
+		plural = plural.toLowerCase();
+		single = single.toLowerCase();
+		this.irregularSingles[single] = plural;
+		this.irregularPlurals[plural] = single;
+	}
+	/**
+	* Sanitize a pluralization rule to a usable regular expression.
+	*/
+	sanitizeRule(rule) {
+		if (typeof rule === "string") return new RegExp(`^${rule}$`, "i");
+		return rule;
+	}
+	/**
+	* Pass in a word token to produce a function that can replicate the case on
+	* another word.
+	*/
+	restoreCase(word, token) {
+		if (word === token) return token;
+		if (word === word.toUpperCase()) return token.toUpperCase();
+		if (word[0] === word[0].toUpperCase()) return token.charAt(0).toUpperCase() + token.substring(1).toLowerCase();
+		return token.toLowerCase();
+	}
+	/**
+	* Interpolate a regexp string.
+	*
+	* @param  {string} str
+	* @param  {Array}  args
+	* @return {string}
+	*/
+	interpolate(str, args) {
+		return str.replace(TagIndexRegExp, (match, index) => {
+			return args[index] || "";
+		});
+	}
+	/**
+	* Replace a word using a rule.
+	*/
+	replace(word, rule) {
+		return word.replace(rule[0], (...args) => {
+			const [match, index] = args;
+			const result = this.interpolate(rule[1], args);
+			if (match === "") return this.restoreCase(word[index - 1], result);
+			return this.restoreCase(match, result);
+		});
+	}
+	/**
+	* Sanitize a word by passing in the word and sanitization rules.
+	*/
+	sanitizeWord(token, word, rules) {
+		if (!token.length || this.uncountables[token]) return word;
+		let len = rules.length;
+		while (len--) {
+			const rule = rules[len];
+			if (typeof rule[0] === "string" || rule[0].test(word)) return this.replace(word, rule);
+		}
+		return word;
+	}
+	/**
+	* Replace a word with the updated word.
+	*/
+	replaceWord(word, direction) {
+		const replaceMap = direction === "SingularToPlural" ? this.irregularSingles : this.irregularPlurals;
+		const keepMap = direction === "SingularToPlural" ? this.irregularPlurals : this.irregularSingles;
+		const rules = direction === "SingularToPlural" ? this.pluralRules : this.singularRules;
+		const token = word.toLowerCase();
+		if (keepMap[token]) return this.restoreCase(word, token);
+		if (replaceMap[token]) return this.restoreCase(word, replaceMap[token]);
+		return this.sanitizeWord(token, word, rules);
+	}
+	/**
+	* Check if a word is part of the map.
+	*/
+	checkWord(word, reason) {
+		const replaceMap = reason === "Plurality" ? this.irregularSingles : this.irregularPlurals;
+		const keepMap = reason === "Plurality" ? this.irregularPlurals : this.irregularSingles;
+		const rules = reason === "Plurality" ? this.pluralRules : this.singularRules;
+		const token = word.toLowerCase();
+		if (keepMap[token]) return true;
+		if (replaceMap[token]) return false;
+		return this.sanitizeWord(token, token, rules) === token;
+	}
+	/**
+	* Pluralize or singularize a word based on the passed in count.
+	*/
+	pluralize(word, count, inclusive = false) {
+		const pluralized = count === 1 ? this.singular(word) : this.plural(word);
+		return (inclusive ? `${count} ` : "") + pluralized;
+	}
+	/**
+	* Pluralize a word.
+	*/
+	plural(singularWord) {
+		return this.replaceWord(singularWord, "SingularToPlural");
+	}
+	/**
+	* Check if a word is plural.
+	*/
+	isPlural(word) {
+		return this.checkWord(word, "Plurality");
+	}
+	/**
+	* Singularize a word.
+	*/
+	singular(pluralWord) {
+		return this.replaceWord(pluralWord, "PluralToSingular");
+	}
+	/**
+	* Check if a word is singular.
+	*/
+	isSingular(word) {
+		return this.checkWord(word, "Singularity");
+	}
 };
+//#endregion
+export { Pluralize };

package/dist/string/pluralize/pluralize.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/string/pluralize/rules/index.cjs

@@ -1,10 +1,9 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const string_pluralize_rules_irregular = require("./irregular.cjs");
-const string_pluralize_rules_pluralization = require("./pluralization.cjs");
-const string_pluralize_rules_singularization = require("./singularization.cjs");
-const string_pluralize_rules_uncountable = require("./uncountable.cjs");
-exports.IRREGULAR_WORDS = string_pluralize_rules_irregular.IRREGULAR_WORDS;
-exports.PLURALIZATION_RULES = string_pluralize_rules_pluralization.PLURALIZATION_RULES;
-exports.SINGULARIZATION_RULES = string_pluralize_rules_singularization.SINGULARIZATION_RULES;
-exports.UNCOUNTABLE_WORDS = string_pluralize_rules_uncountable.UNCOUNTABLE_WORDS;
+const require_string_pluralize_rules_irregular = require("./irregular.cjs");
+const require_string_pluralize_rules_pluralization = require("./pluralization.cjs");
+const require_string_pluralize_rules_singularization = require("./singularization.cjs");
+const require_string_pluralize_rules_uncountable = require("./uncountable.cjs");
+exports.IRREGULAR_WORDS = require_string_pluralize_rules_irregular.IRREGULAR_WORDS;
+exports.PLURALIZATION_RULES = require_string_pluralize_rules_pluralization.PLURALIZATION_RULES;
+exports.SINGULARIZATION_RULES = require_string_pluralize_rules_singularization.SINGULARIZATION_RULES;
+exports.UNCOUNTABLE_WORDS = require_string_pluralize_rules_uncountable.UNCOUNTABLE_WORDS;

package/dist/string/pluralize/rules/index.js

@@ -2,9 +2,4 @@ import { IRREGULAR_WORDS } from "./irregular.js";
 import { PLURALIZATION_RULES } from "./pluralization.js";
 import { SINGULARIZATION_RULES } from "./singularization.js";
 import { UNCOUNTABLE_WORDS } from "./uncountable.js";
-export {
-  IRREGULAR_WORDS,
-  PLURALIZATION_RULES,
-  SINGULARIZATION_RULES,
-  UNCOUNTABLE_WORDS
-};
+export { IRREGULAR_WORDS, PLURALIZATION_RULES, SINGULARIZATION_RULES, UNCOUNTABLE_WORDS };

package/dist/string/pluralize/rules/irregular.cjs

@@ -1,62 +1,58 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const IRREGULAR_WORDS = [
-  // 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"],
-  ["my", "our"],
-  ["its", "their"],
-  ["his", "their"],
-  ["her", "their"],
-  // Words ending in 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"],
-  ["canvas", "canvases"]
+//#region src/string/pluralize/rules/irregular.ts
+var IRREGULAR_WORDS = [
+	["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"],
+	["my", "our"],
+	["its", "their"],
+	["his", "their"],
+	["her", "their"],
+	["echo", "echoes"],
+	["dingo", "dingoes"],
+	["volcano", "volcanoes"],
+	["tornado", "tornadoes"],
+	["torpedo", "torpedoes"],
+	["genus", "genera"],
+	["viscus", "viscera"],
+	["stigma", "stigmata"],
+	["stoma", "stomata"],
+	["dogma", "dogmata"],
+	["lemma", "lemmata"],
+	["schema", "schemata"],
+	["anathema", "anathemata"],
+	["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"],
+	["canvas", "canvases"]
 ];
+//#endregion
 exports.IRREGULAR_WORDS = IRREGULAR_WORDS;

package/dist/string/pluralize/rules/irregular.js

@@ -1,62 +1,57 @@
-const IRREGULAR_WORDS = [
-  // 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"],
-  ["my", "our"],
-  ["its", "their"],
-  ["his", "their"],
-  ["her", "their"],
-  // Words ending in 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"],
-  ["canvas", "canvases"]
+//#region src/string/pluralize/rules/irregular.ts
+var IRREGULAR_WORDS = [
+	["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"],
+	["my", "our"],
+	["its", "their"],
+	["his", "their"],
+	["her", "their"],
+	["echo", "echoes"],
+	["dingo", "dingoes"],
+	["volcano", "volcanoes"],
+	["tornado", "tornadoes"],
+	["torpedo", "torpedoes"],
+	["genus", "genera"],
+	["viscus", "viscera"],
+	["stigma", "stigmata"],
+	["stoma", "stomata"],
+	["dogma", "dogmata"],
+	["lemma", "lemmata"],
+	["schema", "schemata"],
+	["anathema", "anathemata"],
+	["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"],
+	["canvas", "canvases"]
 ];
-export {
-  IRREGULAR_WORDS
-};
+//#endregion
+export { IRREGULAR_WORDS };