@zuwy/frontend-engineering-system-utils 0.1.0 → 0.2.0

package/README.md

@@ -1,17 +1,17 @@
-# @zuwy/frontend-engineering-system-utils
-
-Shared utility functions for frontend-engineering-system.
-
-## Installation
-
-```bash
-pnpm add @zuwy/frontend-engineering-system-utils
-```
-
-## Usage
-
-```ts
-import { readBoolean } from "@zuwy/frontend-engineering-system-utils"
-
-readBoolean("true")
-```
+# @zuwy/frontend-engineering-system-utils
+
+Shared utility functions for frontend-engineering-system.
+
+## Installation
+
+```bash
+pnpm add @zuwy/frontend-engineering-system-utils
+```
+
+## Usage
+
+```ts
+import { readBoolean } from "@zuwy/frontend-engineering-system-utils"
+
+readBoolean("true")
+```

package/dist/array.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Removes duplicate values, keeping the first occurrence.
+ *
+ * @param array - The source array.
+ * @returns A new array without duplicates.
+ *
+ * @example
+ * ```ts
+ * unique([1, 2, 2, 3, 3, 3]) // [1, 2, 3]
+ * unique(["a", "a", "b"]) // ["a", "b"]
+ * ```
+ */
+export declare function unique<T>(array: readonly T[]): T[];
+/**
+ * Removes duplicates based on a derived key, keeping the first occurrence.
+ *
+ * @param array - The source array.
+ * @param keySelector - Returns the key used to detect duplicates.
+ * @returns A new array without duplicates.
+ *
+ * @example
+ * ```ts
+ * const users = [
+ *   { id: 1, name: "Alice" },
+ *   { id: 1, name: "Alice (dup)" },
+ *   { id: 2, name: "Bob" },
+ * ]
+ * uniqueBy(users, (user) => user.id)
+ * // [{ id: 1, name: "Alice" }, { id: 2, name: "Bob" }]
+ * ```
+ */
+export declare function uniqueBy<T, K>(array: readonly T[], keySelector: (item: T) => K): T[];
+/**
+ * Splits an array into groups of the given size. The last group may be shorter.
+ *
+ * @param array - The source array.
+ * @param size - The length of each group. Must be a positive integer.
+ * @returns A new array of chunked arrays.
+ * @throws {RangeError} When `size` is not a positive integer.
+ *
+ * @example
+ * ```ts
+ * chunk([1, 2, 3, 4, 5], 2) // [[1, 2], [3, 4], [5]]
+ * ```
+ */
+export declare function chunk<T>(array: readonly T[], size: number): T[][];
+/**
+ * Groups the items of an array by a derived key.
+ *
+ * @param array - The source array.
+ * @param keySelector - Returns the group key for each item.
+ * @returns An object mapping each key to the list of matching items.
+ *
+ * @example
+ * ```ts
+ * groupBy([1, 2, 3, 4], (n) => (n % 2 === 0 ? "even" : "odd"))
+ * // { odd: [1, 3], even: [2, 4] }
+ * ```
+ */
+export declare function groupBy<T, K extends PropertyKey>(array: readonly T[], keySelector: (item: T) => K): Record<K, T[]>;

package/dist/array.js

