@bccampus/utils 0.2.2 → 0.3.0

package/src/object/index.ts

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

package/src/object/is-object.ts

@@ -1,2 +0,0 @@
-export const isObject = (object: unknown) =>
-  typeof object === "object" && !Array.isArray(object) && object !== null;

package/src/object/omit.ts

@@ -1,21 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-export const omit = <T extends object>(object: T, props: string[]) => {
-  const result: Partial<T> = { ...object };
-
-  props.forEach((prop) => {
-    const propChunks = prop.split(".");
-    const lastChunk = propChunks.pop();
-    if (lastChunk) {
-      const ref = propChunks.reduce<any>(
-        (reducedObject, key) =>
-          reducedObject && key in reducedObject
-            ? reducedObject[key]
-            : undefined,
-        result,
-      );
-      if (ref && lastChunk in ref) delete ref[lastChunk];
-    }
-  });
-
-  return result;
-};

package/src/object/pick.ts

@@ -1,10 +0,0 @@
-import { set } from ".";
-import { get } from "./get";
-
-export const pick = <T extends object>(object: T, props: string[]) => {
-  return props.reduce<Record<string, unknown>>((result, key) => {
-    set(result, key, get(object, key));
-
-    return result;
-  }, {}) as Partial<T>;
-};

package/src/object/set.ts

@@ -1,15 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-export const set = <T extends object, V>(object: T, prop: string, value: V) => {
-  const propChunks = prop.split(".");
-  const lastChunk = propChunks.pop();
-  if (!lastChunk) return object;
-
-  const ref = propChunks.reduce<any>((reducedObject, key) => {
-    if (reducedObject[key] === undefined) reducedObject[key] = {};
-    return reducedObject[key];
-  }, object);
-
-  ref[lastChunk] = value;
-
-  return object;
-};

package/src/path/file-url-to-path.ts

@@ -1,12 +0,0 @@
-const windowsDriveRegExp = /^\/[a-zA-Z1-9_-]+:\//;
-
-/**
- * Browser compatible version of `node:url.fileURLToPath`
- */
-export function fileURLToPath(fileUrl: string) {
-  const url = new URL(fileUrl);
-  let path = decodeURIComponent(url.pathname);
-  if (windowsDriveRegExp.test(path)) path = path.slice(1);
-
-  return path;
-}

package/src/path/index.ts

@@ -1,2 +0,0 @@
-export * from "./normalize";
-export * from "./file-url-to-path";

package/src/path/normalize.ts

@@ -1,72 +0,0 @@
-import { fileURLToPath } from "./file-url-to-path";
-
-export interface NormalizeOptions {
-  /**
-   * - `always`: ensure leading slash exists
-   * - `never`: ensure leading slash does not exist
-   * - `as-is`: do not modify the leading char
-   *
-   * @default "always"
-   */
-  leadingSlash?: "always" | "never" | "as-is";
-
-  /**
-   * - `always`: ensure trailing slash exists
-   * - `never`: ensure trailing slash does not exist
-   * - `as-is`: do not modify the trailing char
-   *
-   * @default "never"
-   */
-  trailingSlash?: "always" | "never" | "as-is";
-}
-
-const defaultOptions: Required<NormalizeOptions> = {
-  leadingSlash: "always",
-  trailingSlash: "never",
-};
-
-const windowsPathSepRegExp = /[\\]+/g;
-const unixPathSepRegExp = /[/]+/g;
-const windowsDriveRegExp = /^[a-zA-Z1-9_-]+:\//;
-const fileProtocolRegExp = /^file:\/\//;
-const leadingSlashRegExp = /^\//g;
-const trailingSlashRegExp = /\/$/g;
-
-/**
- * Clears and converts the provided path to a Posix filepath
- *
- * By default, adds a leading slash and removes the trailing
- *
- * @example
- * ```
- *  normalize("src/test/"); //returns: /src/test
- *  normalize("C:\\Users\\test\\folder\\"); //returns: C:/Users/test/folder
- *  normalize("file:///C:/Users/test/folder/file.ts"); //returns: C:/Users/test/folder/file.ts
- * ```
- */
-export function normalize(path: string, options?: NormalizeOptions) {
-  const conf = { ...defaultOptions, ...options };
-  const sep = "\\";
-  let normalPath = path.trim();
-
-  if (fileProtocolRegExp.test(normalPath))
-    normalPath = fileURLToPath(normalPath);
-
-  normalPath = normalPath
-    .replace(windowsPathSepRegExp, sep) // windows -> linux
-    .replace(unixPathSepRegExp, sep); // multiple -> single
-
-  if (conf.leadingSlash !== "as-is") {
-    normalPath = normalPath.replace(leadingSlashRegExp, "");
-
-    if (conf.leadingSlash === "always" && !windowsDriveRegExp.test(normalPath))
-      normalPath = `${sep}${normalPath}`;
-  }
-
-  if (conf.trailingSlash !== "as-is") {
-    normalPath = normalPath.replace(trailingSlashRegExp, "");
-    if (conf.trailingSlash === "always") normalPath = `${normalPath}${sep}`;
-  }
-
-  return normalPath;
-}

package/src/set/difference.ts

@@ -1,9 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-export function difference(setA: Iterable<any>, setB: Iterable<any>) {
-  const _difference = new Set(setA);
-  for (const elem of setB) {
-    _difference.delete(elem);
-  }
-  return _difference;
-}

package/src/set/index.ts

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

package/src/set/intersection.ts

@@ -1,12 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-export function intersection(setA: Iterable<any>, setB: Iterable<any>) {
-  const _setA = setA instanceof Set ? setA : new Set(setA);
-
-  const _intersection = new Set();
-  for (const elem of setB) {
-    if (_setA.has(elem)) {
-      _intersection.add(elem);
-    }
-  }
-  return _intersection;
-}

package/src/set/is-superset.ts

@@ -1,12 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-export function isSuperset(set: Iterable<any>, subset: Iterable<any>) {
-  const _set = set instanceof Set ? set : new Set(set);
-
-  for (const elem of subset) {
-    if (!_set.has(elem)) {
-      return false;
-    }
-  }
-  return true;
-}

package/src/set/symmetric-difference.ts

@@ -1,12 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-export function symmetricDifference(setA: Iterable<any>, setB: Iterable<any>) {
-  const _difference = new Set(setA);
-  for (const elem of setB) {
-    if (_difference.has(elem)) {
-      _difference.delete(elem);
-    } else {
-      _difference.add(elem);
-    }
-  }
-  return _difference;
-}

package/src/set/union.ts

@@ -1,8 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-export function union(setA: Iterable<any>, setB: Iterable<any>) {
-  const _union = new Set(setA);
-  for (const elem of setB) {
-    _union.add(elem);
-  }
-  return _union;
-}

package/src/string/capitalize.ts

@@ -1,2 +0,0 @@
-export const capitalize = <T extends string>(s: T) =>
-  (s[0].toUpperCase() + s.slice(1)) as Capitalize<typeof s>;

package/src/string/index.ts

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

package/src/string/normalize.ts

@@ -1,7 +0,0 @@
-/**
- * Trims white spaces and
- * replaces multiple white space characters with a single space
- */
-export function normalize(text: string) {
-  return text.trim().replace(/\s+/g, " ");
-}

package/src/string/pluralize/index.ts

@@ -1,7 +0,0 @@
-import { Pluralize } from "./pluralize";
-
-const pluralize = new Pluralize();
-
-export type * from "./types";
-
-export { pluralize, Pluralize };

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"],
-];