lifecycleion 0.0.1

package/dist/lib/strings.d.ts

@@ -0,0 +1,107 @@
+declare function isString(value: unknown): value is string;
+/**
+ * Converts a string or an array of strings to Pascal Case.
+ *
+ * This function takes an input string or an array of strings, each potentially containing hyphens,
+ * and converts them to Pascal Case. It removes any characters that are not letters or numbers,
+ * capitalizes the first letter of each substring, and ensures the rest of the substring
+ * is in lowercase. Finally, it concatenates all these substrings to produce a Pascal Case
+ * output.
+ *
+ * @param {string | string[]} input - The input string or array of strings to be converted to Pascal Case.
+ * @returns {string} The converted string in Pascal Case.
+ *
+ * Examples:
+ * toPascalCase("hello-world-123!$") will return "HelloWorld123"
+ * toPascalCase(["hello", "world-123!$"]) will return "HelloWorld123"
+ */
+declare function toPascalCase(input: string | string[]): string;
+/**
+ * Converts a string or an array of strings to Camel Case.
+ *
+ * This function takes an input string or an array of strings, each potentially containing hyphens,
+ * and converts them to Camel Case. It removes any characters that are not letters or numbers,
+ * capitalizes the first letter of each substring after the first one, and ensures the rest of the substring
+ * is in lowercase. For the first substring, it ensures the entire substring is in lowercase.
+ * Finally, it concatenates all these substrings to produce a Camel Case output.
+ *
+ * @param {string | string[]} input - The input string or array of strings to be converted to Camel Case.
+ * @returns {string} The converted string in Camel Case.
+ *
+ * Examples:
+ * toCamelCase("hello-world-123!$") will return "helloWorld123"
+ * toCamelCase(["hello", "world-123!$"]) will return "helloWorld123"
+ */
+declare function toCamelCase(input: string | string[]): string;
+/**
+ * This method converts a string or an array of strings to camel case,
+ * but if starting with a leading hyphen, it will convert to Pascal case.
+ */
+declare function toCamelCaseWithPascalOverride(input: string | string[]): string;
+/**
+ * Converts a string or an array of strings to constant case.
+ *
+ * The function takes a string or an array of strings, where each string can be separated by a '-',
+ * and converts them into a constant case format (all uppercase with underscores between words).
+ * It first cleans the input by removing non-alphanumeric characters (except for hyphens), splits the
+ * string into parts on hyphens, and then joins these parts with underscores, converting the entire
+ * result to uppercase.
+ *
+ * @param {string | string[]} input - The input string or array of strings to be converted.
+ * @returns {string} The converted string in constant case.
+ *
+ * Example:
+ * toConstantCase("hello-world") will return "HELLO_WORLD"
+ * toConstantCase(["hello", "world"]) will return "HELLO_WORLD"
+ */
+declare function toConstantCase(input: string | string[]): string;
+declare function splitGraphemes(text: string): string[];
+declare function skipTrailingNewLines(str: string): string;
+/**
+ * Filters a string to include only specified characters, optionally replacing disallowed characters.
+ *
+ * @param str - The input string to be filtered.
+ * @param list - An array of allowed characters.
+ * @param caseInsensitive - Optional. If true, the filtering is case-insensitive. Default is false.
+ * @param replacementChar - Optional. Character to replace disallowed characters. If empty, disallowed characters are removed. Default is ''.
+ * @returns A new string containing only the allowed characters from the input string, with disallowed characters optionally replaced.
+ *
+ * @example
+ * // Case-sensitive usage, removing disallowed characters
+ * characterAllowedOnly("Hello123!", ["H", "e", "l", "o"]);
+ * // Returns: "Hello"
+ *
+ * @example
+ * // Case-insensitive usage, removing disallowed characters
+ * characterAllowedOnly("Hello123!", ["h", "E", "L", "O"], true);
+ * // Returns: "Hello"
+ *
+ * @example
+ * // Using replacement character
+ * characterAllowedOnly("Hello123!", ["H", "e", "l", "o"], false, "-");
+ * // Returns: "Hello---"
+ */
+declare function characterAllowedOnly(str: string, list: string[], caseInsensitive?: boolean, replacementChar?: string): string;
+/**
+ * Will remove the matching first character from a string
+ * @param str
+ * @param char
+ * @returns
+ */
+declare function chopBeginningCharacter(str: string, char: string): string;
+/**
+ * Will remove the matching last character from the string
+ * @param str
+ * @param char
+ * @returns
+ */
+declare function chopEndingCharacter(str: string, char: string): string;
+/**
+ * Will remove the matching character, from the beginning and/or end of the string if matching
+ * @param str
+ * @param char
+ * @returns
+ */
+declare function chopBothBeginningAndEndingCharacters(str: string, char: string): string;
+
+export { characterAllowedOnly, chopBeginningCharacter, chopBothBeginningAndEndingCharacters, chopEndingCharacter, isString, skipTrailingNewLines, splitGraphemes, toCamelCase, toCamelCaseWithPascalOverride, toConstantCase, toPascalCase };

package/dist/lib/strings.js

