complete-common 1.0.0

package/LICENSE

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright The Complete Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,7 @@
+# complete-common
+
+[![npm version](https://img.shields.io/npm/v/complete-common.svg)](https://www.npmjs.com/package/complete-common)
+
+This package contains helper functions for a typical TypeScript project, such as [`iRange`](TODO).
+
+For more information about `complete`, see the [official website](https://complete-ts.github.io/).

package/dist/index.cjs

@@ -0,0 +1,535 @@
+'use strict';
+
+const SECOND_IN_MILLISECONDS = 1e3;
+const MINUTE_IN_MILLISECONDS = 60 * SECOND_IN_MILLISECONDS;
+const HOUR_IN_MILLISECONDS = 60 * MINUTE_IN_MILLISECONDS;
+
+const ReadonlySet = Set;
+
+function getRandomInt(min, max, exceptions = []) {
+  min = Math.ceil(min);
+  max = Math.floor(max);
+  if (min > max) {
+    const oldMin = min;
+    const oldMax = max;
+    min = oldMax;
+    max = oldMin;
+  }
+  const exceptionsSet = new ReadonlySet(exceptions);
+  let randomInt;
+  do {
+    randomInt = Math.floor(Math.random() * (max - min + 1)) + min;
+  } while (exceptionsSet.has(randomInt));
+  return randomInt;
+}
+
+const FLOAT_REGEX = /^-?\d*\.?\d+$/;
+const INTEGER_REGEX = /^-?\d+$/;
+function assertDefined(value, ...[msg]) {
+  if (value === void 0) {
+    throw new TypeError(msg);
+  }
+}
+function assertNotNull(value, ...[msg]) {
+  if (value === null) {
+    throw new TypeError(msg);
+  }
+}
+function* eRange(start, end, increment = 1) {
+  if (end === void 0) {
+    yield* eRange(0, start, increment);
+    return;
+  }
+  for (let i = start; i < end; i += increment) {
+    yield i;
+  }
+}
+function* iRange(start, end, increment = 1) {
+  if (end === void 0) {
+    yield* iRange(0, start, increment);
+    return;
+  }
+  const exclusiveEnd = end + 1;
+  yield* eRange(start, exclusiveEnd, increment);
+}
+function isKeyOf(key, target) {
+  return key in target;
+}
+function noop() {
+}
+function parseFloatSafe(string) {
+  if (typeof string !== "string") {
+    return void 0;
+  }
+  const trimmedString = string.trim();
+  if (FLOAT_REGEX.exec(trimmedString) === null) {
+    return void 0;
+  }
+  const number = Number.parseFloat(trimmedString);
+  return Number.isNaN(number) ? void 0 : number;
+}
+function parseIntSafe(string) {
+  if (typeof string !== "string") {
+    return void 0;
+  }
+  const trimmedString = string.trim();
+  if (INTEGER_REGEX.exec(trimmedString) === null) {
+    return void 0;
+  }
+  const number = Number.parseInt(trimmedString, 10);
+  return Number.isNaN(number) ? void 0 : number;
+}
+function repeat(num, func) {
+  for (let i = 0; i < num; i++) {
+    func(i);
+  }
+}
+function todo(...args) {
+}
+
+function arrayCopyTwoDimensional(array) {
+  const copiedArray = [];
+  for (const subArray of array) {
+    copiedArray.push([...subArray]);
+  }
+  return copiedArray;
+}
+function arrayEquals(array1, array2) {
+  if (array1.length !== array2.length) {
+    return false;
+  }
+  return array1.every((array1Element, i) => {
+    const array2Element = array2[i];
+    return array1Element === array2Element;
+  });
+}
+function arrayRemove(originalArray, ...elementsToRemove) {
+  const elementsToRemoveSet = new ReadonlySet(elementsToRemove);
+  const array = [];
+  for (const element of originalArray) {
+    if (!elementsToRemoveSet.has(element)) {
+      array.push(element);
+    }
+  }
+  return array;
+}
+function arrayRemoveInPlace(array, ...elementsToRemove) {
+  const removedElements = [];
+  for (const element of elementsToRemove) {
+    const index = array.indexOf(element);
+    if (index > -1) {
+      const removedElement = array.splice(index, 1);
+      removedElements.push(...removedElement);
+    }
+  }
+  return removedElements;
+}
+function emptyArray(array) {
+  array.splice(0, array.length);
+}
+function filterMap(array, func) {
+  const filteredArray = [];
+  for (const element of array) {
+    const newElement = func(element);
+    if (newElement !== void 0) {
+      filteredArray.push(newElement);
+    }
+  }
+  return filteredArray;
+}
+function getRandomArrayElement(array, exceptions = []) {
+  if (array.length === 0) {
+    throw new Error(
+      "Failed to get a random array element since the provided array is empty."
+    );
+  }
+  const arrayToUse = exceptions.length > 0 ? arrayRemove(array, ...exceptions) : array;
+  const randomIndex = getRandomArrayIndex(arrayToUse);
+  const randomElement = arrayToUse[randomIndex];
+  assertDefined(
+    randomElement,
+    `Failed to get a random array element since the random index of ${randomIndex} was not valid.`
+  );
+  return randomElement;
+}
+function getRandomArrayIndex(array, exceptions = []) {
+  if (array.length === 0) {
+    throw new Error(
+      "Failed to get a random array index since the provided array is empty."
+    );
+  }
+  return getRandomInt(0, array.length - 1, exceptions);
+}
+function includes(array, searchElement) {
+  const widenedArray = array;
+  return widenedArray.includes(searchElement);
+}
+function isArray(arg) {
+  return Array.isArray(arg);
+}
+function newArray(length, value) {
+  return Array.from({ length }, () => value);
+}
+function sumArray(array) {
+  return array.reduce((accumulator, element) => accumulator + element, 0);
+}
+
+function getEnumEntries(transpiledEnum) {
+  const entries = Object.entries(transpiledEnum);
+  const numberEntries = entries.filter(
+    ([_key, value]) => typeof value === "number"
+  );
+  const entriesToReturn = numberEntries.length > 0 ? numberEntries : entries;
+  return entriesToReturn;
+}
+function getEnumKeys(transpiledEnum) {
+  const enumEntries = getEnumEntries(transpiledEnum);
+  return enumEntries.map(([key, _value]) => key);
+}
+function getEnumValues(transpiledEnum) {
+  const enumEntries = getEnumEntries(transpiledEnum);
+  return enumEntries.map(([_key, value]) => value);
+}
+function interfaceSatisfiesEnum() {
+}
+function isEnumValue(value, transpiledEnum, set) {
+  if (set !== void 0) {
+    return set.has(value);
+  }
+  const enumValues = getEnumValues(transpiledEnum);
+  return enumValues.includes(value);
+}
+
+function mapFilter(map, predicate) {
+  const array = [];
+  for (const value of map.values()) {
+    const match = predicate(value);
+    if (match) {
+      array.push(value);
+    }
+  }
+  return array;
+}
+function mapFind(map, predicate) {
+  for (const value of map.values()) {
+    const match = predicate(value);
+    if (match) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function objectToMap(object) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(object)) {
+    map.set(key, value);
+  }
+  return map;
+}
+function objectToReadonlyMap(object) {
+  return objectToMap(object);
+}
+
+function clamp(num, min, max) {
+  return Math.max(min, Math.min(num, max));
+}
+
+function objectFilter(object, predicate) {
+  const array = [];
+  for (const key in object) {
+    const value = object[key];
+    const match = predicate(value);
+    if (match) {
+      array.push(value);
+    }
+  }
+  return array;
+}
+
+function addSetsToSet(mainSet, ...setsToAdd) {
+  for (const set of setsToAdd) {
+    for (const value of set) {
+      mainSet.add(value);
+    }
+  }
+}
+function combineSets(...sets) {
+  const newSet = /* @__PURE__ */ new Set();
+  for (const set of sets) {
+    for (const value of set) {
+      newSet.add(value);
+    }
+  }
+  return newSet;
+}
+function copySet(oldSet) {
+  const newSet = /* @__PURE__ */ new Set();
+  for (const value of oldSet) {
+    newSet.add(value);
+  }
+  return newSet;
+}
+function objectKeysToReadonlySet(object) {
+  return objectKeysToSet(object);
+}
+function objectKeysToSet(object) {
+  const set = /* @__PURE__ */ new Set();
+  for (const key of Object.keys(object)) {
+    set.add(key);
+  }
+  return set;
+}
+function objectValuesToReadonlySet(object) {
+  return objectValuesToSet(object);
+}
+function objectValuesToSet(object) {
+  const set = /* @__PURE__ */ new Set();
+  for (const key of Object.values(object)) {
+    set.add(key);
+  }
+  return set;
+}
+function setAdd(set, ...elements) {
+  for (const element of elements) {
+    set.add(element);
+  }
+}
+function setHas(set, ...elements) {
+  return elements.some((element) => set.has(element));
+}
+
+function sortCaseInsensitive(array) {
+  const newArray = [...array];
+  newArray.sort(
+    (a, b) => a.localeCompare(b, void 0, {
+      sensitivity: "base"
+    })
+  );
+  return newArray;
+}
+
+const DIACRITIC_REGEX = /\p{Diacritic}/u;
+const EMOJI_REGEX = /(\p{Extended_Pictographic}|\p{Emoji_Component})/u;
+const FIRST_LETTER_CAPITALIZED_REGEX = /^\p{Lu}/u;
+const KEBAB_CASE_REGEX = /^([a-z](?!\d)|\d(?![a-z]))+(-?([a-z](?!\d)|\d(?![a-z])))*$|^$/;
+const SEMANTIC_VERSION_REGEX = /^v*(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)/;
+const WHITESPACE_REGEX = /\s/g;
+function capitalizeFirstLetter(string) {
+  if (string === "") {
+    return string;
+  }
+  const firstCharacter = string.charAt(0);
+  const capitalizedFirstLetter = firstCharacter.toUpperCase();
+  const restOfString = string.slice(1);
+  return `${capitalizedFirstLetter}${restOfString}`;
+}
+function escapeHTMLCharacters(string) {
+  return string.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#039;");
+}
+function getNumConsecutiveDiacritics(string) {
+  const normalizedString = string.normalize("NFD");
+  let numConsecutiveDiacritic = 0;
+  let maxConsecutiveDiacritic = 0;
+  for (const character of normalizedString) {
+    if (hasDiacritic(character)) {
+      numConsecutiveDiacritic++;
+      if (numConsecutiveDiacritic > maxConsecutiveDiacritic) {
+        maxConsecutiveDiacritic = numConsecutiveDiacritic;
+      }
+    } else {
+      numConsecutiveDiacritic = 0;
+    }
+  }
+  return maxConsecutiveDiacritic;
+}
+function hasDiacritic(string) {
+  const normalizedString = string.normalize("NFD");
+  return DIACRITIC_REGEX.test(normalizedString);
+}
+function hasEmoji(string) {
+  return EMOJI_REGEX.test(string);
+}
+function hasWhitespace(string) {
+  return WHITESPACE_REGEX.test(string);
+}
+function isFirstLetterCapitalized(string) {
+  return FIRST_LETTER_CAPITALIZED_REGEX.test(string);
+}
+function isKebabCase(string) {
+  return KEBAB_CASE_REGEX.test(string);
+}
+function isSemanticVersion(versionString) {
+  const match = versionString.match(SEMANTIC_VERSION_REGEX);
+  return match !== null;
+}
+function kebabCaseToCamelCase(string) {
+  return string.replaceAll(/-./g, (match) => {
+    const firstLetterOfWord = match[1];
+    return firstLetterOfWord === void 0 ? "" : firstLetterOfWord.toUpperCase();
+  });
+}
+function normalizeString(string) {
+  let sanitizedString = string;
+  sanitizedString = removeNonPrintableCharacters(sanitizedString);
+  sanitizedString = sanitizedString.replaceAll("\n\r", "\n");
+  sanitizedString = sanitizedString.replaceAll(/\p{Zl}/gu, "\n");
+  sanitizedString = sanitizedString.replaceAll(/\p{Zp}/gu, "\n");
+  sanitizedString = sanitizedString.replaceAll(/\p{Zs}/gu, " ");
+  sanitizedString = sanitizedString.trim();
+  return sanitizedString;
+}
+function parseSemanticVersion(versionString) {
+  const match = versionString.match(SEMANTIC_VERSION_REGEX);
+  if (match === null || match.groups === void 0) {
+    return void 0;
+  }
+  const { major, minor, patch } = match.groups;
+  if (major === void 0 || minor === void 0 || patch === void 0) {
+    return void 0;
+  }
+  const majorVersion = parseIntSafe(major);
+  const minorVersion = parseIntSafe(minor);
+  const patchVersion = parseIntSafe(patch);
+  if (majorVersion === void 0 || minorVersion === void 0 || patchVersion === void 0) {
+    return void 0;
+  }
+  return { majorVersion, minorVersion, patchVersion };
+}
+function removeLinesBetweenMarkers(string, marker) {
+  const lines = string.split("\n");
+  const newLines = [];
+  let skippingLines = false;
+  for (const line of lines) {
+    if (line.includes(`${marker}-start`)) {
+      skippingLines = true;
+      continue;
+    }
+    if (line.includes(`${marker}-end`)) {
+      skippingLines = false;
+      continue;
+    }
+    if (!skippingLines) {
+      newLines.push(line);
+    }
+  }
+  return newLines.join("\n");
+}
+function removeLinesMatching(string, match) {
+  const lines = string.split("\n");
+  const newLines = lines.filter((line) => !line.includes(match));
+  return newLines.join("\n");
+}
+function removeNonPrintableCharacters(string) {
+  return string.replaceAll(/\p{C}/gu, "");
+}
+function removeWhitespace(string) {
+  return string.replaceAll(WHITESPACE_REGEX, "");
+}
+function trimPrefix(string, prefix, trimAll = false) {
+  if (trimAll) {
+    const regExp = new RegExp(`^${prefix}+`, "g");
+    return string.replaceAll(regExp, "");
+  }
+  if (!string.startsWith(prefix)) {
+    return string;
+  }
+  return string.slice(prefix.length);
+}
+function trimSuffix(string, prefix) {
+  if (!string.endsWith(prefix)) {
+    return string;
+  }
+  const endCharacter = string.length - prefix.length;
+  return string.slice(0, endCharacter);
+}
+function truncateString(string, maxLength) {
+  if (string.length <= maxLength) {
+    return string;
+  }
+  return string.slice(0, maxLength);
+}
+
+function* tupleEntries(tuple) {
+  yield* tuple.entries();
+}
+function* tupleKeys(tuple) {
+  yield* tuple.keys();
+}
+
+function isObject(variable) {
+  return typeof variable === "object" && variable !== null && !Array.isArray(variable);
+}
+
+const ReadonlyMap = Map;
+
+exports.HOUR_IN_MILLISECONDS = HOUR_IN_MILLISECONDS;
+exports.MINUTE_IN_MILLISECONDS = MINUTE_IN_MILLISECONDS;
+exports.ReadonlyMap = ReadonlyMap;
+exports.ReadonlySet = ReadonlySet;
+exports.SECOND_IN_MILLISECONDS = SECOND_IN_MILLISECONDS;
+exports.addSetsToSet = addSetsToSet;
+exports.arrayCopyTwoDimensional = arrayCopyTwoDimensional;
+exports.arrayEquals = arrayEquals;
+exports.arrayRemove = arrayRemove;
+exports.arrayRemoveInPlace = arrayRemoveInPlace;
+exports.assertDefined = assertDefined;
+exports.assertNotNull = assertNotNull;
+exports.capitalizeFirstLetter = capitalizeFirstLetter;
+exports.clamp = clamp;
+exports.combineSets = combineSets;
+exports.copySet = copySet;
+exports.eRange = eRange;
+exports.emptyArray = emptyArray;
+exports.escapeHTMLCharacters = escapeHTMLCharacters;
+exports.filterMap = filterMap;
+exports.getEnumEntries = getEnumEntries;
+exports.getEnumKeys = getEnumKeys;
+exports.getEnumValues = getEnumValues;
+exports.getNumConsecutiveDiacritics = getNumConsecutiveDiacritics;
+exports.getRandomArrayElement = getRandomArrayElement;
+exports.getRandomArrayIndex = getRandomArrayIndex;
+exports.getRandomInt = getRandomInt;
+exports.hasDiacritic = hasDiacritic;
+exports.hasEmoji = hasEmoji;
+exports.hasWhitespace = hasWhitespace;
+exports.iRange = iRange;
+exports.includes = includes;
+exports.interfaceSatisfiesEnum = interfaceSatisfiesEnum;
+exports.isArray = isArray;
+exports.isEnumValue = isEnumValue;
+exports.isFirstLetterCapitalized = isFirstLetterCapitalized;
+exports.isKebabCase = isKebabCase;
+exports.isKeyOf = isKeyOf;
+exports.isObject = isObject;
+exports.isSemanticVersion = isSemanticVersion;
+exports.kebabCaseToCamelCase = kebabCaseToCamelCase;
+exports.mapFilter = mapFilter;
+exports.mapFind = mapFind;
+exports.newArray = newArray;
+exports.noop = noop;
+exports.normalizeString = normalizeString;
+exports.objectFilter = objectFilter;
+exports.objectKeysToReadonlySet = objectKeysToReadonlySet;
+exports.objectKeysToSet = objectKeysToSet;
+exports.objectToMap = objectToMap;
+exports.objectToReadonlyMap = objectToReadonlyMap;
+exports.objectValuesToReadonlySet = objectValuesToReadonlySet;
+exports.objectValuesToSet = objectValuesToSet;
+exports.parseFloatSafe = parseFloatSafe;
+exports.parseIntSafe = parseIntSafe;
+exports.parseSemanticVersion = parseSemanticVersion;
+exports.removeLinesBetweenMarkers = removeLinesBetweenMarkers;
+exports.removeLinesMatching = removeLinesMatching;
+exports.removeNonPrintableCharacters = removeNonPrintableCharacters;
+exports.removeWhitespace = removeWhitespace;
+exports.repeat = repeat;
+exports.setAdd = setAdd;
+exports.setHas = setHas;
+exports.sortCaseInsensitive = sortCaseInsensitive;
+exports.sumArray = sumArray;
+exports.todo = todo;
+exports.trimPrefix = trimPrefix;
+exports.trimSuffix = trimSuffix;
+exports.truncateString = truncateString;
+exports.tupleEntries = tupleEntries;
+exports.tupleKeys = tupleKeys;