@stonyx/utils 0.2.3-beta.14 → 0.2.3-beta.15

package/dist/date.d.ts

@@ -0,0 +1 @@
+export declare function getTimestamp(dateObject?: Date | null): number;

package/dist/date.js

@@ -0,0 +1,4 @@
+export function getTimestamp(dateObject = null) {
+    const ts = dateObject ? dateObject.getTime() : Date.now();
+    return Math.floor(ts / 1000);
+}

package/dist/file.d.ts

@@ -0,0 +1,35 @@
+interface FileOptions {
+    json?: boolean;
+}
+interface ReadFileOptions extends FileOptions {
+    missingFileCallback?: (filePath: string) => unknown;
+}
+interface DeleteFileOptions {
+    ignoreAccessFailure?: boolean;
+}
+interface ForEachFileImportOptions {
+    ignoreAccessFailure?: boolean;
+    recursive?: boolean;
+    recursiveNaming?: boolean;
+    rawName?: boolean;
+    namePrefix?: string;
+    fullExport?: boolean;
+}
+interface FileImportMeta {
+    name: string;
+    stats: import('fs').Stats;
+    path: string;
+}
+export declare function createFile(filePath: string, data: unknown, options?: FileOptions): Promise<void>;
+export declare function updateFile(filePath: string, data: unknown, options?: FileOptions): Promise<void>;
+interface CopyFileOptions {
+    overwrite?: boolean;
+}
+export declare function copyFile(sourcePath: string, targetPath: string, options?: CopyFileOptions): Promise<boolean>;
+export declare function readFile(filePath: string, options?: ReadFileOptions): Promise<unknown>;
+export declare function deleteFile(filePath: string, options?: DeleteFileOptions): Promise<void>;
+export declare function deleteDirectory(dir: string): Promise<void>;
+export declare function createDirectory(dir: string): Promise<void>;
+export declare function forEachFileImport(dir: string, callback: (output: unknown, meta: FileImportMeta) => void, options?: ForEachFileImportOptions): Promise<void>;
+export declare function fileExists(filePath: string): Promise<boolean>;
+export {};

package/dist/file.js

