@codeleap/utils 6.3.0 → 6.8.0

package/dist/array.d.ts

@@ -0,0 +1,33 @@
+import { FunctionType } from '@codeleap/types';
+type GetterFunction<T> = FunctionType<[T, number], string | number> | keyof T;
+/**
+ * Indexes an array into an object keyed by a derived value.
+ *
+ * `keyAccessor` may be a property name string or a callback that returns a
+ * key. When omitted, array indices are used as keys. Duplicate keys silently
+ * overwrite earlier entries.
+ */
+export declare function objectFromArray<T, Getter extends GetterFunction<T>>(arr: T[], keyAccessor?: Getter): Record<string, T>;
+/**
+ * Returns a deduplicated copy of `array` where uniqueness is determined by
+ * the value returned from `getProperty`.
+ *
+ * When duplicates exist, the **last** occurrence wins because `objectFromArray`
+ * overwrites earlier entries with the same key.
+ */
+export declare function uniqueArrayByProperty<T, G extends GetterFunction<T>>(array: T[], getProperty: G): T[];
+/**
+ * Recursively flattens a nested array of arbitrary depth into a single-level array.
+ *
+ * Unlike `Array.prototype.flat(Infinity)`, this implementation does not rely on
+ * native flat support and works identically across all environments.
+ */
+export declare function flatten<T extends unknown>(arr: T[]): T[];
+/**
+ * Returns an inclusive integer array from `start` to `end`.
+ *
+ * Both bounds are included: `range(1, 3)` → `[1, 2, 3]`.
+ */
+export declare function range(start: number, end: number): number[];
+export {};
+//# sourceMappingURL=array.d.ts.map

package/dist/array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../src/array.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAE9C,KAAK,cAAc,CAAC,CAAC,IAAI,YAAY,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG,MAAM,CAAC,CAAA;AAE7E;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,SAAS,cAAc,CAAC,CAAC,CAAC,EACjE,GAAG,EAAE,CAAC,EAAE,EACR,WAAW,CAAC,EAAE,MAAM,GACnB,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAiBnB;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,CAAC,SAAS,cAAc,CAAC,CAAC,CAAC,EAClE,KAAK,EAAE,CAAC,EAAE,EACV,WAAW,EAAE,CAAC,OAGf;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE,OAYlD;AAED;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,YAG/C"}

package/dist/cloneDeep.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Produces a full recursive clone of `value` without any external dependencies.
+ *
+ * Supported types: primitives (returned as-is), plain objects, arrays, `Date`,
+ * `Map`, `Set`, and `RegExp`. Class instances with prototype methods beyond
+ * these built-ins are cloned as plain objects — prototype chain is not preserved.
+ * Circular references will cause a stack overflow.
+ */
+export declare function cloneDeep<T = any>(value: T): T;
+//# sourceMappingURL=cloneDeep.d.ts.map

package/dist/cloneDeep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloneDeep.d.ts","sourceRoot":"","sources":["../src/cloneDeep.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,CAAC,GAAG,GAAG,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CA0C9C"}

package/dist/colors.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Parses a 6-digit hex colour string (with or without leading `#`) into its
+ * `{ r, g, b }` components.
+ *
+ * Returns `null` for invalid or short (3-digit) hex values.
+ */
+export declare function hexToRgb(hex: string): {
+    r: number;
+    g: number;
+    b: number;
+} | null;
+/**
+ * Lightens or darkens `color` by `percent` and optionally applies `opacity`,
+ * returning an `rgba(...)` string.
+ *
+ * - Positive `percent` → lighten; negative → darken (magnitude is used).
+ * - `opacity` must be in the `0–1` range (passed directly to tinycolor's `setAlpha`).
+ * - Results are memoised in a module-level cache keyed by the serialised parameters,
+ *   so repeated calls with identical arguments are effectively free.
+ */
+export declare function shadeColor(color: string, percent?: number, opacity?: number | null): string;
+//# sourceMappingURL=colors.d.ts.map

package/dist/colors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colors.d.ts","sourceRoot":"","sources":["../src/colors.ts"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM;;;;SASnC;AAID;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,SAAI,EAAE,OAAO,GAAE,MAAM,GAAG,IAAW,UA+BnF"}