@@ -0,0 +1,149 @@
+// src/lib/arrays.ts
+function removeEmptyStringsFromArray(array) {
+  const newArray = [];
+  for (let item of array) {
+    item = item.trim();
+    if (item.length > 0) {
+      newArray.push(item);
+    }
+  }
+  return newArray;
+}
+
+// src/lib/strings.ts
+function isString(value) {
+  return typeof value === "string";
+}
+function toPascalCase(input) {
+  const inputArray = Array.isArray(input) ? input : [input];
+  const parts = [];
+  for (const item of inputArray) {
+    const cleanedItem = item.replace(/[^a-zA-Z0-9-]/g, "");
+    parts.push(...removeEmptyStringsFromArray(cleanedItem.split("-")));
+  }
+  return parts.map(
+    (subString) => subString.charAt(0).toUpperCase() + subString.slice(1).toLowerCase()
+  ).join("");
+}
+function toCamelCase(input) {
+  const inputArray = Array.isArray(input) ? input : [input];
+  const parts = [];
+  for (const item of inputArray) {
+    const cleanedItem = item.replace(/[^a-zA-Z0-9-]/g, "");
+    parts.push(...removeEmptyStringsFromArray(cleanedItem.split("-")));
+  }
+  return parts.map(
+    (subString, index) => index === 0 ? subString.toLowerCase() : subString.charAt(0).toUpperCase() + subString.slice(1).toLowerCase()
+  ).join("");
+}
+function toCamelCaseWithPascalOverride(input) {
+  if (isString(input) && input.startsWith("-")) {
+    return toPascalCase(input);
+  } else if (Array.isArray(input) && input.length > 0 && input[0].startsWith("-")) {
+    return toPascalCase(input);
+  } else {
+    return toCamelCase(input);
+  }
+}
+function toConstantCase(input) {
+  const inputArray = Array.isArray(input) ? input : [input];
+  let parts = [];
+  for (const item of inputArray) {
+    const cleanedItem = item.replace(/[^a-zA-Z0-9-]/g, "");
+    parts.push(...cleanedItem.split("-"));
+  }
+  parts = removeEmptyStringsFromArray(parts);
+  return parts.join("_").toUpperCase();
+}
+function splitGraphemes(text) {
+  const graphemes = [];
+  let grapheme = "";
+  let zwjSequence = "";
+  for (let i = 0; i < text.length; i++) {
+    const char = text[i];
+    const nextChar = text[i + 1] || "";
+    const code = char.charCodeAt(0);
+    if (code >= 768 && code <= 879 || // Combining Diacritical Marks
+    code >= 6832 && code <= 6911 || // Combining Diacritical Marks Extended
+    code >= 7616 && code <= 7679 || // Combining Diacritical Marks Supplement
+    code >= 65056 && code <= 65071 || // Combining Half Marks
+    code >= 3633 && code <= 3642 || // Thai combining marks
+    code >= 3655 && code <= 3662) {
+      grapheme += char;
+    } else if (char === "\u200D") {
+      zwjSequence += grapheme + char;
+      grapheme = "";
+    } else {
+      if (grapheme) {
+        if (zwjSequence) {
+          graphemes.push(zwjSequence + grapheme);
+          zwjSequence = "";
+        } else {
+          graphemes.push(grapheme);
+        }
+      }
+      grapheme = char;
+      if (char >= "\uD800" && char <= "\uDBFF" && nextChar >= "\uDC00" && nextChar <= "\uDFFF") {
+        grapheme += nextChar;
+        i++;
+      }
+    }
+  }
+  if (grapheme) {
+    if (zwjSequence) {
+      graphemes.push(zwjSequence + grapheme);
+    } else {
+      graphemes.push(grapheme);
+    }
+  }
+  return graphemes;
+}
+function skipTrailingNewLines(str) {
+  return str.replace(/\n+$/, "");
+}
+function characterAllowedOnly(str, list, caseInsensitive = false, replacementChar = "") {
+  let newStr = "";
+  if (caseInsensitive) {
+    list = Array.from(new Set(list.map((item) => item.toLowerCase())));
+  }
+  const processedStr = caseInsensitive ? str.toLowerCase() : str;
+  for (const c of processedStr) {
+    if (list.includes(c)) {
+      newStr += c;
+    } else if (replacementChar !== "") {
+      newStr += replacementChar;
+    }
+  }
+  return newStr;
+}
+function chopBeginningCharacter(str, char) {
+  if (str.startsWith(char)) {
+    return str.slice(1);
+  } else {
+    return str;
+  }
+}
+function chopEndingCharacter(str, char) {
+  if (str.endsWith(char)) {
+    return str.slice(0, -1);
+  } else {
+    return str;
+  }
+}
+function chopBothBeginningAndEndingCharacters(str, char) {
+  return chopBeginningCharacter(chopEndingCharacter(str, char), char);
+}
+export {
+  characterAllowedOnly,
+  chopBeginningCharacter,
+  chopBothBeginningAndEndingCharacters,
+  chopEndingCharacter,
+  isString,
+  skipTrailingNewLines,
+  splitGraphemes,
+  toCamelCase,
+  toCamelCaseWithPascalOverride,
+  toConstantCase,
+  toPascalCase
+};
+//# sourceMappingURL=strings.js.map

