@bccampus/utils 0.1.0

package/dist/format/template.js

@@ -0,0 +1,35 @@
+import "./formatter.js";
+import { stringify } from "./stringify.js";
+import { get } from "../object/get.js";
+const tagRegExp = new RegExp(/\${([a-zA-Z0-9_.]+)}/gm);
+const template = (text, templateVars) => {
+  return text.replace(tagRegExp, (match, key) => {
+    const templateVar = get(templateVars, key);
+    const value = typeof templateVar === "function" ? templateVar() : templateVar;
+    if (value === void 0) return match;
+    if (value === null) return "";
+    return stringify(value, { invalidValueString: "" });
+  });
+};
+const templateObject = (obj, templateVars) => {
+  const _objClone = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const _key = template(key, templateVars);
+    if (typeof value === "string") {
+      _objClone[_key] = template(value, templateVars);
+    } else if (value && typeof value === "object") {
+      if (Array.isArray(value))
+        _objClone[_key] = value.map(
+          (valueItem) => typeof valueItem === "string" ? template(valueItem, templateVars) : valueItem
+        );
+      else _objClone[_key] = templateObject(value, templateVars);
+    } else {
+      _objClone[_key] = value;
+    }
+  }
+  return _objClone;
+};
+export {
+  template,
+  templateObject
+};

package/dist/object/get.d.ts

@@ -0,0 +1 @@
+export declare const get: <T extends object>(object: T, prop: string) => any;

package/dist/object/get.js

@@ -0,0 +1,7 @@
+const get = (object, prop) => prop.split(".").reduce(
+  (reducedObject, key) => reducedObject && key in reducedObject ? reducedObject[key] : void 0,
+  object
+);
+export {
+  get
+};

package/dist/object/index.d.ts

@@ -0,0 +1,5 @@
+export * from './is-object';
+export * from './get';
+export * from './set';
+export * from './omit';
+export * from './pick';

package/dist/object/index.js

@@ -0,0 +1,12 @@
+import { isObject } from "./is-object.js";
+import { get } from "./get.js";
+import { set } from "./set.js";
+import { omit } from "./omit.js";
+import { pick } from "./pick.js";
+export {
+  get,
+  isObject,
+  omit,
+  pick,
+  set
+};

package/dist/object/is-object.d.ts

@@ -0,0 +1 @@
+export declare const isObject: (object: unknown) => boolean;

package/dist/object/is-object.js

@@ -0,0 +1,4 @@
+const isObject = (object) => typeof object === "object" && !Array.isArray(object) && object !== null;
+export {
+  isObject
+};

package/dist/object/omit.d.ts

@@ -0,0 +1 @@
+export declare const omit: <T extends object>(object: T, props: string[]) => Partial<T>;

package/dist/object/omit.js

@@ -0,0 +1,18 @@
+const omit = (object, props) => {
+  const result = { ...object };
+  props.forEach((prop) => {
+    const propChunks = prop.split(".");
+    const lastChunk = propChunks.pop();
+    if (lastChunk) {
+      const ref = propChunks.reduce(
+        (reducedObject, key) => reducedObject && key in reducedObject ? reducedObject[key] : void 0,
+        result
+      );
+      if (ref && lastChunk in ref) delete ref[lastChunk];
+    }
+  });
+  return result;
+};
+export {
+  omit
+};

package/dist/object/pick.d.ts

@@ -0,0 +1 @@
+export declare const pick: <T extends object>(object: T, props: string[]) => Partial<T>;

package/dist/object/pick.js

@@ -0,0 +1,11 @@
+import { get } from "./get.js";
+import { set } from "./set.js";
+const pick = (object, props) => {
+  return props.reduce((result, key) => {
+    set(result, key, get(object, key));
+    return result;
+  }, {});
+};
+export {
+  pick
+};

package/dist/object/set.d.ts

@@ -0,0 +1 @@
+export declare const set: <T extends object, V>(object: T, prop: string, value: V) => T;

package/dist/object/set.js