package/dist/date.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Date helpers that normalise timezone-sensitive values before formatting.
+ *
+ * - `removeTimezoneAndFormat(date, format?)` — strips the time component from
+ *   a `Date` or ISO string, anchors it to noon local time, then formats with
+ *   dayjs. This prevents off-by-one-day errors that occur when UTC midnight
+ *   falls on a different calendar day in the user's timezone. Returns `''` for
+ *   falsy input.
+ */
+export declare const dateUtils: {
+    removeTimezoneAndFormat: (date: any, format?: string) => string;
+};
+//# sourceMappingURL=date.d.ts.map

package/dist/date.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date.d.ts","sourceRoot":"","sources":["../src/date.ts"],"names":[],"mappings":"AAgBA;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS;oCAvBiB,GAAG;CAyBzC,CAAA"}

package/dist/faker.d.ts

@@ -0,0 +1,23 @@
+declare function number(min?: number, max?: number): number;
+/**
+ * Lightweight in-house fixture-data generator with no external dependencies.
+ *
+ * Provided methods:
+ * - `firstName()` / `lastName()` — random entries from hard-coded name lists.
+ * - `name()` — space-joined first + last name.
+ * - `animal()` — random animal name.
+ * - `number(min?, max?)` — random integer in `[min, max]` (default 0–100).
+ *
+ * All selections use `Math.random`, so results are not reproducible across calls.
+ * Use this instead of heavy faker libraries in tests or seed scripts where the
+ * small vocabulary is sufficient.
+ */
+export declare const faker: {
+    lastName: () => string;
+    firstName: () => string;
+    animal: () => string;
+    number: typeof number;
+    name: () => string;
+};
+export {};
+//# sourceMappingURL=faker.d.ts.map

package/dist/faker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"faker.d.ts","sourceRoot":"","sources":["../src/faker.ts"],"names":[],"mappings":"AAuBA,iBAAS,MAAM,CAAC,GAAG,GAAE,MAAU,EAAE,GAAG,GAAE,MAAY,UAEjD;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,KAAK;;;;;;CAMjB,CAAA"}

