Small, typed TS utilities you can copy w/o adding a JS dep.
[in progress] Common Utilities uses an MCP-first, copy/paste workflow inspired by shadcn/ui.
- ask for what you need
- review the result
- you own the source
- Fewer security concerns: the copied utility requires no pkg install or dep tree.
- Fewer tokens: the MCP returns the focused utility, documentation, tests, diff, and provenance you need. You can just use the api as well. The MCP is lang translation only.
- Fast development: reuse small, tested building blocks instead of reinventing them.
Ask your MCP client for a TypeScript utility. The response includes:
- ready-to-copy source
- a Markdown explanation and usage example
- a reviewable diff
- tests and provenance
Review the diff, then copy the files into your project. Your codebase owns the result and future changes are explicit.
String conversion, encoding, interpolation, and whitespace helpers.
kebabToCamelString(value: string): string; kebabToCamelStringsInObject( value: ObjectOfStrings, ): ObjectOfStrings;
Converts kebab-case text to camelCase. The object helper converts keys and preserves string values.
kebabToCamelString("test-thing"); // "testThing" kebabToCamelStringsInObject({ "test-thing": "foo" }); // { testThing: "foo" }
# Copy src/index.ts into your project. # Dependencies: none.
rot13: (value: string) => string
Applies the ROT13 substitution to ASCII letters and leaves other characters unchanged.
rot13("Hello Rot13 is awesome!"); // "Uryyb Ebg13 vf njrfbzr!"
# Copy src/index.ts into your project. # Dependencies: none.
snake-to-camel-case: (value: string) => string
Converts a snake_case string to camelCase.
snakeToCamelCase("camel_case_string"); // "camelCaseString"
# Copy src/index.ts into your project. # Dependencies: none.
stringInterpolation( value: string, replacements: KeyValueStringsObject[], ): string;
Replaces #{key} placeholders with values from a list of string records.
stringInterpolation("This string has #{dynamicData}", [ { dynamicData: "a knot in it" }, ]); // "This string has a knot in it"
# Copy src/index.ts into your project. # Dependencies: none.
trim-whitespace: (value: string) => string
Trims outer whitespace and collapses repeated spaces into single spaces.
removeWhitespaceFromString(" This has whitespace. "); // "This has whitespace."
# Copy src/index.ts into your project. # Dependencies: none.
Small array selection and deduplication helpers.
filter-array: (value: unknown[]) => unknown[]
Removes duplicate array items using strict equality. Object values are not deeply compared.
filterArray(["test", "test", "foo"]); // ["test", "foo"]
# Copy src/index.ts into your project. # Dependencies: none.
head: (value: unknown[]) => unknown
Returns the first item in an array, or undefined for an empty array.
head(["first", "second"]); // "first"
# Copy src/index.ts into your project. # Dependencies: none.
Object checks and recursive merge helpers.
isArray(value: unknown): boolean; isOfObjectType(value: unknown): boolean; isObject(value: unknown): boolean;
Checks whether a value is an array, any non-null object-like value, or a non-array object.
isArray(["value"]); // true isOfObjectType({ value: true }); // true isObject(["value"]); // false isObject({ value: true }); // true
# Copy src/index.ts into your project. # Dependencies: none.
merge-objects: (left: unknown, right: unknown) => unknown
Recursively merges objects and combines arrays while removing duplicate primitive values. Prototype-pollution keys are ignored during nested merges.
mergeObjects( { settings: { darkMode: false } }, { settings: { compact: true } }, ); // { settings: { darkMode: false, compact: true } }
# Copy src/index.ts into your project. # Dependencies: none.
Small composable function helpers.
compose: <T>(...fns: ((value: T) => T)[]) => (value: T) => T
Composes functions from right to left.
const add = (value: number) => value + 1; const multiply = (value: number) => value * 2; compose(add, multiply)(2); // 5
# Copy src/index.ts into your project. # Dependencies: none.
curry(fn: F.Function): (this: unknown, ...args: Parameters<typeof fn>) => any;
Returns a function that can receive a function's arguments over multiple calls.
const add = (a: number, b: number, c: number) => a + b + c; curry(add)(1, 2)(3); // 6
# Copy src/index.ts into your project. # Type dependency: ts-toolbelt. # Keep ts-toolbelt for the current F.Function type import.
pipe: <T>(...fns: ((value: T) => T)[]) => (value: T) => T
Composes functions from left to right.
const multiply = (value: number) => value * 2; const add = (value: number) => value + 1; pipe(multiply, add)(2); // 5
# Copy src/index.ts into your project. # Dependencies: none.
repeat: (iterations: number) => <T>(fn: (value: T) => T) => (value: T) => T
Runs a callback a fixed number of times and returns the final value.
repeat(3)((value: number) => value + 1)(0); // 3
# Copy src/index.ts into your project. # Dependencies: none.
Timing and readiness helpers. wait-until-defined is deprecated for new code.
debounce: <T>(fn: (value?: T) => void, delay: number) => (value?: T) => void
Delays a callback until calls stop arriving during the delay window.
const save = debounce((value?: string) => { console.log(value); }, 300); save("latest value");
# Copy src/index.ts into your project. # Dependencies: none.
throttle: <T>(fn: (value?: T) => void, delay: number) => (value?: T) => null | number
Schedules the first callback in a delay window and ignores later calls while that timeout is active.
const report = throttle((value?: number) => { console.log(value); }, 300); report(1); report(2);
# Copy src/index.ts into your project. # Dependencies: none.
wait(timeout: number): Promise<true>; isDefined(check: () => boolean): Promise<boolean>; checkDefinition( check: () => boolean, interval: number, attempts: number, ): Promise<boolean>; waitUntilDefined( check: () => boolean, interval?: number, timeout?: number, ): Promise<boolean>;
Polls a callback until it returns true or the timeout expires. Deprecated: prefer the event or readiness signal that makes the value available.
await waitUntilDefined(() => ready, 100, 5000);
# Deprecated: do not add this to new code. # Dependencies: none.
Small helpers for observing values without changing the value flow.
trace: (label: string) => (value: unknown) => unknown
Logs a label and value, then returns the original value for use in a pipeline.
const result = trace("number")(2); // logs: number: 2 // result: 2
# Copy src/index.ts into your project. # Dependencies: none.
Helpers for turning package metadata into Markdown.
logger(options: LoggerOptions): { debug(message: string, ...args: unknown[]): void; error(message: string, ...args: unknown[]): void; }; processPackages( packagesDirectory: string, markdownFile: string, jsonFile: string, isLogging?: boolean, ): void; getJsonData( packagePath: string, jsonFile: string, log: ReturnType<typeof logger>, ): string; updateText( markdownFile: string, jsonFile: string, log: ReturnType<typeof logger>, packagesDirectory: string, packageName: string, ): void; updateMd( markdownText: string, markdownFile: string, log: ReturnType<typeof logger>, ): void;
Reads package metadata and appends formatted package headings and descriptions to a Markdown file.
const log = logger({ file: "README.md" }); const description = getJsonData("./packages/example", "package.json", log); updateMd(description, "./README.md", log);
# Copy src/index.ts into your project. # Uses Node.js built-ins only.
Browse the full documentation for more examples.