@@ -0,0 +1,128 @@
+import { getTimestamp } from './date.js';
+import { kebabCaseToCamelCase } from './string.js';
+import { objToJson } from './object.js';
+import { promises as fsp } from 'fs';
+import path from 'path';
+export async function createFile(filePath, data, options = {}) {
+    try {
+        filePath = path.resolve(filePath);
+        await createDirectory(path.dirname(filePath));
+        await fsp.writeFile(filePath, options.json ? objToJson(data) : data, 'utf8');
+    }
+    catch (error) {
+        throw new Error(String(error));
+    }
+}
+export async function updateFile(filePath, data, options = {}) {
+    try {
+        await fsp.access(filePath);
+        const swapFile = `${filePath}.temp-${getTimestamp()}`;
+        await fsp.writeFile(swapFile, options.json ? objToJson(data) : data);
+        await fsp.rename(swapFile, filePath);
+    }
+    catch (error) {
+        throw new Error(String(error));
+    }
+}
+export async function copyFile(sourcePath, targetPath, options = {}) {
+    try {
+        sourcePath = path.resolve(sourcePath);
+        targetPath = path.resolve(targetPath);
+        await fsp.access(sourcePath);
+    }
+    catch (error) {
+        throw new Error(String(error));
+    }
+    try {
+        await fsp.access(targetPath);
+        if (!options.overwrite)
+            return false;
+    }
+    catch { }
+    try {
+        await fsp.copyFile(sourcePath, targetPath);
+    }
+    catch (error) {
+        throw new Error(String(error));
+    }
+    return true;
+}
+export async function readFile(filePath, options = {}) {
+    try {
+        filePath = path.resolve(filePath);
+        await fsp.access(filePath);
+        const fileData = await fsp.readFile(filePath, 'utf8');
+        return options.json ? JSON.parse(fileData) : fileData;
+    }
+    catch (error) {
+        const { missingFileCallback } = options;
+        if (error.code === 'ENOENT' && missingFileCallback) {
+            return missingFileCallback(filePath);
+        }
+        throw new Error(String(error));
+    }
+}
+export async function deleteFile(filePath, options) {
+    try {
+        filePath = path.resolve(filePath);
+        await fsp.access(filePath);
+    }
+    catch (error) {
+        if (options?.ignoreAccessFailure)
+            return;
+        throw error;
+    }
+    await fsp.unlink(filePath);
+}
+export async function deleteDirectory(dir) {
+    await fsp.rm(dir, { recursive: true, force: true });
+}
+export async function createDirectory(dir) {
+    await fsp.mkdir(dir, { recursive: true });
+}
+export async function forEachFileImport(dir, callback, options = {}) {
+    if (typeof callback !== 'function')
+        throw new Error('Callback must be valid function');
+    try {
+        await fsp.access(dir);
+    }
+    catch (error) {
+        if (!options.ignoreAccessFailure)
+            throw new Error(`Unable to access directory: ${dir}`);
+        return;
+    }
+    const files = await fsp.readdir(dir);
+    for (const file of files) {
+        const filePath = path.join(dir, file);
+        const stats = await fsp.stat(filePath);
+        if (options.recursive && stats.isDirectory()) {
+            const newOptions = { ...options };
+            if (options.recursiveNaming) {
+                const pathPrefix = options.rawName ? file : `${kebabCaseToCamelCase(file)}`;
+                newOptions.namePrefix = options.namePrefix ? `${options.namePrefix}${pathPrefix}/` : `${pathPrefix}/`;
+            }
+            await forEachFileImport(filePath, callback, newOptions);
+            continue;
+        }
+        if (!stats.isFile() || !file.endsWith('.js'))
+            continue;
+        const prefix = process.platform === 'win32' ? 'file://' : '';
+        const rawName = file.replace('.js', '');
+        let name = options.rawName ? rawName : kebabCaseToCamelCase(rawName);
+        if (options.namePrefix)
+            name = `${options.namePrefix}${name}`;
+        const exported = await import(prefix + path.resolve(filePath));
+        const output = !options.fullExport ? exported.default : exported;
+        callback(output, { name, stats, path: filePath });
+    }
+}
+export async function fileExists(filePath) {
+    try {
+        filePath = path.resolve(filePath);
+        await fsp.access(filePath);
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}

package/dist/object.d.ts

@@ -0,0 +1,11 @@
+export declare function deepCopy<T>(obj: T): T;
+export declare function objToJson(obj: unknown, format?: string | number): string;
+export declare function makeArray<T>(obj: T | T[]): T[];
+interface MergeOptions {
+    ignoreNewKeys?: boolean;
+}
+export declare function mergeObject(obj1: Record<string, unknown>, obj2: Record<string, unknown>, options?: MergeOptions): Record<string, unknown>;
+export declare function get(obj: Record<string, unknown>, path: string): unknown;
+export declare function get(obj: unknown, path?: unknown): void;
+export declare function getOrSet<K, V>(map: Map<K, V>, key: K, defaultValue: V | (() => V)): V;
+export {};

package/dist/object.js

@@ -0,0 +1,58 @@
+export function deepCopy(obj) {
+    return JSON.parse(JSON.stringify(obj));
+}
+export function objToJson(obj, format = '\t') {
+    return JSON.stringify(obj, null, format);
+}
+export function makeArray(obj) {
+    return Array.isArray(obj) ? obj : [obj];
+}
+function cloneShallow(value) {
+    if (Array.isArray(value))
+        return value.slice();
+    if (value && typeof value === 'object')
+        return { ...value };
+    return value;
+}
+export function mergeObject(obj1, obj2, options = {}) {
+    if (Array.isArray(obj1) || Array.isArray(obj2))
+        throw new Error('Cannot merge arrays.');
+    if (obj1 === null || typeof obj1 !== 'object')
+        return cloneShallow(obj2);
+    if (obj2 === null || typeof obj2 !== 'object')
+        return cloneShallow(obj1);
+    const result = {};
+    for (const key of Object.keys(obj1))
+        result[key] = cloneShallow(obj1[key]);
+    for (const key of Object.keys(obj2)) {
+        if (options.ignoreNewKeys && !(key in obj1))
+            continue;
+        const val1 = obj1[key];
+        const val2 = obj2[key];
+        const shouldMerge = val1 && val2 && typeof val1 === 'object' && typeof val2 === 'object' && !Array.isArray(val1) && !Array.isArray(val2);
+        result[key] = shouldMerge ? mergeObject(val1, val2, options) : cloneShallow(val2);
+    }
+    return result;
+}
+export function get(obj, path) {
+    if (arguments.length !== 2)
+        return console.error('Get must be called with two arguments; an object and a property key.');
+    if (!obj)
+        return console.error(`Cannot call get with '${path}' on an undefined object.`);
+    if (typeof path !== 'string')
+        return console.error('The path provided to get must be a string.');
+    let current = obj;
+    for (const key of path.split('.')) {
+        if (current[key] === undefined)
+            return;
+        current = current[key];
+    }
+    return current;
+}
+export function getOrSet(map, key, defaultValue) {
+    if (!(map instanceof Map))
+        throw new Error('First argument to getOrSet must be a Map.');
+    if (!map.has(key))
+        map.set(key, typeof defaultValue === "function" ? defaultValue() : defaultValue);
+    return map.get(key);
+}

package/dist/plurarize.d.ts

@@ -0,0 +1 @@
+export default function pluralize(word: string): string;

package/dist/plurarize.js

@@ -0,0 +1,87 @@
+// --- Irregular nouns ---
+const irregular = {
+    person: 'people',
+    man: 'men',
+    woman: 'women',
+    child: 'children',
+    tooth: 'teeth',
+    foot: 'feet',
+    mouse: 'mice',
+    goose: 'geese',
+    ox: 'oxen',
+    cactus: 'cacti',
+    nucleus: 'nuclei',
+    syllabus: 'syllabi',
+    focus: 'foci',
+    fungus: 'fungi',
+    appendix: 'appendices',
+    index: 'indices',
+    criterion: 'criteria',
+    phenomenon: 'phenomena',
+    die: 'dice',
+    thesis: 'theses',
+    analysis: 'analyses',
+    crisis: 'crises',
+    radius: 'radii',
+    corpus: 'corpora',
+};
+// --- Uncountables ---
+const uncountable = new Set([
+    'sheep', 'fish', 'deer', 'series', 'species', 'news', 'information',
+    'rice', 'moose', 'bison', 'salmon', 'aircraft', 'offspring'
+]);
+// --- Exceptions ---
+const fExceptions = new Set(['chief', 'roof', 'belief', 'chef', 'cliff', 'reef', 'proof', 'brief']);
+// Keep only true irregular -o exceptions (consonant + o but take just "s")
+const oExceptions = new Set(['piano', 'photo', 'halo', 'canto', 'solo']);
+// --- Utility to preserve casing ---
+function applyCasing(original, plural) {
+    if (original === original.toUpperCase())
+        return plural.toUpperCase();
+    if (original === original.toLowerCase())
+        return plural.toLowerCase();
+    if (original[0] === original[0].toUpperCase()) {
+        return plural.charAt(0).toUpperCase() + plural.slice(1);
+    }
+    return plural;
+}
+// --- Rule-based pluralization ---
+const rules = [
+    // quiz -> quizzes, waltz -> waltzes, topaz -> topazes
+    [/z$/i, w => (/iz$/i.test(w) ? w + 'zes' : w + 'es')],
+    // bus -> buses, box -> boxes, church -> churches, but stomach -> stomachs (exclude -ach)
+    [/(s|x|ch|sh)$/i, w => (/ach$/i.test(w) ? w + 's' : w + 'es')],
+    // vowel + y -> +s (key -> keys)
+    [/[aeiou]y$/i, w => w + 's'],
+    // consonant + y -> -ies (city -> cities)
+    [/y$/i, w => w.slice(0, -1) + 'ies'],
+    // -fe -> -ves (knife -> knives), but not chief/roof/etc
+    [/fe$/i, w => (fExceptions.has(w) ? w + 's' : w.slice(0, -2) + 'ves')],
+    // -f -> -ves (wolf -> wolves), but not cliff/etc
+    [/f$/i, w => (fExceptions.has(w) ? w + 's' : w.slice(0, -1) + 'ves')],
+    // -sis -> -ses (analysis -> analyses, thesis -> theses)
+    [/sis$/i, w => w.slice(0, -2) + 'ses'],
+    // vowel + o -> +s (zoo -> zoos, video -> videos, patio -> patios)
+    [/[aeiou]o$/i, w => w + 's'],
+    // consonant + o -> usually +es, unless in oExceptions
+    [/o$/i, w => (oExceptions.has(w) ? w + 's' : w + 'es')],
+    // default: just +s
+    [/$/i, w => w + 's']
+];
+// --- Exported pluralizer ---
+export default function pluralize(word) {
+    if (typeof word !== 'string' || !/^[a-zA-Z]+$/.test(word))
+        return word;
+    const lower = word.toLowerCase();
+    if (uncountable.has(lower))
+        return word;
+    if (irregular[lower]) {
+        return applyCasing(word, irregular[lower]);
+    }
+    for (const [pattern, transform] of rules) {
+        if (pattern.test(lower)) {
+            return applyCasing(word, transform(lower));
+        }
+    }
+    return word; // fallback (shouldn't hit)
+}

package/dist/promise.d.ts

@@ -0,0 +1 @@
+export declare function sleep(seconds: number): Promise<void>;

package/dist/promise.js

@@ -0,0 +1,5 @@
+export async function sleep(seconds) {
+    return new Promise(resolve => {
+        setTimeout(resolve, 1000 * seconds);
+    });
+}

package/dist/prompt.d.ts

@@ -0,0 +1,8 @@
+import type { Readable, Writable } from 'stream';
+interface PromptOptions {
+    input?: Readable;
+    output?: Writable;
+}
+export declare function confirm(question: string, { input, output }?: PromptOptions): Promise<boolean>;
+export declare function prompt(question: string, { input, output }?: PromptOptions): Promise<string>;
+export {};

package/dist/prompt.js

@@ -0,0 +1,25 @@
+import { createInterface } from 'readline';
+export function confirm(question, { input, output } = {}) {
+    const rl = createInterface({
+        input: input ?? process.stdin,
+        output: output ?? process.stdout,
+    });
+    return new Promise(resolve => {
+        rl.question(`${question} (y/N) `, (answer) => {
+            rl.close();
+            resolve(answer.trim().toLowerCase() === 'y');
+        });
+    });
+}
+export function prompt(question, { input, output } = {}) {
+    const rl = createInterface({
+        input: input ?? process.stdin,
+        output: output ?? process.stdout,
+    });
+    return new Promise(resolve => {
+        rl.question(`${question} `, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}

package/dist/string.d.ts

@@ -0,0 +1,5 @@
+export declare function kebabCaseToCamelCase(str: string): string;
+export declare function kebabCaseToPascalCase(str: string): string;
+export declare function camelCaseToKebabCase(str: string): string;
+export declare function generateRandomString(length?: number): string;
+export { default as pluralize } from './plurarize.js';

package/dist/string.js

@@ -0,0 +1,32 @@
+function kebabToCase(str, pascal = false) {
+    let out = '';
+    let upperNext = pascal; // PascalCase starts uppercase
+    for (let i = 0; i < str.length; i++) {
+        const ch = str.charAt(i);
+        if (ch === '-') {
+            upperNext = true;
+        }
+        else if (upperNext) {
+            out += ch.toUpperCase();
+            upperNext = false;
+        }
+        else {
+            out += ch;
+        }
+    }
+    return out;
+}
+export function kebabCaseToCamelCase(str) {
+    return kebabToCase(str, false);
+}
+export function kebabCaseToPascalCase(str) {
+    return kebabToCase(str, true);
+}
+export function camelCaseToKebabCase(str) {
+    return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+}
+export function generateRandomString(length = 8) {
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    return Array(length).fill('').map(() => characters.charAt(Math.floor(Math.random() * characters.length))).join('');
+}
+export { default as pluralize } from './plurarize.js';

package/package.json

@@ -3,7 +3,7 @@
   "keywords": [
     "stonyx-module"
   ],
-  "version": "0.2.3-beta.14",
+  "version": "0.2.3-beta.15",
   "description": "Utils module for Stonyx Framework",
   "repository": {
     "type": "git",
@@ -11,16 +11,34 @@
   },
   "type": "module",
   "files": [
-    "src",
+    "dist",
     "README.md"
   ],
   "exports": {
-    "./date": "./src/date.js",
-    "./object": "./src/object.js",
-    "./file": "./src/file.js",
-    "./promise": "./src/promise.js",
-    "./prompt": "./src/prompt.js",
-    "./string": "./src/string.js"
+    "./date": {
+      "types": "./dist/date.d.ts",
+      "default": "./dist/date.js"
+    },
+    "./object": {
+      "types": "./dist/object.d.ts",
+      "default": "./dist/object.js"
+    },
+    "./file": {
+      "types": "./dist/file.d.ts",
+      "default": "./dist/file.js"
+    },
+    "./promise": {
+      "types": "./dist/promise.d.ts",
+      "default": "./dist/promise.js"
+    },
+    "./prompt": {
+      "types": "./dist/prompt.d.ts",
+      "default": "./dist/prompt.js"
+    },
+    "./string": {
+      "types": "./dist/string.d.ts",
+      "default": "./dist/string.js"
+    }
   },
   "publishConfig": {
     "access": "public",
@@ -32,12 +50,14 @@
     "Stone Costa <stone.costa@synamicd.com>"
   ],
   "devDependencies": {
+    "@types/node": "^25.5.2",
     "fs": "^0.0.1-security",
     "qunit": "^2.24.1",
-    "sinon": "^21.0.0"
+    "sinon": "^21.0.0",
+    "typescript": "^5.8.3"
   },
-  "dependencies": {},
   "scripts": {
-    "test": "qunit"
+    "build": "tsc",
+    "test": "pnpm build && qunit"
   }
 }

package/src/date.js

@@ -1,5 +0,0 @@
-export function getTimestamp(dateObject=null) {
-  const ts = dateObject ? dateObject.getTime() : Date.now();
-
-  return Math.floor(ts / 1000);
-}

package/src/file.js

@@ -1,145 +0,0 @@
-import { getTimestamp } from '@stonyx/utils/date';
-import { kebabCaseToCamelCase } from '@stonyx/utils/string';
-import { objToJson } from '@stonyx/utils/object';
-import { promises as fsp } from 'fs';
-import path from 'path';
-
-export async function createFile(filePath, data, options={}) {
-  try {
-    filePath = path.resolve(filePath);
-
-    await createDirectory(path.dirname(filePath));
-    await fsp.writeFile(filePath, options.json ? objToJson(data) : data, 'utf8');
-  } catch (error) {
-    throw new Error(error);
-  }
-}
-
-export async function updateFile(filePath, data, options={}) {
-  try {
-    await fsp.access(filePath);
-
-    const swapFile = `${filePath}.temp-${getTimestamp()}`;
-    await fsp.writeFile(swapFile, options.json ? objToJson(data) : data);
-    await fsp.rename(swapFile, filePath);
-  } catch (error) {
-    
-    throw new Error(error);
-  }
-}
-
-export async function copyFile(sourcePath, targetPath, options={}) {
-  try {
-    sourcePath = path.resolve(sourcePath);
-    targetPath = path.resolve(targetPath);
-    await fsp.access(sourcePath);
-  } catch (error) {
-    throw new Error(error);
-  }
-
-  try {
-    await fsp.access(targetPath);
-    if (!options.overwrite) return false;
-  } catch {}
-
-  try {
-    await fsp.copyFile(sourcePath, targetPath);
-  } catch (error) {
-    throw new Error(error);
-  }
-
-  return true;
-}
-
-export async function readFile(filePath, options={}) {
-  try {
-    filePath = path.resolve(filePath);
-    
-    await fsp.access(filePath);
-    const fileData = await fsp.readFile(filePath, 'utf8');
-
-    return options.json ? JSON.parse(fileData) : fileData;
-  } catch (error) {
-    const { missingFileCallback } = options;
-
-    if (error.code === 'ENOENT' && missingFileCallback) {
-      return missingFileCallback(filePath);
-    }
-
-    throw new Error(error);
-  }
-}
-
-export async function deleteFile(filePath, options) {
-  try {
-    filePath = path.resolve(filePath);
-    
-    await fsp.access(filePath);
-  } catch (error) {
-    if (options?.ignoreAccessFailure) return;
-    throw error;
-  }
-
-  await fsp.unlink(filePath);
-}
-
-export async function deleteDirectory(dir) {
-  await fsp.rm(dir, { recursive: true, force: true });
-}
-
-export async function createDirectory(dir) {
-  await fsp.mkdir(dir, { recursive: true });
-}
-
-export async function forEachFileImport(dir, callback, options={}) {
-  if (typeof callback !== 'function') throw new Error('Callback must be valid function');
-
-  try {
-    await fsp.access(dir);
-  } catch (error) {
-    if (!options.ignoreAccessFailure) throw new Error(`Unable to access directory: ${dir}`);
-    return;
-  }
-
-  const files = await fsp.readdir(dir);
-
-  for (const file of files) {
-    const filePath = path.join(dir, file);
-    const stats = await fsp.stat(filePath);
-
-    if (options.recursive && stats.isDirectory()) {
-      const newOptions = { ...options };
-      
-      if (options.recursiveNaming) {
-        const pathPrefix = options.rawName ? file : `${kebabCaseToCamelCase(file)}`;
-        newOptions.namePrefix = options.namePrefix ? `${options.namePrefix}${pathPrefix}/` : `${pathPrefix}/`;
-      }
-
-      await forEachFileImport(filePath, callback, newOptions);
-      continue;
-    }
-
-    if (!stats.isFile() || !file.endsWith('.js')) continue;
-
-    const prefix = process.platform === 'win32' ? 'file://' : '';
-    const rawName = file.replace('.js', '');
-    let name = options.rawName ? rawName : kebabCaseToCamelCase(rawName);
-
-    if (options.namePrefix) name = `${options.namePrefix}${name}`;
-
-    const exported = await import(prefix + path.resolve(filePath));
-    const output = !options.fullExport ? exported.default : exported;
-
-    callback(output, { name, stats, path: filePath });
-  }
-}
-
-export async function fileExists(filePath) {
-  try {
-    filePath = path.resolve(filePath);
-    await fsp.access(filePath);
-    return true;
-  } catch (error) {
-    return false;
-  }
-}

package/src/object.js

@@ -1,61 +0,0 @@
-export function deepCopy(obj) {
-  return JSON.parse(JSON.stringify(obj));
-}
-
-export function objToJson(obj, format='\t') {
-  return JSON.stringify(obj, null, format);
-}
-
-export function makeArray(obj) {
-  return Array.isArray(obj) ? obj : [obj];
-}
-
-function cloneShallow(value) {
-  if (Array.isArray(value)) return value.slice();
-  if (value && typeof value === 'object') return { ...value };
-  return value;
-}
-
-export function mergeObject(obj1, obj2, options={}) {
-  if (Array.isArray(obj1) || Array.isArray(obj2)) throw new Error('Cannot merge arrays.');
-
-  if (obj1 === null || typeof obj1 !== 'object') return cloneShallow(obj2);
-  if (obj2 === null || typeof obj2 !== 'object') return cloneShallow(obj1);
-
-  const result = {};
-
-  for (const key of Object.keys(obj1))  result[key] = cloneShallow(obj1[key]);
-  for (const key of Object.keys(obj2)) {
-    if (options.ignoreNewKeys && !(key in obj1)) continue;
-
-    const val1 = obj1[key];
-    const val2 = obj2[key];
-    const shouldMerge = val1 && val2 && typeof val1 === 'object' && typeof val2 === 'object' && !Array.isArray(val1) && !Array.isArray(val2);
-    result[key] = shouldMerge ? mergeObject(val1, val2, options) : cloneShallow(val2);
-    
-  }
-
-  return result;
-}
-
-export function get(obj, path) {
-  if (arguments.length !== 2) return console.error('Get must be called with two arguments; an object and a property key.');
-  if (!obj) return console.error(`Cannot call get with '${path}' on an undefined object.`);
-  if (typeof path !== 'string') return console.error('The path provided to get must be a string.');
-
-  for (const key of path.split('.')) {
-    if (obj[key] === undefined) return;
-
-    obj = obj[key];
-  }
-
-  return obj;
-}
-
-export function getOrSet(map, key, defaultValue) {
-  if (!(map instanceof Map)) throw new Error('First argument to getOrSet must be a Map.');
-  
-  if (!map.has(key)) map.set(key, typeof defaultValue === "function" ? defaultValue() : defaultValue);
-
-  return map.get(key);
-}

package/src/plurarize.js

@@ -1,103 +0,0 @@
-// --- Irregular nouns ---
-const irregular = {
-  person: 'people',
-  man: 'men',
-  woman: 'women',
-  child: 'children',
-  tooth: 'teeth',
-  foot: 'feet',
-  mouse: 'mice',
-  goose: 'geese',
-  ox: 'oxen',
-  cactus: 'cacti',
-  nucleus: 'nuclei',
-  syllabus: 'syllabi',
-  focus: 'foci',
-  fungus: 'fungi',
-  appendix: 'appendices',
-  index: 'indices',
-  criterion: 'criteria',
-  phenomenon: 'phenomena',
-  die: 'dice',
-  thesis: 'theses',
-  analysis: 'analyses',
-  crisis: 'crises',
-  radius: 'radii',
-  corpus: 'corpora',
-};
-
-// --- Uncountables ---
-const uncountable = new Set([
-  'sheep', 'fish', 'deer', 'series', 'species', 'news', 'information',
-  'rice', 'moose', 'bison', 'salmon', 'aircraft', 'offspring'
-]);
-
-// --- Exceptions ---
-const fExceptions = new Set(['chief', 'roof', 'belief', 'chef', 'cliff', 'reef', 'proof', 'brief']);
-
-// Keep only true irregular -o exceptions (consonant + o but take just "s")
-const oExceptions = new Set(['piano', 'photo', 'halo', 'canto', 'solo']);
-
-// --- Utility to preserve casing ---
-function applyCasing(original, plural) {
-  if (original === original.toUpperCase()) return plural.toUpperCase();
-  if (original === original.toLowerCase()) return plural.toLowerCase();
-  if (original[0] === original[0].toUpperCase()) {
-    return plural.charAt(0).toUpperCase() + plural.slice(1);
-  }
-  return plural;
-}
-
-// --- Rule-based pluralization ---
-const rules = [
-  // quiz → quizzes, waltz → waltzes, topaz → topazes
-  [/z$/i, w => (/iz$/i.test(w) ? w + 'zes' : w + 'es')],
-
-  // bus → buses, box → boxes, church → churches, but stomach → stomachs (exclude -ach)
-  [/(s|x|ch|sh)$/i, w => (/ach$/i.test(w) ? w + 's' : w + 'es')],
-
-  // vowel + y → +s (key → keys)
-  [/[aeiou]y$/i, w => w + 's'],
-
-  // consonant + y → -ies (city → cities)
-  [/y$/i, w => w.slice(0, -1) + 'ies'],
-
-  // -fe → -ves (knife → knives), but not chief/roof/etc
-  [/fe$/i, w => (fExceptions.has(w) ? w + 's' : w.slice(0, -2) + 'ves')],
-
-  // -f → -ves (wolf → wolves), but not cliff/etc
-  [/f$/i, w => (fExceptions.has(w) ? w + 's' : w.slice(0, -1) + 'ves')],
-
-  // -sis → -ses (analysis → analyses, thesis → theses)
-  [/sis$/i, w => w.slice(0, -2) + 'ses'],
-
-  // vowel + o → +s (zoo → zoos, video → videos, patio → patios)
-  [/[aeiou]o$/i, w => w + 's'],
-
-  // consonant + o → usually +es, unless in oExceptions
-  [/o$/i, w => (oExceptions.has(w) ? w + 's' : w + 'es')],
-
-  // default: just +s
-  [/$/i, w => w + 's']
-];
-
-// --- Exported pluralizer ---
-export default function pluralize(word) {
-  if (typeof word !== 'string' || !/^[a-zA-Z]+$/.test(word)) return word;
-
-  const lower = word.toLowerCase();
-
-  if (uncountable.has(lower)) return word;
-
-  if (irregular[lower]) {
-    return applyCasing(word, irregular[lower]);
-  }
-
-  for (const [pattern, transform] of rules) {
-    if (pattern.test(lower)) {
-      return applyCasing(word, transform(lower));
-    }
-  }
-
-  return word; // fallback (shouldn't hit)
-}

package/src/promise.js

@@ -1,5 +0,0 @@
-export async function sleep(seconds) {
-  return new Promise(resolve => {
-    setTimeout(resolve, 1000 * seconds);
-  })
-}

package/src/prompt.js

@@ -1,29 +0,0 @@
-import { createInterface } from 'readline';
-
-export function confirm(question, { input, output } = {}) {
-  const rl = createInterface({
-    input: input ?? process.stdin,
-    output: output ?? process.stdout,
-  });
-
-  return new Promise(resolve => {
-    rl.question(`${question} (y/N) `, answer => {
-      rl.close();
-      resolve(answer.trim().toLowerCase() === 'y');
-    });
-  });
-}
-
-export function prompt(question, { input, output } = {}) {
-  const rl = createInterface({
-    input: input ?? process.stdin,
-    output: output ?? process.stdout,
-  });
-
-  return new Promise(resolve => {
-    rl.question(`${question} `, answer => {
-      rl.close();
-      resolve(answer.trim());
-    });
-  });
-}

package/src/string.js

@@ -1,35 +0,0 @@
-function kebabToCase(str, pascal=false) {
-  let out = '';
-  let upperNext = pascal; // PascalCase starts uppercase
-  for (let i = 0; i < str.length; i++) {
-    const ch = str.charAt(i);
-    if (ch === '-') {
-      upperNext = true;
-    } else if (upperNext) {
-      out += ch.toUpperCase();
-      upperNext = false;
-    } else {
-      out += ch;
-    }
-  }
-  return out;
-}
-
-export function kebabCaseToCamelCase(str) {
-  return kebabToCase(str, false);
-}
-
-export function kebabCaseToPascalCase(str) {
-  return kebabToCase(str, true);
-}
-
-export function camelCaseToKebabCase(str) {
-  return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
-}
-
-export function generateRandomString(length=8) {
-  const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-  return Array(length).fill('').map(() => characters.charAt(Math.floor(Math.random() * characters.length))).join('');
-}
-
-export { default as pluralize } from './plurarize.js';