@bccampus/utils 0.2.2 → 0.2.3

package/src/string/pluralize/pluralize.ts

@@ -1,296 +0,0 @@
-/**
- * Typscript version of [pluralize](https://github.com/plurals/pluralize)
- */
-
-import type { Rule, RuleKey, RuleValue } from "./types";
-
-import {
-  IRREGULAR_WORDS,
-  PLURALIZATION_RULES,
-  SINGULARIZATION_RULES,
-  UNCOUNTABLE_WORDS,
-} from "./rules";
-
-const TagIndexRegExp = /\$(\d{1,2})/g;
-
-export class Pluralize {
-  // Rule storage - pluralize and singularize need to be run sequentially,
-  // while other rules can be optimized using an object for instant lookups.
-  private pluralRules: Rule[] = [];
-  private singularRules: Rule[] = [];
-  private uncountables: Record<string, boolean> = {};
-  private irregularPlurals: Record<string, string> = {};
-  private irregularSingles: Record<string, string> = {};
-
-  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: RuleKey, replacement: RuleValue) {
-    this.pluralRules.push([this.sanitizeRule(rule), replacement]);
-  }
-
-  /**
-   * Add a singularization rule to the collection.
-   */
-  addSingularRule(rule: RuleKey, replacement: RuleValue) {
-    this.singularRules.push([this.sanitizeRule(rule), replacement]);
-  }
-
-  /**
-   * Add an uncountable word rule.
-   */
-  addUncountableRule(word: RuleKey) {
-    if (typeof word === "string") {
-      this.uncountables[word.toLowerCase()] = true;
-      return;
-    }
-
-    // Set singular and plural references for the word.
-    this.addPluralRule(word, "$0");
-    this.addSingularRule(word, "$0");
-  }
-
-  /**
-   * Add an irregular word definition.
-   *
-   * @param {string} single
-   * @param {string} plural
-   */
-  addIrregularRule(single: string, plural: string) {
-    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: RuleKey) {
-    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: string, token: string) {
-    // Tokens are an exact match.
-    if (word === token) return token;
-
-    // Lower cased words. E.g. "hello".
-    if (word === word.toLowerCase()) return token.toLowerCase();
-
-    // Upper cased words. E.g. "WHISKY".
-    if (word === word.toUpperCase()) return token.toUpperCase();
-
-    // Title cased words. E.g. "Title".
-    if (word[0] === word[0].toUpperCase()) {
-      return token.charAt(0).toUpperCase() + token.substr(1).toLowerCase();
-    }
-
-    // Lower cased words. E.g. "test".
-    return token.toLowerCase();
-  }
-
-  /**
-   * Interpolate a regexp string.
-   *
-   * @param  {string} str
-   * @param  {Array}  args
-   * @return {string}
-   */
-  interpolate(str: string, args: string[]) {
-    return str.replace(TagIndexRegExp, (match, index) => {
-      return args[index] || "";
-    });
-  }
-
-  /**
-   * Replace a word using a rule.
-   */
-  replace(word: string, rule: 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: string, word: string, rules: Rule[]) {
-    // Empty string or doesn't need fixing.
-    if (!token.length || this.uncountables[token]) {
-      return word;
-    }
-
-    let len = rules.length;
-
-    // Iterate over the sanitization rules and use the first one to match.
-    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: Record<string, string>,
-    keepMap: Record<string, string>,
-    rules: Rule[],
-  ) {
-    return (word: string) => {
-      // Get the correct token and case restoration functions.
-      const token = word.toLowerCase();
-
-      // Check against the keep object map.
-      if (keepMap[token]) {
-        return this.restoreCase(word, token);
-      }
-
-      // Check against the replacement map for a direct word replacement.
-      if (replaceMap[token]) {
-        return this.restoreCase(word, replaceMap[token]);
-      }
-
-      // Run all the rules against the word.
-      return this.sanitizeWord(token, word, rules);
-    };
-  }
-
-  /**
-   * Replace a word with the updated word.
-   */
-  private replaceWord(
-    word: string,
-    direction: "SingularToPlural" | "PluralToSingular",
-  ) {
-    const replaceMap =
-      direction === "SingularToPlural"
-        ? this.irregularSingles
-        : this.irregularPlurals;
-    const keepMap =
-      direction === "SingularToPlural"
-        ? this.irregularPlurals
-        : this.irregularSingles;
-    const rules =
-      direction === "SingularToPlural" ? this.pluralRules : this.singularRules;
-
-    // Get the correct token and case restoration functions.
-    const token = word.toLowerCase();
-
-    // Check against the keep object map.
-    if (keepMap[token]) {
-      return this.restoreCase(word, token);
-    }
-
-    // Check against the replacement map for a direct word replacement.
-    if (replaceMap[token]) {
-      return this.restoreCase(word, replaceMap[token]);
-    }
-
-    // Run all the rules against the word.
-    return this.sanitizeWord(token, word, rules);
-  }
-
-  /**
-   * Check if a word is part of the map.
-   */
-  private checkWord(word: string, reason: "Singularity" | "Plurality") {
-    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: string, count: number, inclusive: boolean) {
-    const pluralized = count === 1 ? this.singular(word) : this.plural(word);
-
-    return (inclusive ? `${count} ` : "") + pluralized;
-  }
-
-  /**
-   * Pluralize a word.
-   */
-  plural(singularWord: string) {
-    return this.replaceWord(singularWord, "SingularToPlural");
-  }
-
-  /**
-   * Check if a word is plural.
-   */
-  isPlural(word: string) {
-    this.checkWord(word, "Plurality");
-  }
-
-  /**
-   * Singularize a word.
-   */
-  singular(pluralWord: string) {
-    return this.replaceWord(pluralWord, "PluralToSingular");
-  }
-
-  /**
-   * Check if a word is singular.
-   */
-  isSingular(word: string) {
-    this.checkWord(word, "Singularity");
-  }
-}

