@yahoo/uds-create-utils 1.1.1

package/dist/string-utils/cssVars.js

@@ -0,0 +1,108 @@
+import { cssVarDeclarations } from "./cssVar.js";
+//#region src/string-utils/cssVars.ts
+/**
+* Tagged template function for CSS variable generation.
+* Automatically converts objects to CSS variable declarations.
+*
+* Handles three types of inputs:
+* 1. Flat objects → CSS variables
+* 2. Nested objects → CSS blocks with selectors
+* 3. Arrays → joined with double newlines
+*
+* @example Flat object (CSS variables)
+* ```tsx
+* const vars = { color: 'red', fontSize: '16px' };
+*
+* const output = cssVars`
+*   :root {
+*     ${vars}
+*   }
+* `;
+*
+* // Output:
+* // :root {
+* //   --color: red;
+* //   --font-size: 16px;
+* // }
+* ```
+*
+* @example Nested object (CSS blocks)
+* ```tsx
+* const modeBlocks = {
+*   dark: { colorPrimary: '#000', colorSecondary: '#333' },
+*   light: { colorPrimary: '#fff', colorSecondary: '#eee' }
+* };
+*
+* const output = cssVars`${modeBlocks}`;
+*
+* // Output:
+* // .dark {
+* //   --color-primary: #000;
+* //   --color-secondary: #333;
+* // }
+* //
+* // .light {
+* //   --color-primary: #fff;
+* //   --color-secondary: #eee;
+* // }
+* ```
+*
+* @example Media queries (special @media handling)
+* ```tsx
+* const mediaQueries = {
+*   '@media (min-width: 768px)': { spacing: '2rem' },
+*   '@media (min-width: 1024px)': { spacing: '3rem' }
+* };
+*
+* const output = cssVars`${mediaQueries}`;
+*
+* // Output:
+* // @media (min-width: 768px) {
+* //   :root {
+* //     --spacing: 2rem;
+* //   }
+* // }
+* //
+* // @media (min-width: 1024px) {
+* //   :root {
+* //     --spacing: 3rem;
+* //   }
+* // }
+* ```
+*
+* @example Array (joined blocks)
+* ```tsx
+* const blocks = ['.dark { --color: black; }', '.light { --color: white; }'];
+* const output = cssVars`${blocks}`;
+* // Output: joined blocks with double newlines
+* ```
+*/
+function cssVars(strings, ...expr) {
+	const isNestedObject = (obj) => {
+		return Object.values(obj).some((val) => val && typeof val === "object" && !Array.isArray(val));
+	};
+	expr.forEach((item) => {
+		if (item && typeof item === "object" && !Array.isArray(item)) {
+			let stringResult;
+			const itemObj = item;
+			if (isNestedObject(itemObj)) stringResult = Object.entries(itemObj).map(([selector, vars]) => {
+				const varDeclarations = cssVarDeclarations(vars).replace(/\n/g, "\n    ");
+				if (selector.startsWith("@media ")) return `${selector} {\n  :root {\n    ${varDeclarations}\n  }\n}`;
+				return `.${selector} {\n  ${varDeclarations}\n}`;
+			}).join("\n\n");
+			else stringResult = cssVarDeclarations(itemObj);
+			Object.defineProperty(itemObj, "toString", { value() {
+				return stringResult;
+			} });
+		} else if (Array.isArray(item)) Object.defineProperty(item, "toString", { value() {
+			return item.filter(Boolean).join("\n\n");
+		} });
+	});
+	let str = "";
+	strings.forEach((string, i) => {
+		str += string + (expr[i] || "");
+	});
+	return str;
+}
+//#endregion
+export { cssVars };

package/dist/string-utils/dedent.d.ts