package/dist/lib/strings.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/arrays.ts","../../src/lib/strings.ts"],"sourcesContent":["import { isString } from './strings';\n\nexport function isArray(value: unknown): value is unknown[] {\n  return Array.isArray(value);\n}\n\nexport function removeEmptyStringsFromArray(array: string[]): string[] {\n  const newArray: string[] = [];\n\n  for (let item of array) {\n    item = item.trim();\n\n    if (item.length > 0) {\n      newArray.push(item);\n    }\n  }\n\n  return newArray;\n}\n\n/**\n * Will take an array and return a new array with a value prepended to each item\n *\n * @param array\n * @param value\n * @returns\n */\n\nexport function prependStringToArrayItems(\n  array: string[],\n  value: string,\n): string[] {\n  const newArray: string[] = [];\n\n  for (const item of array) {\n    newArray.push(value + item);\n  }\n\n  return newArray;\n}\n\nexport function isEveryArrayItemAnString(value: unknown): boolean {\n  if (Array.isArray(value)) {\n    for (const item of value) {\n      if (!isString(item)) {\n        return false;\n      }\n    }\n\n    return true;\n  } else {\n    return false;\n  }\n}\n\nexport function areArraysEqual<T>(arr1: T[], arr2: T[]): boolean {\n  // Check if the arrays are the same length\n  if (arr1.length !== arr2.length) {\n    return false;\n  }\n\n  // Check each element in the arrays\n  for (const [i, element] of arr1.entries()) {\n    if (element !== arr2[i]) {\n      return false;\n    }\n  }\n\n  // If all elements are equal\n  return true;\n}\n\nexport function pushWithoutDuplicates(array: unknown[], value: unknown): void {\n  if (!array.includes(value)) {\n    array.push(value);\n  }\n}\n","import { removeEmptyStringsFromArray } from './arrays';\n\nexport function isString(value: unknown): value is string {\n  return typeof value === 'string';\n}\n\n/**\n * Converts a string or an array of strings to Pascal Case.\n *\n * This function takes an input string or an array of strings, each potentially containing hyphens,\n * and converts them to Pascal Case. It removes any characters that are not letters or numbers,\n * capitalizes the first letter of each substring, and ensures the rest of the substring\n * is in lowercase. Finally, it concatenates all these substrings to produce a Pascal Case\n * output.\n *\n * @param {string | string[]} input - The input string or array of strings to be converted to Pascal Case.\n * @returns {string} The converted string in Pascal Case.\n *\n * Examples:\n * toPascalCase(\"hello-world-123!$\") will return \"HelloWorld123\"\n * toPascalCase([\"hello\", \"world-123!$\"]) will return \"HelloWorld123\"\n */\n\nexport function toPascalCase(input: string | string[]): string {\n  // Ensure input is an array\n  const inputArray = Array.isArray(input) ? input : [input];\n\n  // Process each string in the array\n  const parts: string[] = [];\n\n  for (const item of inputArray) {\n    // Clean the string, split by hyphen, and remove empty strings\n    const cleanedItem = item.replace(/[^a-zA-Z0-9-]/g, '');\n    parts.push(...removeEmptyStringsFromArray(cleanedItem.split('-')));\n  }\n\n  // Process and rejoin the input strings\n  return parts\n    .map(\n      (subString) =>\n        subString.charAt(0).toUpperCase() + subString.slice(1).toLowerCase(),\n    )\n    .join('');\n}\n\n/**\n * Converts a string or an array of strings to Camel Case.\n *\n * This function takes an input string or an array of strings, each potentially containing hyphens,\n * and converts them to Camel Case. It removes any characters that are not letters or numbers,\n * capitalizes the first letter of each substring after the first one, and ensures the rest of the substring\n * is in lowercase. For the first substring, it ensures the entire substring is in lowercase.\n * Finally, it concatenates all these substrings to produce a Camel Case output.\n *\n * @param {string | string[]} input - The input string or array of strings to be converted to Camel Case.\n * @returns {string} The converted string in Camel Case.\n *\n * Examples:\n * toCamelCase(\"hello-world-123!$\") will return \"helloWorld123\"\n * toCamelCase([\"hello\", \"world-123!$\"]) will return \"helloWorld123\"\n */\n\nexport function toCamelCase(input: string | string[]): string {\n  // Ensure input is an array\n  const inputArray = Array.isArray(input) ? input : [input];\n\n  // Process each string in the array\n  const parts: string[] = [];\n\n  for (const item of inputArray) {\n    // Clean the string, split by hyphen, and remove empty strings\n    const cleanedItem = item.replace(/[^a-zA-Z0-9-]/g, '');\n    parts.push(...removeEmptyStringsFromArray(cleanedItem.split('-')));\n  }\n\n  // Process and rejoin the input strings\n  return parts\n    .map((subString, index) =>\n      index === 0\n        ? subString.toLowerCase()\n        : subString.charAt(0).toUpperCase() + subString.slice(1).toLowerCase(),\n    )\n    .join('');\n}\n\n/**\n * This method converts a string or an array of strings to camel case,\n * but if starting with a leading hyphen, it will convert to Pascal case.\n */\n\nexport function toCamelCaseWithPascalOverride(\n  input: string | string[],\n): string {\n  if (isString(input) && input.startsWith('-')) {\n    return toPascalCase(input);\n  } else if (\n    Array.isArray(input) &&\n    input.length > 0 &&\n    input[0].startsWith('-')\n  ) {\n    return toPascalCase(input);\n  } else {\n    return toCamelCase(input);\n  }\n}\n\n/**\n * Converts a string or an array of strings to constant case.\n *\n * The function takes a string or an array of strings, where each string can be separated by a '-',\n * and converts them into a constant case format (all uppercase with underscores between words).\n * It first cleans the input by removing non-alphanumeric characters (except for hyphens), splits the\n * string into parts on hyphens, and then joins these parts with underscores, converting the entire\n * result to uppercase.\n *\n * @param {string | string[]} input - The input string or array of strings to be converted.\n * @returns {string} The converted string in constant case.\n *\n * Example:\n * toConstantCase(\"hello-world\") will return \"HELLO_WORLD\"\n * toConstantCase([\"hello\", \"world\"]) will return \"HELLO_WORLD\"\n */\n\nexport function toConstantCase(input: string | string[]): string {\n  // Ensure input is an array\n  const inputArray = Array.isArray(input) ? input : [input];\n\n  // Process each string in the array\n  let parts: string[] = [];\n\n  for (const item of inputArray) {\n    // Clean the string and split by hyphen\n    const cleanedItem = item.replace(/[^a-zA-Z0-9-]/g, '');\n    parts.push(...cleanedItem.split('-'));\n  }\n\n  // Remove empty strings from the array\n  parts = removeEmptyStringsFromArray(parts);\n\n  // Join parts with underscore and convert to uppercase\n  return parts.join('_').toUpperCase();\n}\n\nexport function splitGraphemes(text: string): string[] {\n  const graphemes: string[] = [];\n  let grapheme = '';\n  let zwjSequence = '';\n\n  for (let i = 0; i < text.length; i++) {\n    const char = text[i];\n    const nextChar = text[i + 1] || '';\n    const code = char.charCodeAt(0);\n\n    // Handling combining marks and zero width joiner\n    if (\n      (code >= 0x0300 && code <= 0x036f) || // Combining Diacritical Marks\n      (code >= 0x1ab0 && code <= 0x1aff) || // Combining Diacritical Marks Extended\n      (code >= 0x1dc0 && code <= 0x1dff) || // Combining Diacritical Marks Supplement\n      (code >= 0xfe20 && code <= 0xfe2f) || // Combining Half Marks\n      (code >= 0x0e31 && code <= 0x0e3a) || // Thai combining marks\n      (code >= 0x0e47 && code <= 0x0e4e)\n    ) {\n      // Thai combining marks\n      grapheme += char;\n    } else if (char === '\\u200d') {\n      // Zero Width Joiner (ZWJ)\n      zwjSequence += grapheme + char;\n      grapheme = '';\n    } else {\n      if (grapheme) {\n        if (zwjSequence) {\n          graphemes.push(zwjSequence + grapheme);\n          zwjSequence = '';\n        } else {\n          graphemes.push(grapheme);\n        }\n      }\n      grapheme = char;\n\n      // Handle surrogate pairs (needed for certain characters including emojis)\n      if (\n        char >= '\\ud800' &&\n        char <= '\\udbff' &&\n        nextChar >= '\\udc00' &&\n        nextChar <= '\\udfff'\n      ) {\n        grapheme += nextChar;\n        i++;\n      }\n    }\n  }\n\n  if (grapheme) {\n    if (zwjSequence) {\n      graphemes.push(zwjSequence + grapheme);\n    } else {\n      graphemes.push(grapheme);\n    }\n  }\n\n  return graphemes;\n}\n\nexport function skipTrailingNewLines(str: string): string {\n  return str.replace(/\\n+$/, '');\n}\n\n/**\n * Filters a string to include only specified characters, optionally replacing disallowed characters.\n *\n * @param str - The input string to be filtered.\n * @param list - An array of allowed characters.\n * @param caseInsensitive - Optional. If true, the filtering is case-insensitive. Default is false.\n * @param replacementChar - Optional. Character to replace disallowed characters. If empty, disallowed characters are removed. Default is ''.\n * @returns A new string containing only the allowed characters from the input string, with disallowed characters optionally replaced.\n *\n * @example\n * // Case-sensitive usage, removing disallowed characters\n * characterAllowedOnly(\"Hello123!\", [\"H\", \"e\", \"l\", \"o\"]);\n * // Returns: \"Hello\"\n *\n * @example\n * // Case-insensitive usage, removing disallowed characters\n * characterAllowedOnly(\"Hello123!\", [\"h\", \"E\", \"L\", \"O\"], true);\n * // Returns: \"Hello\"\n *\n * @example\n * // Using replacement character\n * characterAllowedOnly(\"Hello123!\", [\"H\", \"e\", \"l\", \"o\"], false, \"-\");\n * // Returns: \"Hello---\"\n */\n\nexport function characterAllowedOnly(\n  str: string,\n  list: string[],\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  caseInsensitive = false,\n  replacementChar = '',\n): string {\n  let newStr = '';\n\n  // Convert the allowed list to lowercase if case-insensitive\n  if (caseInsensitive) {\n    list = Array.from(new Set(list.map((item) => item.toLowerCase())));\n  }\n\n  // Convert the entire input string to lowercase if case-insensitive\n  const processedStr = caseInsensitive ? str.toLowerCase() : str;\n\n  for (const c of processedStr) {\n    if (list.includes(c)) {\n      newStr += c;\n    } else if (replacementChar !== '') {\n      newStr += replacementChar;\n    }\n  }\n\n  return newStr;\n}\n\n// functions to chop characters from a string.\n\n/**\n * Will remove the matching first character from a string\n * @param str\n * @param char\n * @returns\n */\n\nexport function chopBeginningCharacter(str: string, char: string): string {\n  if (str.startsWith(char)) {\n    return str.slice(1);\n  } else {\n    return str;\n  }\n}\n\n/**\n * Will remove the matching last character from the string\n * @param str\n * @param char\n * @returns\n */\nexport function chopEndingCharacter(str: string, char: string): string {\n  if (str.endsWith(char)) {\n    return str.slice(0, -1);\n  } else {\n    return str;\n  }\n}\n\n/**\n * Will remove the matching character, from the beginning and/or end of the string if matching\n * @param str\n * @param char\n * @returns\n */\n\nexport function chopBothBeginningAndEndingCharacters(\n  str: string,\n  char: string,\n): string {\n  return chopBeginningCharacter(chopEndingCharacter(str, char), char);\n}\n"],"mappings":"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","names":[]}

package/dist/lib/tmp-dir.cjs

@@ -0,0 +1,254 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/tmp-dir.ts
+var tmp_dir_exports = {};
+__export(tmp_dir_exports, {
+  ErrTmpDirCleanupFailedNotEmpty: () => ErrTmpDirCleanupFailedNotEmpty,
+  ErrTmpDirCleanupUnexpectedError: () => ErrTmpDirCleanupUnexpectedError,
+  ErrTmpDirConfigErrorBaseDirectory: () => ErrTmpDirConfigErrorBaseDirectory,
+  ErrTmpDirConfigErrorMaxTries: () => ErrTmpDirConfigErrorMaxTries,
+  ErrTmpDirInitializeMaxTriesExceeded: () => ErrTmpDirInitializeMaxTriesExceeded,
+  ErrTmpDirNotInitialized: () => ErrTmpDirNotInitialized,
+  ErrTmpDirWasCleanedUp: () => ErrTmpDirWasCleanedUp,
+  TmpDir: () => TmpDir,
+  createTempDir: () => createTempDir
+});
+module.exports = __toCommonJS(tmp_dir_exports);
+var import_path = __toESM(require("path"), 1);
+var import_os = __toESM(require("os"), 1);
+var import_fs = require("fs");
+
+// src/lib/is-number.ts
+function isNumber(value) {
+  return typeof value === "number" && !isNaN(value);
+}
+
+// src/lib/strings.ts
+function isString(value) {
+  return typeof value === "string";
+}
+
+// src/lib/is-boolean.ts
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+
+// src/lib/is-plain-object.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/lib/tmp-dir.ts
+function randomString(length) {
+  const alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+  let result = "";
+  const alphabetLength = alphabet.length;
+  const randomValues = new Uint32Array(length);
+  crypto.getRandomValues(randomValues);
+  for (let i = 0; i < length; i++) {
+    result += alphabet[randomValues[i] % alphabetLength];
+  }
+  return result;
+}
+var ErrTmpDirNotInitialized = class extends Error {
+  constructor() {
+    super("The temporary directory has not been initialized yet.");
+    this.name = "ErrTmpDirNotInitialized";
+  }
+};
+var ErrTmpDirWasCleanedUp = class extends Error {
+  constructor() {
+    super("The temporary directory was already cleaned up.");
+    this.name = "ErrTmpDirWasCleanedUp";
+  }
+};
+var ErrTmpDirConfigErrorBaseDirectory = class extends Error {
+  constructor() {
+    super(
+      "An error occurred with the configuration. `baseDirectory` must be an absolute path."
+    );
+    this.name = "ErrTmpDirConfigErrorBaseDirectory";
+  }
+};
+var ErrTmpDirConfigErrorMaxTries = class extends Error {
+  constructor() {
+    super(
+      "An error occurred with the configuration. `maxTries` must be a positive integer."
+    );
+    this.name = "ErrTmpDirConfigErrorMaxTries";
+  }
+};
+var ErrTmpDirInitializeMaxTriesExceeded = class extends Error {
+  constructor() {
+    super("Could not create a unique temporary directory, maxTries exceeded.");
+    this.name = "ErrTmpDirInitializeMaxTriesExceeded";
+  }
+};
+var ErrTmpDirCleanupFailedNotEmpty = class extends Error {
+  constructor() {
+    super(
+      "Cleanup failed. The temporary directory is not empty and `unsafeCleanup` is false."
+    );
+    this.name = "ErrTmpDirCleanupFailedNotEmpty";
+  }
+};
+var ErrTmpDirCleanupUnexpectedError = class extends Error {
+  additionalInfo;
+  constructor(additionalInfo) {
+    super("Cleanup failed due to an unexpected error.");
+    this.name = "ErrTmpDirCleanupUnexpectedError";
+    this.additionalInfo = additionalInfo;
+  }
+};
+var TmpDir = class {
+  // internal properties
+  isInitialized = false;
+  wasCleanedUp = false;
+  fullTempDirPath = "";
+  // configuration properties
+  allowUnsafeCleanup = false;
+  baseDirectory = "";
+  maxTries = 3;
+  prefix = "tmp";
+  postfix = "";
+  get path() {
+    if (this.wasCleanedUp) {
+      throw new ErrTmpDirWasCleanedUp();
+    } else if (this.isInitialized) {
+      return this.fullTempDirPath;
+    } else {
+      throw new ErrTmpDirNotInitialized();
+    }
+  }
+  constructor(options) {
+    if (isPlainObject(options)) {
+      if (isBoolean(options.unsafeCleanup)) {
+        this.allowUnsafeCleanup = options.unsafeCleanup;
+      }
+      if (isString(options.baseDirectory)) {
+        const baseDirectory = options.baseDirectory.trim();
+        if (import_path.default.isAbsolute(baseDirectory)) {
+          this.baseDirectory = baseDirectory;
+        } else {
+          throw new ErrTmpDirConfigErrorBaseDirectory();
+        }
+      }
+      if (isNumber(options.maxTries)) {
+        const floored = Math.floor(options.maxTries);
+        if (isFinite(floored) && floored > 0) {
+          this.maxTries = floored;
+        } else {
+          throw new ErrTmpDirConfigErrorMaxTries();
+        }
+      }
+      if (isString(options.prefix)) {
+        this.prefix = options.prefix;
+      }
+      if (isString(options.postfix)) {
+        this.postfix = options.postfix;
+      }
+    }
+    if (this.baseDirectory.length === 0) {
+      this.baseDirectory = import_os.default.tmpdir();
+    }
+  }
+  async initialize() {
+    if (!this.isInitialized) {
+      let attemptsMade = 0;
+      while (attemptsMade < this.maxTries) {
+        attemptsMade++;
+        const name = this.generateTempDirName();
+        const fullPath = import_path.default.join(this.baseDirectory, name);
+        let doesPathExist = false;
+        try {
+          await import_fs.promises.stat(fullPath);
+          doesPathExist = true;
+        } catch {
+          doesPathExist = false;
+        }
+        if (!doesPathExist) {
+          await import_fs.promises.mkdir(fullPath, { recursive: true });
+          this.fullTempDirPath = fullPath;
+          this.isInitialized = true;
+          return;
+        }
+      }
+      throw new ErrTmpDirInitializeMaxTriesExceeded();
+    }
+  }
+  async cleanup() {
+    if (this.isInitialized && !this.wasCleanedUp) {
+      try {
+        await import_fs.promises.rm(this.fullTempDirPath, {
+          recursive: this.allowUnsafeCleanup,
+          force: this.allowUnsafeCleanup
+        });
+        this.wasCleanedUp = true;
+      } catch (error) {
+        if (error instanceof Error) {
+          const code = error.code;
+          if (code === "ENOTEMPTY" || code === "EFAULT") {
+            throw new ErrTmpDirCleanupFailedNotEmpty();
+          }
+        }
+        throw new ErrTmpDirCleanupUnexpectedError({
+          originalError: error
+        });
+      }
+    }
+  }
+  generateTempDirName() {
+    return [
+      this.prefix.length > 0 ? this.prefix + "-" : "",
+      process.pid,
+      "-",
+      randomString(12),
+      this.postfix.length > 0 ? "-" + this.postfix : ""
+    ].join("");
+  }
+};
+async function createTempDir(options) {
+  const tmpDir = new TmpDir(options);
+  await tmpDir.initialize();
+  return tmpDir;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ErrTmpDirCleanupFailedNotEmpty,
+  ErrTmpDirCleanupUnexpectedError,
+  ErrTmpDirConfigErrorBaseDirectory,
+  ErrTmpDirConfigErrorMaxTries,
+  ErrTmpDirInitializeMaxTriesExceeded,
+  ErrTmpDirNotInitialized,
+  ErrTmpDirWasCleanedUp,
+  TmpDir,
+  createTempDir
+});
+//# sourceMappingURL=tmp-dir.cjs.map