package/src/string/pluralize/rules/index.ts

@@ -1,4 +0,0 @@
-export { IRREGULAR_WORDS } from './irregular';
-export { PLURALIZATION_RULES } from './pluralization';
-export { SINGULARIZATION_RULES } from './singularization';
-export { UNCOUNTABLE_WORDS } from './uncountable';

package/src/string/pluralize/rules/irregular.ts

@@ -1,59 +0,0 @@
-export const IRREGULAR_WORDS: [string, string][] = [
-  // 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'],
-];

package/src/string/pluralize/rules/pluralization.ts

@@ -1,40 +0,0 @@
-/* eslint-disable no-control-regex */
-
-import type { Rule } from "../types";
-
-export const PLURALIZATION_RULES: Rule[] = [
-  [/s?$/i, "s"],
-  [/[^\u0000-\u007F]$/, "$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"],
-];

package/src/string/pluralize/rules/singularization.ts

@@ -1,46 +0,0 @@
-import type { Rule } from "../types";
-
-export const SINGULARIZATION_RULES: Rule[] = [
-  [/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"],
-  [/(dg|ss|ois|lk|ok|wn|mb|th|ch|ec|oal|is|ck|ix|sser|ts|wb)ies$/i, "$1ie"],
-  [
-    /\b(l|(?:neck|cross|hog|aun)?t|coll|faer|food|gen|goon|group|hipp|junk|vegg|(?:pork)?p|charl|calor|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"],
-];

package/src/string/pluralize/rules/uncountable.ts

@@ -1,107 +0,0 @@
-import type { RuleKey } from '../types';
-
-export const UNCOUNTABLE_WORDS: RuleKey[] = [
-  // 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',
-  '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,
-];

package/src/string/pluralize/types.ts

@@ -1,4 +0,0 @@
-export type RuleKey = string | RegExp;
-export type RuleValue = string;
-
-export type Rule = [RuleKey, RuleValue];

package/src/string/slugify/index.ts

@@ -1,3 +0,0 @@
-import slugifyNP from "@sindresorhus/slugify";
-
-export const slugify = (text: string) => slugifyNP(text);

package/src/string/strip-html-tags.ts

@@ -1,4 +0,0 @@
-const htmlTagRegExp = /(<([^>]+)>)/g;
-export function stripHtmlTags(text: string) {
-  return text.replace(htmlTagRegExp, "");
-}

package/src/string/to-int.ts

@@ -1,20 +0,0 @@
-/**
- * Converts a string (or a number) into a number.
- * If the input can not be successfully converted, it will return the fallback.
- * It will not return NaN.
- * @param value - The value to convert
- * @param fallback - The value to fallback to. Defaults to 0
- * @returns number
- */
-export function stringToInt(
-  value: string | number,
-  fallback: number = 0,
-): number {
-  let returnValue = value;
-  if (typeof returnValue === "string")
-    returnValue = Number.parseInt(returnValue);
-
-  if (Number.isNaN(returnValue)) returnValue = fallback;
-
-  return returnValue;
-}

package/src/string/to-sentence-case.ts

@@ -1,6 +0,0 @@
-const specialCharRegExp = /[\s-_.+]+/g;
-export const toSentenceCase = <T extends string>(s: T) =>
-  (s[0].toUpperCase() + s.slice(1).toLowerCase()).replace(
-    specialCharRegExp,
-    " ",
-  );

package/src/string/trim.ts

@@ -1,11 +0,0 @@
-export function trim(text: string, chars: string | string[] = " ") {
-  let start = 0;
-  let end = text.length;
-
-  if (!Array.isArray(chars)) chars = [chars];
-
-  while (start < end && chars.includes(text[start])) start += 1;
-  while (end > start && chars.includes(text[end - 1])) end -= 1;
-
-  return start > 0 || end < text.length ? text.substring(start, end) : text;
-}

package/src/string/truncate.ts

@@ -1,44 +0,0 @@
-export interface TruncateOptions {
-  /**
-   * The maximum number of character allowed in the text before truncating it
-   *
-   * @default 100
-   */
-  maxlength?: number;
-
-  /**
-   * The string to use at the end of the truncated text
-   *
-   * @default "..."
-   */
-  ending?: string;
-
-  /**
-   * If true, truncates the text at the next space char,
-   * so the returned string can exceed the specified `maxLength`
-   *
-   * @default false
-   */
-  noWordBreak?: boolean;
-}
-
-const defaultOptions: Required<TruncateOptions> = {
-  ending: "...",
-  maxlength: 100,
-  noWordBreak: false,
-};
-
-export function truncate(text: string, options?: TruncateOptions) {
-  const conf = { ...defaultOptions, ...options };
-  text = text.trim();
-  if (conf.noWordBreak) {
-    const lastSpaceIndex = text.indexOf(" ", conf.maxlength);
-
-    if (lastSpaceIndex >= conf.maxlength)
-      return text.substring(0, lastSpaceIndex) + conf.ending;
-  } else if (text.length > conf.maxlength + conf.ending.length) {
-    return text.substring(0, conf.maxlength) + conf.ending;
-  }
-
-  return text;
-}

package/src/value/index.ts

@@ -1 +0,0 @@
-export * from "./is-empty";

package/src/value/is-empty.ts

@@ -1,31 +0,0 @@
-/**
- * Checks if the value is `empty`
- *
- * returns `true`, if the value
- *
- * - `undefined`
- * - `null`
- * - `string` and there is no character in the string or all white space
- * - `array` and there is no item in the array
- * - `map` and there is no item in the map
- * - `set` and there is no item in the set
- * - `object` and there is no property in the object
- *
- * otherwise, false
- *
- */
-export const isEmpty = (value: unknown) => {
-  if (value === undefined) return true;
-  if (value === null) return true;
-
-  if (typeof value === "string") return value.trim() === "";
-  if (typeof value === "object") {
-    if (Array.isArray(value) && value.length === 0) return true;
-
-    if (value instanceof Map || value instanceof Set) return value.size === 0;
-
-    return Object.keys(value).length === 0;
-  }
-
-  return false;
-};