@@ -0,0 +1,47 @@
+//#region src/string-utils/dedent.d.ts
+/**
+ * Dedent tagged template literal function.
+ * Removes common leading indentation from all lines in a template literal,
+ * based on how the code appears in the source.
+ *
+ * Inspired by @qnighy/dedent
+ * @see https://github.com/qnighy/dedent-js
+ *
+ * @example
+ * ```typescript
+ * const text = dedent`
+ *   Hello World
+ *     This line is indented
+ *   Back to normal
+ * `;
+ * // Result:
+ * // "Hello World\n  This line is indented\nBack to normal\n"
+ * ```
+ *
+ * @example With leading backslash to avoid first line issues
+ * ```typescript
+ * const text = dedent`\
+ *   First line
+ *   Second line
+ * `;
+ * ```
+ */
+declare function dedent(strings: TemplateStringsArray, ...values: unknown[]): string;
+/**
+ * Dedent utility specifically for TypeScript declarations.
+ * Same as dedent but ensures a trailing newline for proper file formatting.
+ *
+ * @example
+ * ```typescript
+ * const types = dedentTS`\
+ *   declare module 'uds/types' {
+ *     export interface Foo {
+ *       bar: string;
+ *     }
+ *   }
+ * `;
+ * ```
+ */
+declare function dedentTS(strings: TemplateStringsArray, ...values: unknown[]): string;
+//#endregion
+export { dedent, dedentTS };

package/dist/string-utils/dedent.js

@@ -0,0 +1,68 @@
+//#region src/string-utils/dedent.ts
+/**
+* Dedent tagged template literal function.
+* Removes common leading indentation from all lines in a template literal,
+* based on how the code appears in the source.
+*
+* Inspired by @qnighy/dedent
+* @see https://github.com/qnighy/dedent-js
+*
+* @example
+* ```typescript
+* const text = dedent`
+*   Hello World
+*     This line is indented
+*   Back to normal
+* `;
+* // Result:
+* // "Hello World\n  This line is indented\nBack to normal\n"
+* ```
+*
+* @example With leading backslash to avoid first line issues
+* ```typescript
+* const text = dedent`\
+*   First line
+*   Second line
+* `;
+* ```
+*/
+function dedent(strings, ...values) {
+	let result = "";
+	for (let i = 0; i < strings.length; i++) {
+		result += strings[i];
+		if (i < values.length) result += String(values[i] ?? "");
+	}
+	const lines = result.split("\n");
+	let minIndent = Number.POSITIVE_INFINITY;
+	for (const line of lines) {
+		if (line.trim().length === 0) continue;
+		const match = line.match(/^[ \t]*/);
+		const indent = match ? match[0].length : 0;
+		minIndent = Math.min(minIndent, indent);
+	}
+	if (minIndent === Number.POSITIVE_INFINITY) minIndent = 0;
+	return lines.map((line) => {
+		if (line.trim().length === 0) return line.length >= minIndent ? line.slice(minIndent) : "";
+		return line.slice(minIndent);
+	}).join("\n");
+}
+/**
+* Dedent utility specifically for TypeScript declarations.
+* Same as dedent but ensures a trailing newline for proper file formatting.
+*
+* @example
+* ```typescript
+* const types = dedentTS`\
+*   declare module 'uds/types' {
+*     export interface Foo {
+*       bar: string;
+*     }
+*   }
+* `;
+* ```
+*/
+function dedentTS(strings, ...values) {
+	return `${dedent(strings, ...values).trimEnd()}\n`;
+}
+//#endregion
+export { dedent, dedentTS };

package/dist/string-utils/indent.d.ts

@@ -0,0 +1,4 @@
+//#region src/string-utils/indent.d.ts
+declare function indent(str: string, n: number): string;
+//#endregion
+export { indent };

package/dist/string-utils/indent.js

@@ -0,0 +1,6 @@
+//#region src/string-utils/indent.ts
+function indent(str, n) {
+	return str.split("\n").map((l) => " ".repeat(n) + l).join("\n");
+}
+//#endregion
+export { indent };

package/dist/string-utils/join.d.ts