@@ -0,0 +1,95 @@
+/**
+ * Removes duplicate values, keeping the first occurrence.
+ *
+ * @param array - The source array.
+ * @returns A new array without duplicates.
+ *
+ * @example
+ * ```ts
+ * unique([1, 2, 2, 3, 3, 3]) // [1, 2, 3]
+ * unique(["a", "a", "b"]) // ["a", "b"]
+ * ```
+ */
+export function unique(array) {
+    return Array.from(new Set(array));
+}
+/**
+ * Removes duplicates based on a derived key, keeping the first occurrence.
+ *
+ * @param array - The source array.
+ * @param keySelector - Returns the key used to detect duplicates.
+ * @returns A new array without duplicates.
+ *
+ * @example
+ * ```ts
+ * const users = [
+ *   { id: 1, name: "Alice" },
+ *   { id: 1, name: "Alice (dup)" },
+ *   { id: 2, name: "Bob" },
+ * ]
+ * uniqueBy(users, (user) => user.id)
+ * // [{ id: 1, name: "Alice" }, { id: 2, name: "Bob" }]
+ * ```
+ */
+export function uniqueBy(array, keySelector) {
+    const seen = new Set();
+    const result = [];
+    for (const item of array) {
+        const key = keySelector(item);
+        if (!seen.has(key)) {
+            seen.add(key);
+            result.push(item);
+        }
+    }
+    return result;
+}
+/**
+ * Splits an array into groups of the given size. The last group may be shorter.
+ *
+ * @param array - The source array.
+ * @param size - The length of each group. Must be a positive integer.
+ * @returns A new array of chunked arrays.
+ * @throws {RangeError} When `size` is not a positive integer.
+ *
+ * @example
+ * ```ts
+ * chunk([1, 2, 3, 4, 5], 2) // [[1, 2], [3, 4], [5]]
+ * ```
+ */
+export function chunk(array, size) {
+    if (!Number.isInteger(size) || size <= 0) {
+        throw new RangeError("chunk size must be a positive integer");
+    }
+    const result = [];
+    for (let index = 0; index < array.length; index += size) {
+        result.push(array.slice(index, index + size));
+    }
+    return result;
+}
+/**
+ * Groups the items of an array by a derived key.
+ *
+ * @param array - The source array.
+ * @param keySelector - Returns the group key for each item.
+ * @returns An object mapping each key to the list of matching items.
+ *
+ * @example
+ * ```ts
+ * groupBy([1, 2, 3, 4], (n) => (n % 2 === 0 ? "even" : "odd"))
+ * // { odd: [1, 3], even: [2, 4] }
+ * ```
+ */
+export function groupBy(array, keySelector) {
+    const result = {};
+    for (const item of array) {
+        const key = keySelector(item);
+        const group = result[key];
+        if (group) {
+            group.push(item);
+        }
+        else {
+            result[key] = [item];
+        }
+    }
+    return result;
+}

package/dist/async.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Pauses execution for the given duration.
+ *
+ * @param duration - Milliseconds to wait.
+ * @returns A promise that resolves after the duration.
+ *
+ * @example
+ * ```ts
+ * console.log("start")
+ * await sleep(1000)
+ * console.log("one second later")
+ * ```
+ */
+export declare function sleep(duration: number): Promise<void>;
+/**
+ * Options for {@link retry}.
+ */
+export interface RetryOptions {
+    /** Maximum number of retries, excluding the first attempt. Defaults to 3. */
+    retries?: number;
+    /** Milliseconds to wait before each retry. Defaults to 0. */
+    delay?: number;
+}
+/**
+ * Runs a function and retries it until it succeeds or the retry limit is reached.
+ *
+ * @param fn - The function to execute. It may return a value or a promise.
+ * @param options - Retry options.
+ * @returns The resolved value of `fn`.
+ * @throws The last error thrown by `fn` when all attempts fail.
+ *
+ * @example
+ * ```ts
+ * const data = await retry(() => fetch("/api/data").then((res) => res.json()), {
+ *   retries: 3,
+ *   delay: 500,
+ * })
+ * ```
+ */
+export declare function retry<T>(fn: () => Promise<T> | T, options?: RetryOptions): Promise<T>;

package/dist/async.js