@@ -0,0 +1,14 @@
+const set = (object, prop, value) => {
+  const propChunks = prop.split(".");
+  const lastChunk = propChunks.pop();
+  if (!lastChunk) return object;
+  const ref = propChunks.reduce((reducedObject, key) => {
+    if (reducedObject[key] === void 0) reducedObject[key] = {};
+    return reducedObject[key];
+  }, object);
+  ref[lastChunk] = value;
+  return object;
+};
+export {
+  set
+};

package/dist/set/difference.d.ts

@@ -0,0 +1 @@
+export declare function difference(setA: Iterable<any>, setB: Iterable<any>): Set<any>;

package/dist/set/difference.js

@@ -0,0 +1,10 @@
+function difference(setA, setB) {
+  const _difference = new Set(setA);
+  for (const elem of setB) {
+    _difference.delete(elem);
+  }
+  return _difference;
+}
+export {
+  difference
+};

package/dist/set/index.d.ts

@@ -0,0 +1,5 @@
+export * from './union';
+export * from './intersection';
+export * from './is-superset';
+export * from './difference';
+export * from './symmetric-difference';

package/dist/set/index.js

@@ -0,0 +1,12 @@
+import { union } from "./union.js";
+import { intersection } from "./intersection.js";
+import { isSuperset } from "./is-superset.js";
+import { difference } from "./difference.js";
+import { symmetricDifference } from "./symmetric-difference.js";
+export {
+  difference,
+  intersection,
+  isSuperset,
+  symmetricDifference,
+  union
+};

package/dist/set/intersection.d.ts

@@ -0,0 +1 @@
+export declare function intersection(setA: Iterable<any>, setB: Iterable<any>): Set<unknown>;

package/dist/set/intersection.js

@@ -0,0 +1,13 @@
+function intersection(setA, setB) {
+  const _setA = setA instanceof Set ? setA : new Set(setA);
+  const _intersection = /* @__PURE__ */ new Set();
+  for (const elem of setB) {
+    if (_setA.has(elem)) {
+      _intersection.add(elem);
+    }
+  }
+  return _intersection;
+}
+export {
+  intersection
+};

package/dist/set/is-superset.d.ts

@@ -0,0 +1 @@
+export declare function isSuperset(set: Iterable<any>, subset: Iterable<any>): boolean;

package/dist/set/is-superset.js

@@ -0,0 +1,12 @@
+function isSuperset(set, subset) {
+  const _set = set instanceof Set ? set : new Set(set);
+  for (const elem of subset) {
+    if (!_set.has(elem)) {
+      return false;
+    }
+  }
+  return true;
+}
+export {
+  isSuperset
+};

package/dist/set/symmetric-difference.d.ts

@@ -0,0 +1 @@
+export declare function symmetricDifference(setA: Iterable<any>, setB: Iterable<any>): Set<any>;

package/dist/set/symmetric-difference.js

@@ -0,0 +1,14 @@
+function symmetricDifference(setA, setB) {
+  const _difference = new Set(setA);
+  for (const elem of setB) {
+    if (_difference.has(elem)) {
+      _difference.delete(elem);
+    } else {
+      _difference.add(elem);
+    }
+  }
+  return _difference;
+}
+export {
+  symmetricDifference
+};

package/dist/set/union.d.ts

@@ -0,0 +1 @@
+export declare function union(setA: Iterable<any>, setB: Iterable<any>): Set<any>;

package/dist/set/union.js

@@ -0,0 +1,10 @@
+function union(setA, setB) {
+  const _union = new Set(setA);
+  for (const elem of setB) {
+    _union.add(elem);
+  }
+  return _union;
+}
+export {
+  union
+};

package/dist/string/capitalize.d.ts

@@ -0,0 +1 @@
+export declare const capitalize: <T extends string>(s: T) => Capitalize<typeof s>;

package/dist/string/capitalize.js

@@ -0,0 +1,4 @@
+const capitalize = (s) => s[0].toUpperCase() + s.slice(1);
+export {
+  capitalize
+};

package/dist/string/index.d.ts

@@ -0,0 +1,6 @@
+export * from './truncate';
+export * from './trim';
+export * from './strip-html-tags';
+export * from './capitalize';
+export * from './to-sentence-case';
+export * from './to-int';