@@ -0,0 +1,5 @@
+//#region src/string-utils/join.d.ts
+type Join<T extends readonly string[], D extends string> = T extends [] ? '' : T extends [infer F extends string] ? F : T extends [infer F extends string, ...infer R extends readonly string[]] ? `${F}${D}${Join<R, D>}` : string;
+declare function join<T extends readonly string[]>(...parts: T): <D extends string>(delimiter: D) => Join<T, D>;
+//#endregion
+export { join };

package/dist/string-utils/join.js

@@ -0,0 +1,6 @@
+//#region src/string-utils/join.ts
+function join(...parts) {
+	return (delimiter) => parts.join(delimiter);
+}
+//#endregion
+export { join };

package/dist/string-utils/kebabCase.d.ts

@@ -0,0 +1,13 @@
+//#region src/string-utils/kebabCase.d.ts
+type KebabCase<S extends string> = S extends `${infer First}${infer Rest}` ? First extends Uppercase<First> ? Rest extends `${infer RestFirst}${infer _RestRest}` ? RestFirst extends Uppercase<RestFirst> ? `${Lowercase<First>}${KebabCase<Rest>}` : `-${Lowercase<First>}${KebabCase<Rest>}` : `-${Lowercase<First>}${KebabCase<Rest>}` : `${First}${KebabCase<Rest>}` : Lowercase<S>;
+/**
+ * Convert a string to kebab-case.
+ *
+ * - camelCase & PascalCase → hyphens
+ * - letter→digit boundaries → hyphens
+ * - collapses non-alphanumerics into single hyphens
+ * - trims edge hyphens, lowercases
+ */
+declare function kebabCase<Input extends string>(input: Input): KebabCase<Input>;
+//#endregion
+export { KebabCase, kebabCase };

package/dist/string-utils/kebabCase.js