@@ -0,0 +1,50 @@
+/**
+ * Pauses execution for the given duration.
+ *
+ * @param duration - Milliseconds to wait.
+ * @returns A promise that resolves after the duration.
+ *
+ * @example
+ * ```ts
+ * console.log("start")
+ * await sleep(1000)
+ * console.log("one second later")
+ * ```
+ */
+export function sleep(duration) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, duration);
+    });
+}
+/**
+ * Runs a function and retries it until it succeeds or the retry limit is reached.
+ *
+ * @param fn - The function to execute. It may return a value or a promise.
+ * @param options - Retry options.
+ * @returns The resolved value of `fn`.
+ * @throws The last error thrown by `fn` when all attempts fail.
+ *
+ * @example
+ * ```ts
+ * const data = await retry(() => fetch("/api/data").then((res) => res.json()), {
+ *   retries: 3,
+ *   delay: 500,
+ * })
+ * ```
+ */
+export async function retry(fn, options = {}) {
+    const { retries = 3, delay = 0 } = options;
+    let lastError;
+    for (let attempt = 0; attempt <= retries; attempt += 1) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt < retries && delay > 0) {
+                await sleep(delay);
+            }
+        }
+    }
+    throw lastError;
+}

package/dist/function.d.ts

@@ -0,0 +1,76 @@
+/**
+ * A debounced function returned by {@link debounce}.
+ */
+export interface DebouncedFunction<Args extends unknown[]> {
+    (...args: Args): void;
+    /** Cancels the pending invocation, if any. */
+    cancel: () => void;
+}
+/**
+ * Creates a debounced function that delays invoking `fn` until `wait`
+ * milliseconds have elapsed since the last call.
+ *
+ * @param fn - The function to debounce.
+ * @param wait - Delay in milliseconds. Defaults to 300.
+ * @returns A debounced function with a `cancel` method.
+ *
+ * @example
+ * ```ts
+ * const search = debounce((keyword: string) => {
+ *   console.log("searching:", keyword)
+ * }, 300)
+ *
+ * search("a")
+ * search("ab") // only "ab" is logged, 300ms after the last call
+ * search.cancel() // cancels the pending invocation
+ * ```
+ */
+export declare function debounce<Args extends unknown[]>(fn: (...args: Args) => void, wait?: number): DebouncedFunction<Args>;
+/**
+ * A throttled function returned by {@link throttle}.
+ */
+export interface ThrottledFunction<Args extends unknown[]> {
+    (...args: Args): void;
+    /** Cancels the trailing invocation, if any. */
+    cancel: () => void;
+}
+/**
+ * Creates a throttled function that invokes `fn` at most once per `wait`
+ * milliseconds. Calls made during the window are invoked at the end of it.
+ *
+ * @param fn - The function to throttle.
+ * @param wait - Minimum interval between invocations in milliseconds. Defaults to 300.
+ * @returns A throttled function with a `cancel` method.
+ *
+ * @example
+ * ```ts
+ * const onScroll = throttle(() => {
+ *   console.log(window.scrollY)
+ * }, 200)
+ *
+ * window.addEventListener("scroll", onScroll)
+ * // ...later
+ * window.removeEventListener("scroll", onScroll)
+ * onScroll.cancel()
+ * ```
+ */
+export declare function throttle<Args extends unknown[]>(fn: (...args: Args) => void, wait?: number): ThrottledFunction<Args>;
+/**
+ * Wraps a function so it is executed only once. Subsequent calls return the
+ * result of the first invocation.
+ *
+ * @param fn - The function to wrap.
+ * @returns A function that runs `fn` at most once.
+ *
+ * @example
+ * ```ts
+ * const init = once(() => {
+ *   console.log("initialized")
+ *   return 42
+ * })
+ *
+ * init() // logs "initialized", returns 42
+ * init() // returns 42 without logging again
+ * ```
+ */
+export declare function once<Args extends unknown[], R>(fn: (...args: Args) => R): (...args: Args) => R;

package/dist/function.js