package/dist/lib/tmp-dir.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/tmp-dir.ts","../../src/lib/is-number.ts","../../src/lib/strings.ts","../../src/lib/is-boolean.ts","../../src/lib/is-plain-object.ts"],"sourcesContent":["import path from 'path';\nimport os from 'os';\nimport { promises as fs } from 'fs';\nimport { isNumber } from './is-number';\nimport { isString } from './strings';\nimport { isBoolean } from './is-boolean';\nimport { isPlainObject } from './is-plain-object';\n\n// Helper functions\nfunction randomString(length: number): string {\n  const alphabet =\n    '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';\n  let result = '';\n  const alphabetLength = alphabet.length;\n  const randomValues = new Uint32Array(length);\n\n  // Generate random values\n  crypto.getRandomValues(randomValues);\n\n  // Use the random values to select characters from the alphabet\n  for (let i = 0; i < length; i++) {\n    result += alphabet[randomValues[i] % alphabetLength];\n  }\n\n  return result;\n}\n\n// Error classes\nexport class ErrTmpDirNotInitialized extends Error {\n  constructor() {\n    super('The temporary directory has not been initialized yet.');\n    this.name = 'ErrTmpDirNotInitialized';\n  }\n}\n\nexport class ErrTmpDirWasCleanedUp extends Error {\n  constructor() {\n    super('The temporary directory was already cleaned up.');\n    this.name = 'ErrTmpDirWasCleanedUp';\n  }\n}\n\nexport class ErrTmpDirConfigErrorBaseDirectory extends Error {\n  constructor() {\n    super(\n      'An error occurred with the configuration. `baseDirectory` must be an absolute path.',\n    );\n    this.name = 'ErrTmpDirConfigErrorBaseDirectory';\n  }\n}\n\nexport class ErrTmpDirConfigErrorMaxTries extends Error {\n  constructor() {\n    super(\n      'An error occurred with the configuration. `maxTries` must be a positive integer.',\n    );\n    this.name = 'ErrTmpDirConfigErrorMaxTries';\n  }\n}\n\nexport class ErrTmpDirInitializeMaxTriesExceeded extends Error {\n  constructor() {\n    super('Could not create a unique temporary directory, maxTries exceeded.');\n    this.name = 'ErrTmpDirInitializeMaxTriesExceeded';\n  }\n}\n\nexport class ErrTmpDirCleanupFailedNotEmpty extends Error {\n  constructor() {\n    super(\n      'Cleanup failed. The temporary directory is not empty and `unsafeCleanup` is false.',\n    );\n    this.name = 'ErrTmpDirCleanupFailedNotEmpty';\n  }\n}\n\nexport class ErrTmpDirCleanupUnexpectedError extends Error {\n  public additionalInfo: { originalError: Error };\n\n  constructor(additionalInfo: { originalError: Error }) {\n    super('Cleanup failed due to an unexpected error.');\n    this.name = 'ErrTmpDirCleanupUnexpectedError';\n    this.additionalInfo = additionalInfo;\n  }\n}\n\ninterface TmpDirOptions {\n  unsafeCleanup?: boolean; // allow cleaning up a directory that is not empty, default: false\n  baseDirectory?: string; // the directory in which the temporary directory should be created, default: os.tmpdir()\n  maxTries?: number; // max number of attempts to create a unique directory, default: 3\n  prefix?: string; // prefix of the created directory, default: 'tmp'\n  postfix?: string; // postfix of the created directory, default: ''\n}\n\n/**\n * Inspired by tmp-promise and tmp-promise with a limited subset of features\n * Was getting an error with the newer versions of `tmp-promise`,\n *\n * TypeError: removeFunction is not a function. (In 'removeFunction(fileOrDirName, next || function() {\n * })', 'removeFunction' is an instance of Object)\n * at _cleanupCallback\n *  at fn (node:util:119:27)\n *\n * so decided to create a simpler version with only the features I need and native to typescript and async/await\n * as was not even using everything included and was a wrapper around another library anyways.\n */\n\nexport class TmpDir {\n  // internal properties\n  private isInitialized = false;\n  private wasCleanedUp = false;\n  private fullTempDirPath = '';\n\n  // configuration properties\n  private allowUnsafeCleanup = false;\n  private baseDirectory = '';\n  private maxTries = 3;\n  private prefix = 'tmp';\n  private postfix = '';\n\n  public get path(): string {\n    if (this.wasCleanedUp) {\n      throw new ErrTmpDirWasCleanedUp();\n    } else if (this.isInitialized) {\n      return this.fullTempDirPath;\n    } else {\n      throw new ErrTmpDirNotInitialized();\n    }\n  }\n\n  constructor(options?: TmpDirOptions) {\n    if (isPlainObject(options)) {\n      if (isBoolean(options.unsafeCleanup)) {\n        this.allowUnsafeCleanup = options.unsafeCleanup;\n      }\n\n      if (isString(options.baseDirectory)) {\n        // trim the baseDirectory just in case\n        const baseDirectory = options.baseDirectory.trim();\n\n        // check if the baseDirectory is an absolute path\n        if (path.isAbsolute(baseDirectory)) {\n          this.baseDirectory = baseDirectory;\n        } else {\n          throw new ErrTmpDirConfigErrorBaseDirectory();\n        }\n      }\n\n      if (isNumber(options.maxTries)) {\n        const floored = Math.floor(options.maxTries);\n\n        if (isFinite(floored) && floored > 0) {\n          this.maxTries = floored;\n        } else {\n          throw new ErrTmpDirConfigErrorMaxTries();\n        }\n      }\n\n      if (isString(options.prefix)) {\n        this.prefix = options.prefix;\n      }\n\n      if (isString(options.postfix)) {\n        this.postfix = options.postfix;\n      }\n    }\n\n    // if the baseDirectory is not set, use the system temp directory\n    if (this.baseDirectory.length === 0) {\n      this.baseDirectory = os.tmpdir();\n    }\n  }\n\n  public async initialize(): Promise<void> {\n    if (!this.isInitialized) {\n      let attemptsMade = 0;\n\n      // attempt this while the attemptsMade is less than the maxTries\n      while (attemptsMade < this.maxTries) {\n        attemptsMade++; // increment the attempts made\n\n        // generate a temporary directory name\n        const name = this.generateTempDirName();\n\n        // check if the path exists\n        const fullPath = path.join(this.baseDirectory, name);\n\n        let doesPathExist = false;\n        try {\n          await fs.stat(fullPath);\n          doesPathExist = true;\n        } catch {\n          // Path doesn't exist, which is what we want\n          doesPathExist = false;\n        }\n\n        // only proceed if path doesn't exist\n        if (!doesPathExist) {\n          // create the directory\n          await fs.mkdir(fullPath, { recursive: true });\n\n          // set isInitialized to true and return\n          this.fullTempDirPath = fullPath;\n          this.isInitialized = true;\n\n          return;\n        }\n      }\n\n      // if the loop completes without finding a unique directory, throw an error\n      throw new ErrTmpDirInitializeMaxTriesExceeded();\n    }\n  }\n\n  public async cleanup(): Promise<void> {\n    if (this.isInitialized && !this.wasCleanedUp) {\n      try {\n        await fs.rm(this.fullTempDirPath, {\n          recursive: this.allowUnsafeCleanup,\n          force: this.allowUnsafeCleanup,\n        });\n\n        this.wasCleanedUp = true;\n      } catch (error) {\n        // Check if directory is not empty\n        // Different runtimes may return different error codes:\n        // - ENOTEMPTY: directory not empty (Node.js)\n        // - EFAULT: bad address (Bun when trying to delete non-empty dir without recursive)\n        // - ENOENT: doesn't exist (already cleaned up, this shouldn't happen but handle it)\n        if (error instanceof Error) {\n          const code = (error as NodeJS.ErrnoException).code;\n          if (code === 'ENOTEMPTY' || code === 'EFAULT') {\n            throw new ErrTmpDirCleanupFailedNotEmpty();\n          }\n        }\n\n        throw new ErrTmpDirCleanupUnexpectedError({\n          originalError: error as Error,\n        });\n      }\n    }\n  }\n\n  private generateTempDirName(): string {\n    return [\n      this.prefix.length > 0 ? this.prefix + '-' : '',\n      process.pid,\n      '-',\n      randomString(12),\n      this.postfix.length > 0 ? '-' + this.postfix : '',\n    ].join('');\n  }\n}\n\nexport async function createTempDir(options?: TmpDirOptions): Promise<TmpDir> {\n  const tmpDir = new TmpDir(options);\n\n  await tmpDir.initialize();\n\n  return tmpDir;\n}\n","/**\n * Type guard to check if a value is a valid number.\n *\n * @param value - Value to check\n * @returns `true` if the value is a number and not NaN, `false` otherwise\n *\n * @example\n * ```typescript\n * isNumber(42);        // true\n * isNumber(3.14);      // true\n * isNumber(NaN);       // false\n * isNumber('123');     // false\n * isNumber(null);      // false\n * isNumber(undefined); // false\n * ```\n */\nexport function isNumber(value: unknown): value is number {\n  return typeof value === 'number' && !isNaN(value);\n}\n\n/**\n * Type guard to check if a value is a finite number.\n *\n * @param value - Value to check\n * @returns `true` if the value is a number and is finite (excludes NaN, Infinity, -Infinity), `false` otherwise\n *\n * @example\n * ```typescript\n * isFiniteNumber(42);        // true\n * isFiniteNumber(3.14);      // true\n * isFiniteNumber(Infinity);  // false\n * isFiniteNumber(-Infinity); // false\n * isFiniteNumber(NaN);       // false\n * isFiniteNumber('123');     // false\n * isFiniteNumber(null);      // false\n * isFiniteNumber(undefined); // false\n * ```\n */\nexport function isFiniteNumber(value: unknown): value is number {\n  return typeof value === 'number' && isFinite(value);\n}\n","import { removeEmptyStringsFromArray } from './arrays';\n\nexport function isString(value: unknown): value is string {\n  return typeof value === 'string';\n}\n\n/**\n * Converts a string or an array of strings to Pascal Case.\n *\n * This function takes an input string or an array of strings, each potentially containing hyphens,\n * and converts them to Pascal Case. It removes any characters that are not letters or numbers,\n * capitalizes the first letter of each substring, and ensures the rest of the substring\n * is in lowercase. Finally, it concatenates all these substrings to produce a Pascal Case\n * output.\n *\n * @param {string | string[]} input - The input string or array of strings to be converted to Pascal Case.\n * @returns {string} The converted string in Pascal Case.\n *\n * Examples:\n * toPascalCase(\"hello-world-123!$\") will return \"HelloWorld123\"\n * toPascalCase([\"hello\", \"world-123!$\"]) will return \"HelloWorld123\"\n */\n\nexport function toPascalCase(input: string | string[]): string {\n  // Ensure input is an array\n  const inputArray = Array.isArray(input) ? input : [input];\n\n  // Process each string in the array\n  const parts: string[] = [];\n\n  for (const item of inputArray) {\n    // Clean the string, split by hyphen, and remove empty strings\n    const cleanedItem = item.replace(/[^a-zA-Z0-9-]/g, '');\n    parts.push(...removeEmptyStringsFromArray(cleanedItem.split('-')));\n  }\n\n  // Process and rejoin the input strings\n  return parts\n    .map(\n      (subString) =>\n        subString.charAt(0).toUpperCase() + subString.slice(1).toLowerCase(),\n    )\n    .join('');\n}\n\n/**\n * Converts a string or an array of strings to Camel Case.\n *\n * This function takes an input string or an array of strings, each potentially containing hyphens,\n * and converts them to Camel Case. It removes any characters that are not letters or numbers,\n * capitalizes the first letter of each substring after the first one, and ensures the rest of the substring\n * is in lowercase. For the first substring, it ensures the entire substring is in lowercase.\n * Finally, it concatenates all these substrings to produce a Camel Case output.\n *\n * @param {string | string[]} input - The input string or array of strings to be converted to Camel Case.\n * @returns {string} The converted string in Camel Case.\n *\n * Examples:\n * toCamelCase(\"hello-world-123!$\") will return \"helloWorld123\"\n * toCamelCase([\"hello\", \"world-123!$\"]) will return \"helloWorld123\"\n */\n\nexport function toCamelCase(input: string | string[]): string {\n  // Ensure input is an array\n  const inputArray = Array.isArray(input) ? input : [input];\n\n  // Process each string in the array\n  const parts: string[] = [];\n\n  for (const item of inputArray) {\n    // Clean the string, split by hyphen, and remove empty strings\n    const cleanedItem = item.replace(/[^a-zA-Z0-9-]/g, '');\n    parts.push(...removeEmptyStringsFromArray(cleanedItem.split('-')));\n  }\n\n  // Process and rejoin the input strings\n  return parts\n    .map((subString, index) =>\n      index === 0\n        ? subString.toLowerCase()\n        : subString.charAt(0).toUpperCase() + subString.slice(1).toLowerCase(),\n    )\n    .join('');\n}\n\n/**\n * This method converts a string or an array of strings to camel case,\n * but if starting with a leading hyphen, it will convert to Pascal case.\n */\n\nexport function toCamelCaseWithPascalOverride(\n  input: string | string[],\n): string {\n  if (isString(input) && input.startsWith('-')) {\n    return toPascalCase(input);\n  } else if (\n    Array.isArray(input) &&\n    input.length > 0 &&\n    input[0].startsWith('-')\n  ) {\n    return toPascalCase(input);\n  } else {\n    return toCamelCase(input);\n  }\n}\n\n/**\n * Converts a string or an array of strings to constant case.\n *\n * The function takes a string or an array of strings, where each string can be separated by a '-',\n * and converts them into a constant case format (all uppercase with underscores between words).\n * It first cleans the input by removing non-alphanumeric characters (except for hyphens), splits the\n * string into parts on hyphens, and then joins these parts with underscores, converting the entire\n * result to uppercase.\n *\n * @param {string | string[]} input - The input string or array of strings to be converted.\n * @returns {string} The converted string in constant case.\n *\n * Example:\n * toConstantCase(\"hello-world\") will return \"HELLO_WORLD\"\n * toConstantCase([\"hello\", \"world\"]) will return \"HELLO_WORLD\"\n */\n\nexport function toConstantCase(input: string | string[]): string {\n  // Ensure input is an array\n  const inputArray = Array.isArray(input) ? input : [input];\n\n  // Process each string in the array\n  let parts: string[] = [];\n\n  for (const item of inputArray) {\n    // Clean the string and split by hyphen\n    const cleanedItem = item.replace(/[^a-zA-Z0-9-]/g, '');\n    parts.push(...cleanedItem.split('-'));\n  }\n\n  // Remove empty strings from the array\n  parts = removeEmptyStringsFromArray(parts);\n\n  // Join parts with underscore and convert to uppercase\n  return parts.join('_').toUpperCase();\n}\n\nexport function splitGraphemes(text: string): string[] {\n  const graphemes: string[] = [];\n  let grapheme = '';\n  let zwjSequence = '';\n\n  for (let i = 0; i < text.length; i++) {\n    const char = text[i];\n    const nextChar = text[i + 1] || '';\n    const code = char.charCodeAt(0);\n\n    // Handling combining marks and zero width joiner\n    if (\n      (code >= 0x0300 && code <= 0x036f) || // Combining Diacritical Marks\n      (code >= 0x1ab0 && code <= 0x1aff) || // Combining Diacritical Marks Extended\n      (code >= 0x1dc0 && code <= 0x1dff) || // Combining Diacritical Marks Supplement\n      (code >= 0xfe20 && code <= 0xfe2f) || // Combining Half Marks\n      (code >= 0x0e31 && code <= 0x0e3a) || // Thai combining marks\n      (code >= 0x0e47 && code <= 0x0e4e)\n    ) {\n      // Thai combining marks\n      grapheme += char;\n    } else if (char === '\\u200d') {\n      // Zero Width Joiner (ZWJ)\n      zwjSequence += grapheme + char;\n      grapheme = '';\n    } else {\n      if (grapheme) {\n        if (zwjSequence) {\n          graphemes.push(zwjSequence + grapheme);\n          zwjSequence = '';\n        } else {\n          graphemes.push(grapheme);\n        }\n      }\n      grapheme = char;\n\n      // Handle surrogate pairs (needed for certain characters including emojis)\n      if (\n        char >= '\\ud800' &&\n        char <= '\\udbff' &&\n        nextChar >= '\\udc00' &&\n        nextChar <= '\\udfff'\n      ) {\n        grapheme += nextChar;\n        i++;\n      }\n    }\n  }\n\n  if (grapheme) {\n    if (zwjSequence) {\n      graphemes.push(zwjSequence + grapheme);\n    } else {\n      graphemes.push(grapheme);\n    }\n  }\n\n  return graphemes;\n}\n\nexport function skipTrailingNewLines(str: string): string {\n  return str.replace(/\\n+$/, '');\n}\n\n/**\n * Filters a string to include only specified characters, optionally replacing disallowed characters.\n *\n * @param str - The input string to be filtered.\n * @param list - An array of allowed characters.\n * @param caseInsensitive - Optional. If true, the filtering is case-insensitive. Default is false.\n * @param replacementChar - Optional. Character to replace disallowed characters. If empty, disallowed characters are removed. Default is ''.\n * @returns A new string containing only the allowed characters from the input string, with disallowed characters optionally replaced.\n *\n * @example\n * // Case-sensitive usage, removing disallowed characters\n * characterAllowedOnly(\"Hello123!\", [\"H\", \"e\", \"l\", \"o\"]);\n * // Returns: \"Hello\"\n *\n * @example\n * // Case-insensitive usage, removing disallowed characters\n * characterAllowedOnly(\"Hello123!\", [\"h\", \"E\", \"L\", \"O\"], true);\n * // Returns: \"Hello\"\n *\n * @example\n * // Using replacement character\n * characterAllowedOnly(\"Hello123!\", [\"H\", \"e\", \"l\", \"o\"], false, \"-\");\n * // Returns: \"Hello---\"\n */\n\nexport function characterAllowedOnly(\n  str: string,\n  list: string[],\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  caseInsensitive = false,\n  replacementChar = '',\n): string {\n  let newStr = '';\n\n  // Convert the allowed list to lowercase if case-insensitive\n  if (caseInsensitive) {\n    list = Array.from(new Set(list.map((item) => item.toLowerCase())));\n  }\n\n  // Convert the entire input string to lowercase if case-insensitive\n  const processedStr = caseInsensitive ? str.toLowerCase() : str;\n\n  for (const c of processedStr) {\n    if (list.includes(c)) {\n      newStr += c;\n    } else if (replacementChar !== '') {\n      newStr += replacementChar;\n    }\n  }\n\n  return newStr;\n}\n\n// functions to chop characters from a string.\n\n/**\n * Will remove the matching first character from a string\n * @param str\n * @param char\n * @returns\n */\n\nexport function chopBeginningCharacter(str: string, char: string): string {\n  if (str.startsWith(char)) {\n    return str.slice(1);\n  } else {\n    return str;\n  }\n}\n\n/**\n * Will remove the matching last character from the string\n * @param str\n * @param char\n * @returns\n */\nexport function chopEndingCharacter(str: string, char: string): string {\n  if (str.endsWith(char)) {\n    return str.slice(0, -1);\n  } else {\n    return str;\n  }\n}\n\n/**\n * Will remove the matching character, from the beginning and/or end of the string if matching\n * @param str\n * @param char\n * @returns\n */\n\nexport function chopBothBeginningAndEndingCharacters(\n  str: string,\n  char: string,\n): string {\n  return chopBeginningCharacter(chopEndingCharacter(str, char), char);\n}\n","/**\n * Type guard to check if a value is a boolean.\n *\n * @param value - Value to check\n * @returns `true` if the value is a boolean, `false` otherwise\n *\n * @example\n * ```typescript\n * isBoolean(true);       // true\n * isBoolean(false);      // true\n * isBoolean(1);          // false\n * isBoolean('true');     // false\n * isBoolean(null);       // false\n * isBoolean(undefined);  // false\n * ```\n */\nexport function isBoolean(value: unknown): value is boolean {\n  return typeof value === 'boolean';\n}\n","/**\n * Type guard to check if a value is a plain object (not null, not an array).\n *\n * @param value - Value to check\n * @returns `true` if the value is a plain object, `false` otherwise\n *\n * @example\n * ```typescript\n * isPlainObject({});           // true\n * isPlainObject({ a: 1 });     // true\n * isPlainObject([]);           // false\n * isPlainObject(null);         // false\n * isPlainObject(undefined);    // false\n * isPlainObject('string');     // false\n * isPlainObject(42);           // false\n * ```\n */\nexport function isPlainObject(\n  value: unknown,\n): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n"],"mappings":"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","names":["path","os","fs"]}

