@leancodepl/utils 8.5.0 → 8.6.0

package/src/lib/hooks/useKeyByRoute.d.ts

@@ -0,0 +1,29 @@
+/**
+ * React hook for generating keys based on current route matches.
+ *
+ * @template TKey - The type of the route keys
+ * @param routeMatches - Record of route keys to match objects or arrays
+ * @returns Array of active route keys
+ * @example
+ * ```typescript
+ * function NavigationComponent() {
+ *   const routeMatches = {
+ *     home: useRouteMatch('/'),
+ *     about: useRouteMatch('/about'),
+ *     contact: useRouteMatch('/contact')
+ *   };
+ *
+ *   const activeRoutes = useKeyByRoute(routeMatches);
+ *   // Returns ['home'] if on home page, ['about'] if on about page, etc.
+ *
+ *   return (
+ *     <nav>
+ *       {activeRoutes.map(route => (
+ *         <span key={route}>Active: {route}</span>
+ *       ))}
+ *     </nav>
+ *   );
+ * }
+ * ```
+ */
+export declare function useKeyByRoute<TKey extends string>(routeMatches: Record<TKey, (object | null)[] | never | object | null>): TKey[];

package/src/lib/hooks/useRunInTask.d.ts

@@ -0,0 +1,25 @@
+/**
+ * React hook for tracking async task execution with loading state.
+ * Automatically manages a loading counter and provides a wrapper function for tasks.
+ *
+ * @returns A tuple containing [isLoading: boolean, runInTask: function]
+ * @example
+ * ```typescript
+ * function MyComponent() {
+ *   const [isLoading, runInTask] = useRunInTask();
+ *
+ *   const handleSave = async () => {
+ *     await runInTask(async () => {
+ *       await saveData();
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleSave} disabled={isLoading}>
+ *       {isLoading ? 'Saving...' : 'Save'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export declare function useRunInTask(): readonly [boolean, <T>(task: () => Promise<T> | T) => Promise<T>];

package/src/lib/hooks/useSetUnset.d.ts

@@ -0,0 +1,23 @@
+import { Dispatch, SetStateAction } from "react";
+/**
+ * React hook for boolean state management helpers.
+ *
+ * @param set - The state setter function from useState
+ * @returns A tuple containing [setTrue: function, setFalse: function]
+ * @example
+ * ```typescript
+ * function MyComponent() {
+ *   const [isVisible, setIsVisible] = useState(false);
+ *   const [show, hide] = useSetUnset(setIsVisible);
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={show}>Show</button>
+ *       <button onClick={hide}>Hide</button>
+ *       {isVisible && <div>Content is visible</div>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useSetUnset(set: Dispatch<SetStateAction<boolean>>): readonly [() => void, () => void];

package/src/lib/transformDeep.d.ts

@@ -0,0 +1,29 @@
+import { CapitalizeDeep, UncapitalizeDeep } from "./types";
+/**
+ * Recursively transforms all object keys to use uncapitalized (camelCase) format.
+ *
+ * @template T - The type of the input value
+ * @param value - The value to transform (can be object, array, or primitive)
+ * @returns A new object with all keys converted to camelCase
+ * @example
+ * ```typescript
+ * const serverData = { UserId: 1, UserName: 'John', Profile: { FirstName: 'John' } };
+ * const clientData = uncapitalizeDeep(serverData);
+ * // Result: { userId: 1, userName: 'John', profile: { firstName: 'John' } }
+ * ```
+ */
+export declare function uncapitalizeDeep<T>(value: T): UncapitalizeDeep<T>;
+/**
+ * Recursively transforms all object keys to use capitalized (PascalCase) format.
+ *
+ * @template T - The type of the input value
+ * @param value - The value to transform (can be object, array, or primitive)
+ * @returns A new object with all keys converted to PascalCase
+ * @example
+ * ```typescript
+ * const clientData = { userId: 1, userName: 'John', profile: { firstName: 'John' } };
+ * const serverData = capitalizeDeep(clientData);
+ * // Result: { UserId: 1, UserName: 'John', Profile: { FirstName: 'John' } }
+ * ```
+ */
+export declare function capitalizeDeep<T>(value: T): CapitalizeDeep<T>;

package/src/lib/transformFirst.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Converts the first character of a string to lowercase.
+ *
+ * @param value - The string to transform
+ * @returns The string with the first character in lowercase
+ * @example
+ * ```typescript
+ * const result = toLowerFirst('UserName');
+ * // Result: 'userName'
+ * ```
+ */
+export declare function toLowerFirst(value: string): string;
+/**
+ * Converts the first character of a string to uppercase.
+ *
+ * @param value - The string to transform
+ * @returns The string with the first character in uppercase
+ * @example
+ * ```typescript
+ * const result = toUpperFirst('userName');
+ * // Result: 'UserName'
+ * ```
+ */
+export declare function toUpperFirst(value: string): string;

package/src/lib/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./transformDeep";
+export * from "./unpromisify";

package/src/lib/types/transformDeep.d.ts

@@ -0,0 +1,10 @@
+import type { ApiDateOnly, ApiDateTimeOffset, ApiTimeOnly, ApiTimeSpan } from "@leancodepl/api-date";
+export type Mode = "capitalize" | "uncapitalize";
+export type TransformDeep<T, TMode extends Mode> = T extends Array<infer TArrayElement> ? Array<TransformDeep<TArrayElement, TMode>> : T extends object ? T extends ApiDateOnly | ApiDateTimeOffset | ApiTimeOnly | ApiTimeSpan ? T : {
+    [TKey in keyof T as TKey extends string ? TMode extends "uncapitalize" ? Uncapitalize<TKey> : Capitalize<TKey> : TKey]: TransformDeep<T[TKey], TMode>;
+} : T extends null ? undefined : T;
+export type UncapitalizeDeep<T> = TransformDeep<T, "uncapitalize">;
+export type CapitalizeDeep<T> = TransformDeep<T, "capitalize">;
+export type MutableDeep<T> = T extends bigint | boolean | Date | number | string | symbol | null | undefined ? T : T extends ReadonlyArray<infer ArrayType> ? Array<MutableDeep<ArrayType>> : {
+    -readonly [K in keyof T]: MutableDeep<T[K]>;
+};

package/src/lib/types/unpromisify.d.ts

@@ -0,0 +1 @@
+export type Unpromisify<T> = T extends Promise<infer TResult> ? TResult : T;