@@ -0,0 +1,122 @@
+/**
+ * Creates a debounced function that delays invoking `fn` until `wait`
+ * milliseconds have elapsed since the last call.
+ *
+ * @param fn - The function to debounce.
+ * @param wait - Delay in milliseconds. Defaults to 300.
+ * @returns A debounced function with a `cancel` method.
+ *
+ * @example
+ * ```ts
+ * const search = debounce((keyword: string) => {
+ *   console.log("searching:", keyword)
+ * }, 300)
+ *
+ * search("a")
+ * search("ab") // only "ab" is logged, 300ms after the last call
+ * search.cancel() // cancels the pending invocation
+ * ```
+ */
+export function debounce(fn, wait = 300) {
+    let timer;
+    const cancel = () => {
+        if (timer !== undefined) {
+            clearTimeout(timer);
+            timer = undefined;
+        }
+    };
+    const debounced = (...args) => {
+        cancel();
+        timer = setTimeout(() => {
+            timer = undefined;
+            fn(...args);
+        }, wait);
+    };
+    return Object.assign(debounced, { cancel });
+}
+/**
+ * Creates a throttled function that invokes `fn` at most once per `wait`
+ * milliseconds. Calls made during the window are invoked at the end of it.
+ *
+ * @param fn - The function to throttle.
+ * @param wait - Minimum interval between invocations in milliseconds. Defaults to 300.
+ * @returns A throttled function with a `cancel` method.
+ *
+ * @example
+ * ```ts
+ * const onScroll = throttle(() => {
+ *   console.log(window.scrollY)
+ * }, 200)
+ *
+ * window.addEventListener("scroll", onScroll)
+ * // ...later
+ * window.removeEventListener("scroll", onScroll)
+ * onScroll.cancel()
+ * ```
+ */
+export function throttle(fn, wait = 300) {
+    let lastCall = 0;
+    let timer;
+    let lastArgs;
+    const invoke = () => {
+        lastCall = Date.now();
+        timer = undefined;
+        if (lastArgs !== undefined) {
+            fn(...lastArgs);
+            lastArgs = undefined;
+        }
+    };
+    const cancel = () => {
+        if (timer !== undefined) {
+            clearTimeout(timer);
+            timer = undefined;
+        }
+        lastArgs = undefined;
+        lastCall = 0;
+    };
+    const throttled = (...args) => {
+        lastArgs = args;
+        const remaining = wait - (Date.now() - lastCall);
+        if (remaining <= 0) {
+            if (timer !== undefined) {
+                clearTimeout(timer);
+                timer = undefined;
+            }
+            invoke();
+            return;
+        }
+        if (timer === undefined) {
+            timer = setTimeout(invoke, remaining);
+        }
+    };
+    return Object.assign(throttled, { cancel });
+}
+/**
+ * Wraps a function so it is executed only once. Subsequent calls return the
+ * result of the first invocation.
+ *
+ * @param fn - The function to wrap.
+ * @returns A function that runs `fn` at most once.
+ *
+ * @example
+ * ```ts
+ * const init = once(() => {
+ *   console.log("initialized")
+ *   return 42
+ * })
+ *
+ * init() // logs "initialized", returns 42
+ * init() // returns 42 without logging again
+ * ```
+ */
+export function once(fn) {
+    let called = false;
+    let result;
+    return (...args) => {
+        if (!called) {
+            called = true;
+            result = fn(...args);
+        }
+        return result;
+    };
+}

package/dist/index.d.ts

@@ -1 +1,10 @@
 export { readBoolean } from "./boolean.js";
+export { isNil, isDefined, isPlainObject, isEmpty } from "./type.js";
+export { unique, uniqueBy, chunk, groupBy } from "./array.js";
+export { pick, omit, deepClone } from "./object.js";
+export { capitalize, truncate, camelCase, kebabCase } from "./string.js";
+export { clamp, randomInt } from "./number.js";
+export { debounce, throttle, once } from "./function.js";
+export type { DebouncedFunction, ThrottledFunction } from "./function.js";
+export { sleep, retry } from "./async.js";
+export type { RetryOptions } from "./async.js";

package/dist/index.js

@@ -1 +1,8 @@
 export { readBoolean } from "./boolean.js";
+export { isNil, isDefined, isPlainObject, isEmpty } from "./type.js";
+export { unique, uniqueBy, chunk, groupBy } from "./array.js";
+export { pick, omit, deepClone } from "./object.js";
+export { capitalize, truncate, camelCase, kebabCase } from "./string.js";
+export { clamp, randomInt } from "./number.js";
+export { debounce, throttle, once } from "./function.js";
+export { sleep, retry } from "./async.js";