package/dist/lib/tmp-dir.d.cts

@@ -0,0 +1,63 @@
+declare class ErrTmpDirNotInitialized extends Error {
+    constructor();
+}
+declare class ErrTmpDirWasCleanedUp extends Error {
+    constructor();
+}
+declare class ErrTmpDirConfigErrorBaseDirectory extends Error {
+    constructor();
+}
+declare class ErrTmpDirConfigErrorMaxTries extends Error {
+    constructor();
+}
+declare class ErrTmpDirInitializeMaxTriesExceeded extends Error {
+    constructor();
+}
+declare class ErrTmpDirCleanupFailedNotEmpty extends Error {
+    constructor();
+}
+declare class ErrTmpDirCleanupUnexpectedError extends Error {
+    additionalInfo: {
+        originalError: Error;
+    };
+    constructor(additionalInfo: {
+        originalError: Error;
+    });
+}
+interface TmpDirOptions {
+    unsafeCleanup?: boolean;
+    baseDirectory?: string;
+    maxTries?: number;
+    prefix?: string;
+    postfix?: string;
+}
+/**
+ * Inspired by tmp-promise and tmp-promise with a limited subset of features
+ * Was getting an error with the newer versions of `tmp-promise`,
+ *
+ * TypeError: removeFunction is not a function. (In 'removeFunction(fileOrDirName, next || function() {
+ * })', 'removeFunction' is an instance of Object)
+ * at _cleanupCallback
+ *  at fn (node:util:119:27)
+ *
+ * so decided to create a simpler version with only the features I need and native to typescript and async/await
+ * as was not even using everything included and was a wrapper around another library anyways.
+ */
+declare class TmpDir {
+    private isInitialized;
+    private wasCleanedUp;
+    private fullTempDirPath;
+    private allowUnsafeCleanup;
+    private baseDirectory;
+    private maxTries;
+    private prefix;
+    private postfix;
+    get path(): string;
+    constructor(options?: TmpDirOptions);
+    initialize(): Promise<void>;
+    cleanup(): Promise<void>;
+    private generateTempDirName;
+}
+declare function createTempDir(options?: TmpDirOptions): Promise<TmpDir>;
+
+export { ErrTmpDirCleanupFailedNotEmpty, ErrTmpDirCleanupUnexpectedError, ErrTmpDirConfigErrorBaseDirectory, ErrTmpDirConfigErrorMaxTries, ErrTmpDirInitializeMaxTriesExceeded, ErrTmpDirNotInitialized, ErrTmpDirWasCleanedUp, TmpDir, createTempDir };