@@ -0,0 +1,14 @@
+//#region src/string-utils/kebabCase.ts
+/**
+* Convert a string to kebab-case.
+*
+* - camelCase & PascalCase → hyphens
+* - letter→digit boundaries → hyphens
+* - collapses non-alphanumerics into single hyphens
+* - trims edge hyphens, lowercases
+*/
+function kebabCase(input) {
+	return input.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([a-z])([0-9]+)/gi, "$1-$2").replace(/[^A-Za-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").toLowerCase();
+}
+//#endregion
+export { kebabCase };

package/dist/string-utils/objectToInterface.d.ts

@@ -0,0 +1 @@
+export declare function objectToInterface<T extends Record<string, string>>(object: T): `${Extract<keyof T, string>}: ${T[Extract<keyof T, string>]};`;

package/dist/string-utils/objectToInterface.js

@@ -0,0 +1,6 @@
+//#region src/string-utils/objectToInterface.ts
+function objectToInterface(object) {
+	return Object.entries(object).map(([key, value]) => `${key}: ${value};`).join(" ");
+}
+//#endregion
+export { objectToInterface };

package/dist/string-utils/split.d.ts

@@ -0,0 +1,10 @@
+//#region src/string-utils/split.d.ts
+type Split<S extends string, D extends string> = string extends S ? string[] : S extends '' ? [] : S extends `${infer T}${D}${infer U}` ? [T, ...Split<U, D>] : [S];
+type BuildArray<L extends number, A extends unknown[] = []> = A['length'] extends L ? A : BuildArray<L, [...A, unknown]>;
+type Decrement<N extends number> = BuildArray<N> extends [unknown, ...infer Rest] ? Rest['length'] : never;
+type SplitDepth<S extends string, D extends string, N extends number> = N extends 0 ? [S] : S extends `${infer Head}${D}${infer Tail}` ? N extends 1 ? [Head, Tail] : [Head, ...SplitDepth<Tail, D, Decrement<N>>] : [S];
+declare function split<T extends string, Delimiter extends string, Depth extends number = number>(str: T, delimiter: Delimiter, options?: {
+  depth?: Depth;
+}): Split<T, Delimiter> | SplitDepth<T, Delimiter, Depth>;
+//#endregion
+export { split };

package/dist/string-utils/split.js

@@ -0,0 +1,12 @@
+//#region src/string-utils/split.ts
+function split(str, delimiter, options) {
+	if (!options || options.depth == null || options.depth <= 0) return str.split(delimiter);
+	const { depth } = options;
+	const parts = str.split(delimiter);
+	if (parts.length <= depth) return parts;
+	const head = parts.slice(0, depth);
+	const tail = parts.slice(depth).join(delimiter);
+	return [...head, tail];
+}
+//#endregion
+export { split };

package/dist/string-utils/tsProperties.d.ts

@@ -0,0 +1,29 @@
+//#region src/string-utils/tsProperties.d.ts
+/**
+ * Template literal utility for formatting TypeScript interface properties
+ *
+ * @example
+ * ```ts
+ * const props = tsProperties`${{
+ *   brand: void,
+ *   primary: void
+ * }}`;
+ * // Returns: "  'brand': void;\n  'primary': void;"
+ * ```
+ */
+declare function tsProperties<T extends Record<string, unknown>>(strings: TemplateStringsArray, ...expr: [T]): string;
+/**
+ * Template literal utility for formatting TypeScript namespace type exports
+ *
+ * @example
+ * ```ts
+ * const types = tsTypes`${{
+ *   ColorMode: "'light' | 'dark'",
+ *   Responsive: "'sm' | 'md'"
+ * }}`;
+ * // Returns: "  export type ColorMode = 'light' | 'dark';\n  export type Responsive = 'sm' | 'md';"
+ * ```
+ */
+declare function tsTypes<T extends Record<string, string>>(strings: TemplateStringsArray, ...expr: [T]): string;
+//#endregion
+export { tsProperties, tsTypes };

package/dist/string-utils/tsProperties.js

@@ -0,0 +1,60 @@
+import { entries } from "../object-utils/entries.js";
+//#region src/string-utils/tsProperties.ts
+/**
+* Template literal utility for formatting TypeScript interface properties
+*
+* @example
+* ```ts
+* const props = tsProperties`${{
+*   brand: void,
+*   primary: void
+* }}`;
+* // Returns: "  'brand': void;\n  'primary': void;"
+* ```
+*/
+function tsProperties(strings, ...expr) {
+	let result = "";
+	expr.forEach((item) => {
+		if (item && typeof item === "object") {
+			const propertyLines = entries(item).map(([key, value]) => {
+				return `  '${key}': ${value === void 0 || value === null ? "void" : JSON.stringify(value)};`;
+			}).join("\n");
+			Object.defineProperty(item, "toString", { value() {
+				return propertyLines;
+			} });
+		}
+	});
+	strings.forEach((string, i) => {
+		result += string + (expr[i] || "");
+	});
+	return result;
+}
+/**
+* Template literal utility for formatting TypeScript namespace type exports
+*
+* @example
+* ```ts
+* const types = tsTypes`${{
+*   ColorMode: "'light' | 'dark'",
+*   Responsive: "'sm' | 'md'"
+* }}`;
+* // Returns: "  export type ColorMode = 'light' | 'dark';\n  export type Responsive = 'sm' | 'md';"
+* ```
+*/
+function tsTypes(strings, ...expr) {
+	let result = "";
+	expr.forEach((item) => {
+		if (item && typeof item === "object") {
+			const typeLines = entries(item).map(([typeName, typeValue]) => `  export type ${typeName} = ${typeValue};`).join("\n");
+			Object.defineProperty(item, "toString", { value() {
+				return typeLines;
+			} });
+		}
+	});
+	strings.forEach((string, i) => {
+		result += string + (expr[i] || "");
+	});
+	return result;
+}
+//#endregion
+export { tsProperties, tsTypes };