package/dist/number.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Clamps a number within the inclusive `min` and `max` bounds.
+ *
+ * @param value - The number to clamp.
+ * @param min - The lower bound.
+ * @param max - The upper bound.
+ * @returns The clamped number.
+ *
+ * @example
+ * ```ts
+ * clamp(5, 0, 10) // 5
+ * clamp(-1, 0, 10) // 0
+ * clamp(99, 0, 10) // 10
+ * ```
+ */
+export declare function clamp(value: number, min: number, max: number): number;
+/**
+ * Returns a random integer between `min` and `max`, both inclusive.
+ *
+ * @param min - The lower bound.
+ * @param max - The upper bound.
+ * @returns A random integer within `[min, max]`.
+ *
+ * @example
+ * ```ts
+ * randomInt(1, 6) // e.g. 4
+ * ```
+ */
+export declare function randomInt(min: number, max: number): number;

package/dist/number.js

@@ -0,0 +1,35 @@
+/**
+ * Clamps a number within the inclusive `min` and `max` bounds.
+ *
+ * @param value - The number to clamp.
+ * @param min - The lower bound.
+ * @param max - The upper bound.
+ * @returns The clamped number.
+ *
+ * @example
+ * ```ts
+ * clamp(5, 0, 10) // 5
+ * clamp(-1, 0, 10) // 0
+ * clamp(99, 0, 10) // 10
+ * ```
+ */
+export function clamp(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+}
+/**
+ * Returns a random integer between `min` and `max`, both inclusive.
+ *
+ * @param min - The lower bound.
+ * @param max - The upper bound.
+ * @returns A random integer within `[min, max]`.
+ *
+ * @example
+ * ```ts
+ * randomInt(1, 6) // e.g. 4
+ * ```
+ */
+export function randomInt(min, max) {
+    const lower = Math.ceil(min);
+    const upper = Math.floor(max);
+    return Math.floor(Math.random() * (upper - lower + 1)) + lower;
+}

package/dist/object.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Creates a new object containing only the picked properties.
+ *
+ * @param object - The source object.
+ * @param keys - The property keys to pick.
+ * @returns A new object with only the picked properties.
+ *
+ * @example
+ * ```ts
+ * pick({ id: 1, name: "Alice", age: 30 }, ["id", "name"])
+ * // { id: 1, name: "Alice" }
+ * ```
+ */
+export declare function pick<T extends object, K extends keyof T>(object: T, keys: readonly K[]): Pick<T, K>;
+/**
+ * Creates a shallow copy of an object without the omitted properties.
+ *
+ * @param object - The source object.
+ * @param keys - The property keys to omit.
+ * @returns A shallow copy without the omitted properties.
+ *
+ * @example
+ * ```ts
+ * omit({ id: 1, name: "Alice", age: 30 }, ["age"])
+ * // { id: 1, name: "Alice" }
+ * ```
+ */
+export declare function omit<T extends object, K extends keyof T>(object: T, keys: readonly K[]): Omit<T, K>;
+/**
+ * Creates a deep clone of the given value. Plain objects, arrays and `Date`
+ * instances are cloned recursively, while other values are returned as-is.
+ *
+ * @param value - The value to clone.
+ * @returns A deep clone of the value.
+ *
+ * @example
+ * ```ts
+ * const source = { user: { name: "Alice" }, tags: ["a"] }
+ * const copy = deepClone(source)
+ * copy.user.name = "Bob"
+ * source.user.name // "Alice" (the original is untouched)
+ * ```
+ */
+export declare function deepClone<T>(value: T): T;

package/dist/object.js