package/dist/file.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Splits a file system path into its directory, base name, and extension.
+ *
+ * Both `/` and `\` are treated as separators, so Windows and POSIX paths are
+ * handled uniformly. Files without an extension return an empty string for
+ * `extension`. The returned `path` is always joined with `/` regardless of the
+ * original separator.
+ */
+export declare function parseFilePathData(path: string): {
+    path: string;
+    extension: string;
+    name: string;
+};
+//# sourceMappingURL=file.d.ts.map

package/dist/file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../src/file.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM;;;;EAoB7C"}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export * from './array';
+export * from './colors';
+export * from './misc';
+export * from './object';
+export * from './react';
+export * from './file';
+export * from './string';
+export * from './faker';
+export * from './cloneDeep';
+export * from './locale';
+export * from './date';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAA;AACvB,cAAc,UAAU,CAAA;AACxB,cAAc,QAAQ,CAAA;AACtB,cAAc,UAAU,CAAA;AACxB,cAAc,SAAS,CAAA;AACvB,cAAc,QAAQ,CAAA;AACtB,cAAc,UAAU,CAAA;AACxB,cAAc,SAAS,CAAA;AACvB,cAAc,aAAa,CAAA;AAC3B,cAAc,UAAU,CAAA;AACxB,cAAc,QAAQ,CAAA"}

package/dist/locale.d.ts

@@ -0,0 +1,10 @@
+import { AnyRecord } from '@codeleap/types';
+/**
+ * Finds the closest matching key in `languageDictionary` for a given `locale`.
+ *
+ * Matching uses only the first two characters (the language subtag), so `'en-AU'`
+ * will match an `'en-US'` dictionary key. Returns `defaultLocale` when no
+ * partial match exists.
+ */
+export declare function getSimilarLocale(locale: string, defaultLocale: string, languageDictionary: AnyRecord): string;
+//# sourceMappingURL=locale.d.ts.map

package/dist/locale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locale.d.ts","sourceRoot":"","sources":["../src/locale.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAE3C;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,MAAM,EACrB,kBAAkB,EAAE,SAAS,UAS9B"}

package/dist/misc.d.ts

@@ -0,0 +1,67 @@
+import { StylesOf } from '@codeleap/types';
+/**
+ * Converts a remote image URL into a file-upload-compatible object
+ * (`{ uri, name, type }`).
+ *
+ * The `type` is inferred from the URL's file extension. Returns `null` when
+ * `imagePath` is falsy, making it safe to pass directly to optional file-input APIs.
+ */
+export declare function imagePathToFileObject(imagePath: string | null): {
+    uri: string;
+    name: string;
+    type: string;
+} | null;
+/**
+ * Maps the first character of `anyString` to a deterministic colour for use in
+ * avatar placeholders.
+ *
+ * Lookup is case-insensitive. Returns `'#999999'` for empty, undefined, or
+ * characters not in the `a–z` range.
+ */
+export declare function matchInitialToColor(anyString?: string): string;
+/** Returns a Promise that resolves after `ms` milliseconds. */
+export declare function waitFor(ms: number): Promise<void>;
+type ParseSourceUrlArg = {
+    source?: string;
+    src?: string;
+};
+/**
+ * Resolves a media URL from either a raw string or a `{ source?, src? }` object.
+ *
+ * - Paths starting with `/media/` are prefixed with `Settings.BaseURL`.
+ * - Absolute URLs are returned unchanged.
+ * - Empty/missing addresses fall back to a random `picsum.photos` placeholder.
+ * - Returns `null` for a falsy `args` argument.
+ */
+export declare function parseSourceUrl(args: string, Settings?: any): string;
+export declare function parseSourceUrl(args: ParseSourceUrlArg, Settings?: any): string | null;
+/**
+ * Extracts style entries from a variant styles map whose keys begin with `match`,
+ * returning them as a new object with the prefix stripped and the first
+ * remaining character lowercased.
+ *
+ * Used internally by component style systems to pull out sub-part styles
+ * (e.g. `inputLabel`, `inputWrapper`) into their own namespaced objects.
+ */
+export declare function getNestedStylesByKey<T extends StylesOf<any>>(match: string, variantStyles: T): Record<string, unknown>;
+/**
+ * Heuristically detects whether the app has been React Fast Refreshed since
+ * initial launch.
+ *
+ * Compares the elapsed time since `Settings.Environment.InitTime` against a
+ * 1-second threshold. Fast Refresh typically completes well under 1 second from
+ * app start; anything longer suggests a subsequent refresh rather than cold boot.
+ * Returns `undefined` and logs a warning when `InitTime` is not set.
+ */
+export declare function hasFastRefreshed(Settings: any): any;
+/**
+ * Leading-edge throttle keyed by a `ref` identifier rather than by function reference.
+ *
+ * `func` is called immediately on the first invocation for a given `ref`; subsequent
+ * calls with the same `ref` are dropped until `delay` milliseconds have elapsed.
+ * Using a string/number `ref` allows multiple independent throttle timers to coexist
+ * in a single module without needing to hold separate timer handles.
+ */
+export declare function throttle(func: () => void, ref: string | number, delay: number): void;
+export {};
+//# sourceMappingURL=misc.d.ts.map

package/dist/misc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"misc.d.ts","sourceRoot":"","sources":["../src/misc.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAE1C;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;;;;SAc7D;AA+BD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,CAAC,EAAE,MAAM,UAGrD;AAED,+DAA+D;AAC/D,wBAAgB,OAAO,CAAC,EAAE,EAAE,MAAM,iBAMjC;AAED,KAAK,iBAAiB,GAAG;IACvB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,GAAG,CAAC,EAAE,MAAM,CAAA;CACb,CAAA;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,GAAG,GAAG,MAAM,CAAA;AACpE,wBAAgB,cAAc,CAC5B,IAAI,EAAE,iBAAiB,EACvB,QAAQ,CAAC,EAAE,GAAG,GACb,MAAM,GAAG,IAAI,CAAA;AA0BhB;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,QAAQ,CAAC,GAAG,CAAC,EAAE,KAAK,EAAC,MAAM,EAAE,aAAa,EAAE,CAAC,2BAY3F;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,GAAG,OAU7C;AAID;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,IAAI,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,EAAE,MAAM,QAS7E"}

package/dist/object.d.ts

@@ -0,0 +1,115 @@
+import { FunctionType, AppSettings } from '@codeleap/types';
+/**
+ * Recursively merges `changes` into `base`, deep-merging nested plain objects.
+ *
+ * Arrays and `Date` instances are treated as scalar values — they replace rather
+ * than merge. If `changes` is not iterable, it is returned as-is.
+ */
+export declare function deepMerge(base?: Record<string, any>, changes?: Record<string, any>): any;
+/**
+ * Like `Array.prototype.map` but over an object's entries.
+ *
+ * Returns an array — not a new object — so it is useful when you need to
+ * transform key-value pairs into arbitrary values (e.g. JSX elements).
+ */
+export declare function mapObject<T>(obj: T, callback: FunctionType<[[keyof T, T[keyof T]]], any>): any[];
+/**
+ * Sets a value at an arbitrarily deep dot-separated `path`, mutating `base` in place
+ * and returning it.
+ *
+ * Numeric path segments are coerced to array indices when the current node is an array.
+ */
+export declare const deepSet: (base: any | undefined, path: string, value: any) => any;
+/**
+ * Reads a value from `obj` at a dot-separated `path`.
+ *
+ * Returns `undefined` (without throwing) when any intermediate node is absent,
+ * because property access on `undefined` propagates silently through the loop.
+ */
+export declare const deepGet: (path: string, obj: Record<string, any>) => Record<string, any>;
+/**
+ * Returns every dot-separated leaf path in a nested object.
+ *
+ * Array values are treated as leaves — their indices are not traversed.
+ */
+export declare function objectPaths(obj: Record<string, any>): string[];
+/** Returns `true` only for `string`, `number`, and `boolean` — `null`, `undefined`, and objects are excluded. */
+export declare function isValuePrimitive(a: any): boolean;
+/**
+ * Inline ternary helper for spread-merging optional style or prop objects.
+ *
+ * Intended for use inside object spreads where the ternary would otherwise
+ * require wrapping: `{ ...optionalObject(flag, trueProps, {}) }`.
+ */
+export declare function optionalObject(condition: boolean, ifTrue: any, ifFalse: any): any;
+type TraverseRecArgs = {
+    path: string[];
+    value: any;
+    depth: number;
+    key: string;
+    type: string;
+    primitive: boolean;
+};
+type TraverseCallback = (args?: TraverseRecArgs) => {
+    stop?: boolean;
+} | void;
+/**
+ * Depth-first walk over a nested object, invoking `callback` at each node.
+ *
+ * The callback receives metadata about each visited node (`path`, `depth`,
+ * `key`, `type`, `primitive`). Primitive leaves fire the callback once; object
+ * nodes fire it for each child before recursing into it. Returning `{ stop: true }`
+ * from the callback is accepted by the type but **does not halt traversal** —
+ * the implementation does not check the return value.
+ */
+export declare function traverse(obj: any | undefined, callback: TraverseCallback, args?: TraverseRecArgs): void;
+/**
+ * Identity helper that returns its argument unchanged, typed as `AppSettings`.
+ *
+ * Exists solely to give TypeScript a typed entry point for authoring settings
+ * objects so that editors provide autocompletion and type errors at the
+ * definition site rather than at the point of use.
+ */
+export declare function createSettings<T extends AppSettings>(a: T): T;
+/**
+ * Returns `obj.id` if it exists, otherwise `undefined`.
+ *
+ * Intended as a default `keyExtractor` in list utilities where records are
+ * expected to carry an `id` field.
+ */
+export declare function extractKey(obj: any): any;
+/**
+ * Returns a new object containing only the entries for which `predicate` returns `true`.
+ *
+ * Only own enumerable keys are visited; prototype-chain properties are skipped.
+ */
+export declare function objectPickBy<K extends string = string, P = any>(obj: Record<K, P>, predicate: (valueKey: P, key: K) => boolean): Record<K, P>;
+/**
+ * Rebuilds an object by running every entry through `predicate`, which must
+ * return a `[newKey, newValue]` tuple.
+ *
+ * Keys returned by `predicate` need not be unique — later entries silently
+ * overwrite earlier ones if they resolve to the same key.
+ */
+export declare function transformObject<K extends string = string, T extends string = string>(obj: Record<K, T>, predicate: (value: T, key: K) => [K, T]): Record<string, any>;
+type LowercaseFirst<S extends string> = S extends `${infer F}${infer Rest}` ? `${Lowercase<F>}${Rest}` : S;
+/**
+ * Mapped type that extracts keys of `T` starting with `P`, strips the prefix,
+ * and lowercases the first character of the remainder.
+ *
+ * Used to derive the return type of {@link filterObjectByPrefix} at compile time.
+ * For example, `FilterByPrefix<{ onPress: () => void }, 'on'>` yields `{ press: () => void }`.
+ */
+export type FilterByPrefix<T, P extends string> = {
+    [K in Extract<keyof T, `${P}${string}`> as K extends `${P}${infer Rest}` ? LowercaseFirst<Rest> : never]: T[K];
+};
+/**
+ * Returns a new object containing only keys that start with `prefix`, with the
+ * prefix stripped and the first remaining character lowercased.
+ *
+ * Useful for splitting a flat props object into logical groups, e.g. separating
+ * all `inputXxx` props from a combined component interface.
+ */
+export declare function filterObjectByPrefix<T extends Record<string, any>, P extends string>(obj: T, prefix: P): FilterByPrefix<T, P>;
+export {};
+//# sourceMappingURL=object.d.ts.map

package/dist/object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../src/object.ts"],"names":[],"mappings":"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"}

package/dist/react.d.ts

@@ -0,0 +1,118 @@
+import equals from 'deep-equal';
+import React from 'react';
+/** Deep structural equality backed by the `deep-equal` package. */
+export declare const deepEqual: typeof equals;
+type ArePropsEqualOptions<MergedObject> = {
+    check: (keyof MergedObject)[];
+    excludeKeys?: string[];
+};
+/**
+ * Checks a specific subset of props for deep equality between two render cycles.
+ *
+ * `excludeKeys` are deleted from each compared value **in place** before
+ * comparison — this mutates the items inside `previous` and `next`.
+ * Pass only the keys you want to ignore, and be aware of the side-effect.
+ */
+export declare function arePropsEqual<A, B>(previous: A, next: B, options: ArePropsEqualOptions<A & B>): boolean;
+/**
+ * Recursively collects a React children tree into a single flat array.
+ *
+ * Uses `React.Children.toArray` at each level (which assigns stable keys), then
+ * follows any `children` prop on the top-level element to continue flattening.
+ * Only one level of `props.children` nesting is followed per call — deeply
+ * nested component trees (not just wrapper nodes) are not fully unwound.
+ */
+export declare const flattenChildren: (children: any, flat?: React.ReactNode[]) => React.ReactNode[];
+/**
+ * Flattens a children tree and strips the `children` prop from each element's
+ * props, returning a serialisable summary of the tree.
+ *
+ * Intended for introspection and testing — not for re-rendering, since `ref`
+ * and event-handler functions are preserved as-is.
+ */
+export declare const simplifyChildren: (children: any) => {
+    key: any;
+    ref: any;
+    type: any;
+    props: any;
+}[];
+/**
+ * Renders a slot that accepts a component, a props object, or a pre-rendered node.
+ *
+ * Resolution order:
+ * 1. If `ComponentOrProps` is a function → render it as `<ComponentOrProps {...props} />`.
+ * 2. If it is `null`, `undefined`, or an empty object → return `null`.
+ * 3. If it is already a valid React element → return it as-is.
+ * 4. Otherwise treat it as a props object and render `<DefaultComponent {...props} {...ComponentOrProps} />`.
+ *
+ * This lets call sites pass either a component override, extra props, or nothing,
+ * without needing separate conditional rendering logic.
+ */
+export declare function getRenderedComponent<P = any>(ComponentOrProps: React.ComponentType<P> | P | React.ReactNode | null | undefined, DefaultComponent: React.ComponentType<P>, props?: P): React.ReactNode;
+/**
+ * Memoizes a React functional component to prevent unnecessary re-renders.
+ *
+ * This function wraps a React functional component using `React.memo`, which provides
+ * a mechanism for memoizing the result of rendering the component. By default, it
+ * uses a comparison function that always returns `true`, indicating that the component
+ * should not re-render, regardless of prop changes. This behavior essentially freezes
+ * the component's rendering until explicitly updated.
+ *
+ * @template P - The type of the component's props.
+ * @param ComponentToMemoize - The React functional component to memoize.
+ * @returns A memoized version of the input component (`React.NamedExoticComponent`).
+ */
+export declare function memoize<P extends object>(ComponentToMemoize: React.FunctionComponent<P>): React.NamedExoticComponent<P>;
+/**
+ * Checks whether a specific property in two sets of props is equal.
+ *
+ * This function compares the value of a given property (`prop`) between two objects
+ * (`prevProps` and `nextProps`) using a deep equality check (`equals`).
+ *
+ * @template P - The type of the props object.
+ * @param prop - The key of the property to compare.
+ * @param prevProps - The previous props object.
+ * @param nextProps - The next props object.
+ * @returns `true` if the values of the specified property are deeply equal; otherwise, `false`.
+ */
+export declare function memoChecker<P>(prop: keyof P, prevProps: P, nextProps: P): boolean;
+/**
+ * Memoizes a React functional component based on specific props.
+ *
+ * This function wraps a React functional component using `React.memo` with a custom comparison
+ * function. The comparison function checks if the specified properties (passed as `check`)
+ * remain equal between renders. If all specified properties are equal, the component will not re-render.
+ *
+ * @template P - The type of the component's props.
+ * @param ComponentToMemoize - The React functional component to memoize.
+ * @param check - A single property key or an array of property keys to compare for memoization.
+ * @returns A memoized version of the input component (`React.NamedExoticComponent`).
+ *
+ * @example
+ * import React from 'react';
+ * import { memoBy } from './utils';
+ *
+ * const MyComponent: React.FC<{ name: string; age: number }> = ({ name, age }) => {
+ *   console.log('Rendering MyComponent...');
+ *   return (
+ *     <div>
+ *       {name}, {age}
+ *     </div>
+ *   );
+ * };
+ *
+ * // Memoize the component based on the `name` prop.
+ * const MemoizedByName = memoBy(MyComponent, 'name');
+ *
+ * // Memoize the component based on both `name` and `age` props.
+ * const MemoizedByNameAndAge = memoBy(MyComponent, ['name', 'age']);
+ *
+ * export { MemoizedByName, MemoizedByNameAndAge };
+ *
+ * // Usage in a parent component
+ * <MemoizedByName name="Alice" age={25} />;
+ * <MemoizedByNameAndAge name="Alice" age={25} />;
+ */
+export declare function memoBy<P extends object>(ComponentToMemoize: React.FunctionComponent<P>, check: keyof P | Array<keyof P>): React.NamedExoticComponent<P>;
+export {};
+//# sourceMappingURL=react.d.ts.map

package/dist/react.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../src/react.tsx"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,YAAY,CAAA;AAC/B,OAAO,KAAK,MAAM,OAAO,CAAA;AAGzB,mEAAmE;AACnE,eAAO,MAAM,SAAS,eAAS,CAAA;AAE/B,KAAK,oBAAoB,CAAC,YAAY,IAAI;IACxC,KAAK,EAAE,CAAC,MAAM,YAAY,CAAC,EAAE,CAAA;IAC7B,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;CACvB,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,CAAC,EAChC,QAAQ,EAAE,CAAC,EACX,IAAI,EAAE,CAAC,EACP,OAAO,EAAE,oBAAoB,CAAC,CAAC,GAAG,CAAC,CAAC,WAqBrC;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,GAAI,UAAU,GAAG,EAAE,OAAM,KAAK,CAAC,SAAS,EAAO,KAAG,KAAK,CAAC,SAAS,EAQ5F,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,GAAI,UAAU,GAAG;;;;;GAgB7C,CAAA;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,GAAG,GAAG,EAC1C,gBAAgB,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,SAAS,GAAG,IAAI,GAAG,SAAS,EACjF,gBAAgB,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,EACxC,KAAK,CAAC,EAAE,CAAC,GACR,KAAK,CAAC,SAAS,CAmBjB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,MAAM,EAAE,kBAAkB,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAEvH;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,GAAG,OAAO,CAKjF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,MAAM,EACrC,kBAAkB,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAC9C,KAAK,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,GAC9B,KAAK,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAK/B"}

package/dist/string.d.ts

@@ -0,0 +1,43 @@
+/** Collapses all newline characters in `text` to single spaces. */
+export declare function singleLine(text: string): string;
+/**
+ * Round-trips a value through `JSON.stringify` → `JSON.parse`.
+ *
+ * Strips non-serialisable properties (functions, `undefined`, class instances)
+ * and produces a plain-object clone. Throws if the value contains circular
+ * references.
+ */
+export declare function stringiparse(string: string): any;
+/**
+ * Changes only the first character of `str`.
+ *
+ * When `reverse` is `true` the first character is lowercased instead of
+ * uppercased — useful for converting PascalCase to camelCase.
+ */
+export declare function capitalize(str: string, reverse?: boolean): string;
+/**
+ * Returns `true` if `char` is an uppercase Latin or extended Latin character.
+ *
+ * Covers the Unicode range `U+0080`–`U+024F` in addition to `A–Z`, so
+ * accented capitals (e.g. `É`, `Ñ`) are recognised correctly.
+ */
+export declare function isUppercase(char: string): boolean;
+/** Returns `true` when `char` is **not** considered uppercase by {@link isUppercase}. */
+export declare function isLowercase(char: string): boolean;
+/**
+ * Converts a camelCase or PascalCase identifier to a space-separated, title-cased string.
+ *
+ * A space is inserted before each uppercase letter that is immediately preceded
+ * by a lowercase letter. The first character is always uppercased.
+ * Consecutive uppercase runs (e.g. acronyms like "URL") are not split.
+ */
+export declare function humanizeCamelCase(str: string): string;
+/**
+ * Truncates `str` to `maxLen` characters, appending `'...'` when truncation occurs.
+ *
+ * The three dots count toward `maxLen`, so the returned string never exceeds
+ * `maxLen` characters when truncated. Strings already at or below `maxLen` are
+ * returned unchanged.
+ */
+export declare function ellipsis(str: string, maxLen: number): string;
+//# sourceMappingURL=string.d.ts.map

package/dist/string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../src/string.ts"],"names":[],"mappings":"AAAA,mEAAmE;AACnE,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,UAEtC;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,OAE1C;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,UAAQ,UAItD;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,WAEvC;AAED,yFAAyF;AACzF,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,WAEvC;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,UAkB5C;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,UAMnD"}

package/package.json

@@ -1,7 +1,20 @@
 {
   "name": "@codeleap/utils",
-  "version": "6.3.0",
+  "version": "6.8.0",
   "main": "src/index.ts",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
   "license": "UNLICENSED",
   "repository": {
     "url": "https://github.com/codeleap-uk/internal-libs-monorepo.git",
@@ -9,23 +22,24 @@
     "directory": "packages/utils"
   },
   "devDependencies": {
-    "@codeleap/config": "6.3.0",
-    "@codeleap/types": "6.3.0",
+    "@codeleap/config": "6.8.0",
+    "@codeleap/types": "6.8.0",
     "ts-node-dev": "1.1.8"
   },
   "scripts": {
-    "build": "echo 'No build needed'"
+    "build": "tsc --build tsconfig.build.json",
+    "typecheck": "bun tsc --noEmit -p ./tsconfig.json"
   },
   "peerDependencies": {
-    "@codeleap/types": "6.3.0",
+    "@codeleap/types": "6.8.0",
     "axios": "^1.7.9",
     "dayjs": "1.11.18",
-    "typescript": "5.5.2",
+    "typescript": "6.0.3",
     "react": "19.1.0",
-    "@tanstack/react-query": "5.89.0"
+    "@tanstack/react-query": "5.100.9"
   },
   "dependencies": {
     "tinycolor2": "^1.4.2",
     "deep-equal": "^2.0.5"
   }
-}
+}