package/dist/string/index.js

@@ -0,0 +1,14 @@
+import { truncate } from "./truncate.js";
+import { trim } from "./trim.js";
+import { stripHtmlTags } from "./strip-html-tags.js";
+import { capitalize } from "./capitalize.js";
+import { toSentenceCase } from "./to-sentence-case.js";
+import { stringToInt } from "./to-int.js";
+export {
+  capitalize,
+  stringToInt,
+  stripHtmlTags,
+  toSentenceCase,
+  trim,
+  truncate
+};

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

@@ -0,0 +1,2 @@
+export * from './pluralize';
+export type * from './types';

package/dist/string/pluralize/index.js

@@ -0,0 +1,4 @@
+import { Pluralize } from "./pluralize.js";
+export {
+  Pluralize
+};

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

@@ -0,0 +1,85 @@
+import { Rule, RuleKey, RuleValue } from './types';
+export declare class Pluralize {
+    private pluralRules;
+    private singularRules;
+    private uncountables;
+    private irregularPlurals;
+    private irregularSingles;
+    constructor();
+    /**
+     * Add a pluralization rule to the collection.
+     */
+    addPluralRule(rule: RuleKey, replacement: RuleValue): void;
+    /**
+     * Add a singularization rule to the collection.
+     */
+    addSingularRule(rule: RuleKey, replacement: RuleValue): void;
+    /**
+     * Add an uncountable word rule.
+     */
+    addUncountableRule(word: RuleKey): void;
+    /**
+     * Add an irregular word definition.
+     *
+     * @param {string} single
+     * @param {string} plural
+     */
+    addIrregularRule(single: string, plural: string): void;
+    /**
+     * Sanitize a pluralization rule to a usable regular expression.
+     */
+    sanitizeRule(rule: RuleKey): RegExp;
+    /**
+     * Pass in a word token to produce a function that can replicate the case on
+     * another word.
+     */
+    restoreCase(word: string, token: string): string;
+    /**
+     * Interpolate a regexp string.
+     *
+     * @param  {string} str
+     * @param  {Array}  args
+     * @return {string}
+     */
+    interpolate(str: string, args: string[]): string;
+    /**
+     * Replace a word using a rule.
+     */
+    replace(word: string, rule: Rule): string;
+    /**
+     * Sanitize a word by passing in the word and sanitization rules.
+     */
+    sanitizeWord(token: string, word: string, rules: Rule[]): string;
+    /**
+     * Replace a word with the updated word.
+     */
+    old_replaceWord(replaceMap: Record<string, string>, keepMap: Record<string, string>, rules: Rule[]): (word: string) => string;
+    /**
+     * Replace a word with the updated word.
+     */
+    private replaceWord;
+    /**
+     * Check if a word is part of the map.
+     */
+    private checkWord;
+    /**
+     * Pluralize or singularize a word based on the passed in count.
+     */
+    pluralize(word: string, count: number, inclusive: boolean): string;
+    /**
+     * Pluralize a word.
+     */
+    plural(singularWord: string): string;
+    /**
+     * Check if a word is plural.
+     */
+    isPlural(word: string): void;
+    /**
+     * Singularize a word.
+     */
+    singular(pluralWord: string): string;
+    /**
+     * Check if a word is singular.
+     */
+    isSingular(word: string): void;
+}

package/dist/string/pluralize/pluralize.js

@@ -0,0 +1,210 @@
+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
+};

package/dist/string/pluralize/rules/index.d.ts

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

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

@@ -0,0 +1,10 @@
+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
+};

package/dist/string/pluralize/rules/irregular.d.ts

@@ -0,0 +1 @@
+export declare const IRREGULAR_WORDS: [string, string][];

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

@@ -0,0 +1,62 @@
+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"]
+];
+export {
+  IRREGULAR_WORDS
+};

package/dist/string/pluralize/rules/pluralization.d.ts

@@ -0,0 +1,2 @@
+import { Rule } from '../types';
+export declare const PLURALIZATION_RULES: Rule[];