@@ -0,0 +1,77 @@
+import { isPlainObject } from "./type.js";
+/**
+ * Creates a new object containing only the picked properties.
+ *
+ * @param object - The source object.
+ * @param keys - The property keys to pick.
+ * @returns A new object with only the picked properties.
+ *
+ * @example
+ * ```ts
+ * pick({ id: 1, name: "Alice", age: 30 }, ["id", "name"])
+ * // { id: 1, name: "Alice" }
+ * ```
+ */
+export function pick(object, keys) {
+    const result = {};
+    for (const key of keys) {
+        if (key in object) {
+            result[key] = object[key];
+        }
+    }
+    return result;
+}
+/**
+ * Creates a shallow copy of an object without the omitted properties.
+ *
+ * @param object - The source object.
+ * @param keys - The property keys to omit.
+ * @returns A shallow copy without the omitted properties.
+ *
+ * @example
+ * ```ts
+ * omit({ id: 1, name: "Alice", age: 30 }, ["age"])
+ * // { id: 1, name: "Alice" }
+ * ```
+ */
+export function omit(object, keys) {
+    const result = { ...object };
+    for (const key of keys) {
+        delete result[key];
+    }
+    return result;
+}
+function clone(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => clone(item));
+    }
+    if (value instanceof Date) {
+        return new Date(value.getTime());
+    }
+    if (isPlainObject(value)) {
+        const result = {};
+        for (const [key, item] of Object.entries(value)) {
+            result[key] = clone(item);
+        }
+        return result;
+    }
+    return value;
+}
+/**
+ * Creates a deep clone of the given value. Plain objects, arrays and `Date`
+ * instances are cloned recursively, while other values are returned as-is.
+ *
+ * @param value - The value to clone.
+ * @returns A deep clone of the value.
+ *
+ * @example
+ * ```ts
+ * const source = { user: { name: "Alice" }, tags: ["a"] }
+ * const copy = deepClone(source)
+ * copy.user.name = "Bob"
+ * source.user.name // "Alice" (the original is untouched)
+ * ```
+ */
+export function deepClone(value) {
+    return clone(value);
+}

package/dist/string.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Converts the first character of a string to upper case.
+ *
+ * @param value - The source string.
+ * @returns A new string with the first character upper-cased.
+ *
+ * @example
+ * ```ts
+ * capitalize("hello") // "Hello"
+ * capitalize("") // ""
+ * ```
+ */
+export declare function capitalize(value: string): string;
+/**
+ * Truncates a string to the given length, appending a suffix when it is cut.
+ *
+ * @param value - The source string.
+ * @param maxLength - Maximum length of the result, including the suffix.
+ * @param suffix - Appended when the string is truncated. Defaults to `"..."`.
+ * @returns The truncated string.
+ *
+ * @example
+ * ```ts
+ * truncate("Hello, world!", 8) // "Hello..."
+ * truncate("Hi", 8) // "Hi"
+ * ```
+ */
+export declare function truncate(value: string, maxLength: number, suffix?: string): string;
+/**
+ * Converts a string to camelCase.
+ *
+ * @param value - The source string. Segments may be separated by `-`, `_` or whitespace.
+ * @returns The camelCased string.
+ *
+ * @example
+ * ```ts
+ * camelCase("foo-bar baz") // "fooBarBaz"
+ * camelCase("FOO_BAR") // "fooBar"
+ * ```
+ */
+export declare function camelCase(value: string): string;
+/**
+ * Converts a string to kebab-case.
+ *
+ * @param value - The source string. camelCase boundaries, whitespace and `_` become `-`.
+ * @returns The kebab-cased string.
+ *
+ * @example
+ * ```ts
+ * kebabCase("fooBar") // "foo-bar"
+ * kebabCase("Foo_Bar baz") // "foo-bar-baz"
+ * ```
+ */
+export declare function kebabCase(value: string): string;

package/dist/string.js

@@ -0,0 +1,77 @@
+/**
+ * Converts the first character of a string to upper case.
+ *
+ * @param value - The source string.
+ * @returns A new string with the first character upper-cased.
+ *
+ * @example
+ * ```ts
+ * capitalize("hello") // "Hello"
+ * capitalize("") // ""
+ * ```
+ */
+export function capitalize(value) {
+    return value.charAt(0).toUpperCase() + value.slice(1);
+}
+/**
+ * Truncates a string to the given length, appending a suffix when it is cut.
+ *
+ * @param value - The source string.
+ * @param maxLength - Maximum length of the result, including the suffix.
+ * @param suffix - Appended when the string is truncated. Defaults to `"..."`.
+ * @returns The truncated string.
+ *
+ * @example
+ * ```ts
+ * truncate("Hello, world!", 8) // "Hello..."
+ * truncate("Hi", 8) // "Hi"
+ * ```
+ */
+export function truncate(value, maxLength, suffix = "...") {
+    if (value.length <= maxLength) {
+        return value;
+    }
+    return value.slice(0, Math.max(0, maxLength - suffix.length)) + suffix;
+}
+/**
+ * Converts a string to camelCase.
+ *
+ * @param value - The source string. Segments may be separated by `-`, `_` or whitespace.
+ * @returns The camelCased string.
+ *
+ * @example
+ * ```ts
+ * camelCase("foo-bar baz") // "fooBarBaz"
+ * camelCase("FOO_BAR") // "fooBar"
+ * ```
+ */
+export function camelCase(value) {
+    return value
+        .split(/[-_\s]+/)
+        .filter((word) => word.length > 0)
+        .map((word, index) => {
+        const lower = word.toLowerCase();
+        return index === 0 ? lower : capitalize(lower);
+    })
+        .join("");
+}
+/**
+ * Converts a string to kebab-case.
+ *
+ * @param value - The source string. camelCase boundaries, whitespace and `_` become `-`.
+ * @returns The kebab-cased string.
+ *
+ * @example
+ * ```ts
+ * kebabCase("fooBar") // "foo-bar"
+ * kebabCase("Foo_Bar baz") // "foo-bar-baz"
+ * ```
+ */
+export function kebabCase(value) {
+    return value
+        .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+        .replace(/[\s_]+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, "")
+        .toLowerCase();
+}

package/dist/type.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Checks whether a value is `null` or `undefined`.
+ *
+ * @param value - The value to check.
+ * @returns `true` when the value is `null` or `undefined`.
+ *
+ * @example
+ * ```ts
+ * isNil(null) // true
+ * isNil(undefined) // true
+ * isNil(0) // false
+ * ```
+ */
+export declare function isNil(value: unknown): value is null | undefined;
+/**
+ * Checks whether a value is neither `null` nor `undefined`, narrowing the type.
+ *
+ * @param value - The value to check.
+ * @returns `true` when the value is defined.
+ *
+ * @example
+ * ```ts
+ * isDefined(0) // true
+ * isDefined("") // true
+ * isDefined(null) // false
+ *
+ * const list = [1, null, 2].filter(isDefined) // number[]
+ * ```
+ */
+export declare function isDefined<T>(value: T | null | undefined): value is T;
+/**
+ * Checks whether a value is a plain object, e.g. created via `{}` or `new Object()`.
+ * Arrays, class instances, `Date`, `Map` and `null` are not considered plain objects.
+ *
+ * @param value - The value to check.
+ * @returns `true` when the value is a plain object.
+ *
+ * @example
+ * ```ts
+ * isPlainObject({}) // true
+ * isPlainObject(Object.create(null)) // true
+ * isPlainObject([]) // false
+ * isPlainObject(new Date()) // false
+ * ```
+ */
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Checks whether a value is "empty". `null`/`undefined`, empty strings and arrays,
+ * empty `Map`/`Set` and plain objects without own keys are treated as empty.
+ *
+ * @param value - The value to check.
+ * @returns `true` when the value is empty.
+ *
+ * @example
+ * ```ts
+ * isEmpty(null) // true
+ * isEmpty("") // true
+ * isEmpty([]) // true
+ * isEmpty(new Map()) // true
+ * isEmpty({}) // true
+ * isEmpty({ a: 1 }) // false
+ * ```
+ */
+export declare function isEmpty(value: unknown): boolean;

package/dist/type.js

@@ -0,0 +1,88 @@
+/**
+ * Checks whether a value is `null` or `undefined`.
+ *
+ * @param value - The value to check.
+ * @returns `true` when the value is `null` or `undefined`.
+ *
+ * @example
+ * ```ts
+ * isNil(null) // true
+ * isNil(undefined) // true
+ * isNil(0) // false
+ * ```
+ */
+export function isNil(value) {
+    return value === null || value === undefined;
+}
+/**
+ * Checks whether a value is neither `null` nor `undefined`, narrowing the type.
+ *
+ * @param value - The value to check.
+ * @returns `true` when the value is defined.
+ *
+ * @example
+ * ```ts
+ * isDefined(0) // true
+ * isDefined("") // true
+ * isDefined(null) // false
+ *
+ * const list = [1, null, 2].filter(isDefined) // number[]
+ * ```
+ */
+export function isDefined(value) {
+    return value !== null && value !== undefined;
+}
+/**
+ * Checks whether a value is a plain object, e.g. created via `{}` or `new Object()`.
+ * Arrays, class instances, `Date`, `Map` and `null` are not considered plain objects.
+ *
+ * @param value - The value to check.
+ * @returns `true` when the value is a plain object.
+ *
+ * @example
+ * ```ts
+ * isPlainObject({}) // true
+ * isPlainObject(Object.create(null)) // true
+ * isPlainObject([]) // false
+ * isPlainObject(new Date()) // false
+ * ```
+ */
+export function isPlainObject(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+/**
+ * Checks whether a value is "empty". `null`/`undefined`, empty strings and arrays,
+ * empty `Map`/`Set` and plain objects without own keys are treated as empty.
+ *
+ * @param value - The value to check.
+ * @returns `true` when the value is empty.
+ *
+ * @example
+ * ```ts
+ * isEmpty(null) // true
+ * isEmpty("") // true
+ * isEmpty([]) // true
+ * isEmpty(new Map()) // true
+ * isEmpty({}) // true
+ * isEmpty({ a: 1 }) // false
+ * ```
+ */
+export function isEmpty(value) {
+    if (isNil(value)) {
+        return true;
+    }
+    if (typeof value === "string" || Array.isArray(value)) {
+        return value.length === 0;
+    }
+    if (value instanceof Map || value instanceof Set) {
+        return value.size === 0;
+    }
+    if (isPlainObject(value)) {
+        return Object.keys(value).length === 0;
+    }
+    return false;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@zuwy/frontend-engineering-system-utils",
   "author": "Wenyin Zu",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Shared utility functions for @zuwy/frontend-engineering-system.",
   "license": "MIT",
   "private": false,
@@ -20,23 +20,22 @@
     "README.md",
     "LICENSE"
   ],
-  "scripts": {
-    "build": "tsc -p tsconfig.build.json",
-    "lint": "eslint .",
-    "typecheck": "tsc --noEmit",
-    "pack:check": "npm pack --dry-run",
-    "prepublishOnly": "pnpm lint && pnpm typecheck && pnpm build && pnpm pack:check"
-  },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"
   },
   "devDependencies": {
-    "@zuwy/frontend-engineering-system-eslint-config": "workspace:*",
-    "@zuwy/frontend-engineering-system-ts-config": "workspace:*",
     "typescript": "~6.0.2",
     "eslint": "^10.5.0",
     "eslint-config-prettier": "^10.1.8",
-    "typescript-eslint": "^8.61.0"
+    "typescript-eslint": "^8.61.0",
+    "@zuwy/frontend-engineering-system-eslint-config": "0.0.0",
+    "@zuwy/frontend-engineering-system-ts-config": "1.0.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "lint": "eslint .",
+    "typecheck": "tsc --noEmit",
+    "pack:check": "npm pack --dry-run"
   }
-}
+}