@redocly/redoc-reef 0.138.0-next.13 → 0.138.0-next.15

package/dist/types/ssr.d.ts

@@ -1,42 +0,0 @@
-import type { AsyncApiRealmCLI } from '@redocly/realm-asyncapi-sdk';
-import type { Store } from '../server/store';
-import type { PageProps, UserData, Version, ProductConfig } from '@redocly/config';
-export type RenderPayload = {
-    page: RenderPagePayload;
-    store: Pick<Store, 'globalData' | 'config' | 'ssr' | 'hasSitemap'>;
-    sharedData: Record<string, unknown>;
-    serverOutDir: string;
-    outdir: string;
-    ssrHref: string;
-    userAgent: string;
-    telemetry: AsyncApiRealmCLI.Telemetry;
-    omitSuspense: boolean;
-};
-export type RenderPagePayload = {
-    templateId: string;
-    slug: string;
-    props: PageProps;
-    sharedDataIds: Record<string, string>;
-    userInfo: UserData;
-    versions?: Version[];
-    isPublic: boolean;
-    product?: ProductConfig;
-    request?: {
-        search: string;
-        url: string;
-    };
-};
-export type RenderTemplateInput = {
-    bodyHtml: string;
-    linkTags: string;
-    lang?: string;
-    title: string;
-    favicon?: string;
-    preload?: string[];
-    headScriptTags?: string;
-    postBodyScriptTags?: string;
-    preBodyScriptTags?: string;
-    productClass?: string;
-    runtimeCss?: string;
-};
-//# sourceMappingURL=ssr.d.ts.map

package/dist/utils/array/ensure-array.d.ts

@@ -1,18 +0,0 @@
-/**
- * Ensures that the input value is always returned as an array.
- *
- * If the input is already an array, it is returned unchanged.
- * If the input is a single value, it is wrapped in an array.
- *
- * @template T The type of the value or array elements.
- * @param maybeArray - A single item or an array of items.
- * @returns An array containing the input value(s).
- *
- * @example
- * ```ts
- * ensureArray(5); // [5]
- * ensureArray([1, 2, 3]); // [1, 2, 3]
- * ```
- */
-export declare function ensureArray<T>(maybeArray: T | T[]): T[];
-//# sourceMappingURL=ensure-array.d.ts.map

package/dist/utils/array/ensure-array.js

@@ -1 +0,0 @@
-function n(r){return Array.isArray(r)?r:[r]}export{n as ensureArray};

package/dist/utils/array/group-by.d.ts

@@ -1,33 +0,0 @@
-/**
- * Groups elements of an array into an object based on a key function.
- *
- * Iterates over the input array and groups items by the string key returned by the key function.
- * Each key maps to an array of items that share that key.
- *
- * @template T The type of elements in the input array.
- * @param array - The array of items to group.
- * @param keyFn - A function that takes an item and returns a string key to group by.
- * @returns An object where each key is associated with an array of items that share that key.
- *
- * @example
- * ```ts
- * const data = [
- *   { type: 'fruit', name: 'apple' },
- *   { type: 'vegetable', name: 'carrot' },
- *   { type: 'fruit', name: 'banana' }
- * ];
- *
- * const grouped = groupBy(data, item => item.type);
- * // {
- * //   fruit: [
- * //     { type: 'fruit', name: 'apple' },
- * //     { type: 'fruit', name: 'banana' }
- * //   ],
- * //   vegetable: [
- * //     { type: 'vegetable', name: 'carrot' }
- * //   ]
- * // }
- * ```
- */
-export declare function groupBy<T>(array: T[], keyFn: (item: T) => string): Record<string, T[]>;
-//# sourceMappingURL=group-by.d.ts.map

package/dist/utils/array/group-by.js

@@ -1 +0,0 @@
-function s(r,e){const o={};for(const n of r){const t=e(n);o[t]||(o[t]=[]),o[t].push(n)}return o}export{s as groupBy};

package/dist/utils/array/partition.d.ts

@@ -1,22 +0,0 @@
-/**
- * Partitions a list into multiple groups based on a key returned by the given predicate function.
- *
- * For each item in the input list, the predicate is called to produce a grouping key.
- * Items with the same key are placed in the same group (array).
- * Items for which the predicate returns `undefined` are each placed into their own single-item group.
- *
- * @template T The type of items in the input list.
- * @param list - The array of items to partition.
- * @param predicate - A function that takes an item and returns a grouping key (string) or undefined.
- * @returns An array of groups. Each group is an array of items that share the same key.
- *          Items without a key are grouped individually.
- *
- * @example
- * ```ts
- * const data = ['apple', 'banana', 'apricot', 'blueberry', ''];
- * const result = partition(data, item => item[0] || undefined);
- * // result: [['apple', 'apricot'], ['banana', 'blueberry'], ['']]
- * ```
- */
-export declare function partition<T>(list: T[], predicate: (item: T) => string | undefined): T[][];
-//# sourceMappingURL=partition.d.ts.map

package/dist/utils/array/partition.js

@@ -1 +0,0 @@
-function i(e,s){const t={},c=[];for(const o of e){const n=s(o);if(!n){c.push([o]);continue}t[n]||(t[n]=[]),t[n].push(o)}return Object.values(t).concat(c)}export{i as partition};

package/dist/utils/array/split-array-async.d.ts

@@ -1,24 +0,0 @@
-/**
- * Splits an array into two arrays based on an asynchronous or synchronous predicate.
- *
- * Iterates through the input array, applying the given predicate function to each item.
- * If the predicate resolves to `true`, the item is placed in the first output array (positive).
- * If the predicate resolves to `false`, the item is placed in the second output array (negative).
- *
- * The predicate may return a boolean directly or a Promise that resolves to a boolean.
- *
- * @template T The type of items in the input array.
- * @param inputArray - The array to split.
- * @param predicate - A function that takes an item and returns a boolean or a Promise<boolean>.
- * @returns A Promise that resolves to a tuple: [items that matched, items that did not match].
- *
- * @example
- * ```ts
- * const numbers = [1, 2, 3, 4, 5];
- * const [even, odd] = await splitArrayAsync(numbers, async (n) => n % 2 === 0);
- * // even: [2, 4]
- * // odd: [1, 3, 5]
- * ```
- */
-export declare function splitArrayAsync<T>(inputArray: T[], predicate: (arrayItem: T) => boolean | Promise<boolean>): Promise<[T[], T[]]>;
-//# sourceMappingURL=split-array-async.d.ts.map

package/dist/utils/array/split-array-async.js

@@ -1 +0,0 @@
-async function e(a,n){const t=[],s=[];for(const r of a)await n(r)?t.push(r):s.push(r);return[t,s]}export{e as splitArrayAsync};

package/dist/utils/array/unique.d.ts

@@ -1,25 +0,0 @@
-/**
- * Removes duplicate items from an array, optionally using a custom key extractor.
- *
- * Iterates through the input array and returns a new array containing only the first
- * occurrence of each unique item. If a predicate function is provided, its return value
- * is used as the unique key for comparison instead of the item itself.
- *
- * @template T The type of the items in the input array.
- * @param array - The array to deduplicate.
- * @param predicate - Optional. A function that returns the value to use for uniqueness checks.
- * @returns A new array containing only unique items.
- *
- * @example
- * ```ts
- * unique([1, 2, 2, 3]); // [1, 2, 3]
- *
- * unique(
- *   [{ id: 1, name: 'A' }, { id: 1, name: 'B' }, { id: 2, name: 'C' }],
- *   item => item.id
- * );
- * // [{ id: 1, name: 'A' }, { id: 2, name: 'C' }]
- * ```
- */
-export declare function unique<T>(array: T[], predicate?: (item: T) => unknown): T[];
-//# sourceMappingURL=unique.d.ts.map

package/dist/utils/array/unique.js

@@ -1 +0,0 @@
-function c(u,n){const o=new Set,s=[];for(const t of u){const e=n?n(t):t;o.has(e)||s.push(t),o.add(e)}return s}export{c as unique};

package/dist/utils/auth/build-login-url.d.ts

@@ -1,22 +0,0 @@
-/**
- * Builds a login URL for a given identity provider (IdP).
- *
- * This function generates a login URL by either using a predefined mapping
- * or falling back to the default server login route. It appends query parameters such as
- * `idpId`, `localePrefix`, `redirectTo`, and any additional `extraParams`.
- *
- * @param idpId - The unique identifier of the identity provider.
- * @param localePrefix - The locale prefix (e.g., "en", "fr").
- * @param redirectTo - Optional redirect target after login.
- * @param extraParams - Additional query parameters to append to the login URL.
- *
- * @returns The constructed login URL as a string, or `undefined` if `idpId` is not provided.
- *
- * @example
- * ```ts
- * buildLoginUrl('okta-123', 'oidc', 'en', undefined, '/dashboard', { prompt: 'login' });
- * // "/api/idp/login?idpId=okta-123&localePrefix=en&redirectTo=%2Fdashboard&prompt=login"
- * ```
- */
-export declare function buildLoginUrl(idpId: string, localePrefix: string, redirectTo?: string, extraParams?: Record<string, string>): string | undefined;
-//# sourceMappingURL=build-login-url.d.ts.map

package/dist/utils/auth/build-login-url.js

@@ -1 +0,0 @@
-import{ServerRoutes as u}from"../../constants/api.js";import{appendQueryParams as m}from"../url/append-query-params.js";function s(r,e,o,n={}){if(!r)return;const t=u.IDP_LOGIN,i={idpId:r,localePrefix:e,redirectTo:o||"",...n};return m(t,i)}export{s as buildLoginUrl};

package/dist/utils/auth/is-auth-route-path.d.ts

@@ -1,11 +0,0 @@
-/**
- * Returns true if the pathname targets Realm reserved auth URLs (`/_auth/*`).
- *
- * @param pathname - Full pathname (e.g. from URL), optionally with path prefix.
- * @returns `true` if the first path segment, after `withoutPathPrefix`, is `_auth`.
- * @example
- * isAuthRoutePath('/_auth/idp-login'); // true
- * isAuthRoutePath('/es/_auth/idp-login'); // false
- */
-export declare function isAuthRoutePath(pathname: string): boolean;
-//# sourceMappingURL=is-auth-route-path.d.ts.map

package/dist/utils/auth/is-auth-route-path.js

@@ -1 +0,0 @@
-import{withoutPathPrefix as i}from"@redocly/theme/core/utils";import{AUTH_SEGMENT as r}from"../../constants/api.js";function n(e){const t=i(e);return(t.startsWith("/")?t:`/${t}`).split("/").filter(Boolean)}function f(e){return n(e)[0]===r}export{f as isAuthRoutePath};

package/dist/utils/collection/find-in-iterable.d.ts

@@ -1,19 +0,0 @@
-/**
- * Finds and returns the first element in an iterable that matches the given predicate.
- *
- * Iterates over the provided iterable and applies the predicate function to each item.
- * Returns the first item for which the predicate returns true. If no item matches,
- * it returns undefined.
- *
- * @param iter - The iterable to search through (e.g. an array, Set, or generator).
- * @param predicate - A function that tests each element. Should return true for the desired item.
- * @returns The first matching item, or undefined if none match.
- *
- * @example
- * ```ts
- * findInIterable([1, 2, 3, 4], (n) => n % 2 === 0);
- * // 2
- * ```
- */
-export declare function findInIterable<T>(iter: Iterable<T>, predicate: (item: T) => boolean | undefined): T | undefined;
-//# sourceMappingURL=find-in-iterable.d.ts.map

package/dist/utils/collection/find-in-iterable.js

@@ -1 +0,0 @@
-function f(t,e){for(const n of t)if(e(n))return n}export{f as findInIterable};

package/dist/utils/collection/set-map-value.d.ts

@@ -1,20 +0,0 @@
-/**
- * Sets a value for the given key in a Map and returns the value.
- *
- * This is useful when you want to chain map setting with inline assignment,
- * for example when building up a Map in a functional style.
- *
- * @param map - The Map to update.
- * @param key - The key to set.
- * @param value - The value to set for the key.
- * @returns The same value that was set.
- *
- * @example
- * ```ts
- * const m = new Map<string, number>();
- * const v = setMapValue(m, 'a', 42);
- * // v === 42, m.get('a') === 42
- * ```
- */
-export declare function setMapValue<K, T>(map: Map<K, T>, key: K, value: T): T;
-//# sourceMappingURL=set-map-value.d.ts.map

package/dist/utils/collection/set-map-value.js

@@ -1 +0,0 @@
-function r(e,n,t){return e.set(n,t),t}export{r as setMapValue};

package/dist/utils/conflict-resolvers.d.ts

@@ -1,6 +0,0 @@
-export declare class UniqueKeyResolver {
-    #private;
-    resolve(key: string): string;
-    reset(): void;
-}
-//# sourceMappingURL=conflict-resolvers.d.ts.map

package/dist/utils/conflict-resolvers.js

@@ -1 +0,0 @@
-class c{#e=new Map;resolve(s){let e=s;for(;this.#e.has(e);){const t=(this.#e.get(e)||0)+1;this.#e.set(e,t),e=s+"-"+t}return this.#e.set(e,0),e}reset(){this.#e.clear()}}export{c as UniqueKeyResolver};

package/dist/utils/env/is-browser.d.ts

@@ -1,18 +0,0 @@
-/**
- * Checks if the current environment is a browser.
- *
- * Returns `true` if the global `window` object exists and has the `HTMLElement` property,
- * which is a good indication that the code is running in a browser context.
- * Otherwise, returns `false` (e.g., Node.js or other non-browser environments).
- *
- * @param - This function takes no parameters.
- * @returns `true` if running in a browser environment; otherwise `false`.
- *
- * @example
- * ```ts
- * isBrowser();
- * // true (in browser), false (in Node.js)
- * ```
- */
-export declare function isBrowser(): boolean;
-//# sourceMappingURL=is-browser.d.ts.map

package/dist/utils/env/is-browser.js

@@ -1 +0,0 @@
-function n(){return typeof window<"u"&&"HTMLElement"in window}export{n as isBrowser};

package/dist/utils/guards/is-defined.d.ts

@@ -1,15 +0,0 @@
-/**
- * Type guard that checks if a value is not `undefined` or `null`.
- *
- * Useful for filtering out nullable values while preserving type safety.
- *
- * @template T The value type.
- * @param value The value to check.
- * @returns `true` if the value is neither `undefined` nor `null`; otherwise `false`.
- *
- * @example
- * const arr = [1, null, 2, undefined, 3];
- * const filtered = arr.filter(isDefined); // [1, 2, 3]
- */
-export declare function isDefined<T>(value: T | undefined | null): value is T;
-//# sourceMappingURL=is-defined.d.ts.map

package/dist/utils/guards/is-defined.js

@@ -1 +0,0 @@
-function e(n){return n!=null}export{e as isDefined};

package/dist/utils/guards/is-function.d.ts

@@ -1,17 +0,0 @@
-/**
- * Type guard that checks if a value is a function.
- *
- * Useful for safely calling or handling values that may or may not be functions.
- *§
- * @template T The return type of the function.
- * @param value The value to check.
- * @returns `true` if the value is a function; otherwise `false`.
- *
- * @example
- * const maybeFn: unknown = () => 42;
- * if (isFunction(maybeFn)) {
- *   const result = maybeFn(); // Safe to call
- * }
- */
-export declare function isFunction<T>(value: any): value is (...args: any[]) => T;
-//# sourceMappingURL=is-function.d.ts.map

package/dist/utils/guards/is-function.js

@@ -1 +0,0 @@
-function t(n){return typeof n=="function"}export{t as isFunction};

package/dist/utils/guards/is-object.d.ts

@@ -1,21 +0,0 @@
-/**
- * Determines whether a given value is a plain object.
- *
- * Checks that the value is of type 'object', not null,
- * and has either Object.prototype or null as its prototype.
- * This excludes arrays, functions, and other built-in objects.
- *
- * @param obj - The value to check.
- * @returns True if the value is a plain object, otherwise false.
- *
- * @example
- * ```ts
- * isObject({}); // true
- * isObject(Object.create(null)); // true
- * isObject([]); // false
- * isObject(null); // false
- * isObject(() => {}); // false
- * ```
- */
-export declare function isObject(obj: unknown): obj is object;
-//# sourceMappingURL=is-object.d.ts.map

package/dist/utils/guards/is-object.js

@@ -1 +0,0 @@
-function o(t){if(typeof t=="object"&&t!==null){if(typeof Object.getPrototypeOf=="function"){const e=Object.getPrototypeOf(t);return e===Object.prototype||e===null}return Object.prototype.toString.call(t)==="[object Object]"}return!1}export{o as isObject};

package/dist/utils/guards/is-plain-object.d.ts

@@ -1,19 +0,0 @@
-/**
- * Determines whether a value is a non-null, non-array object.
- *
- * Unlike `isObject`, class instances pass: the check guards shape
- * (keyed properties), not prototype purity.
- *
- * @param value - The value to check.
- * @returns True if the value is a non-null, non-array object.
- *
- * @example
- * ```ts
- * isPlainObject({}); // true
- * isPlainObject(new Date()); // true
- * isPlainObject([]); // false
- * isPlainObject(null); // false
- * ```
- */
-export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
-//# sourceMappingURL=is-plain-object.d.ts.map

package/dist/utils/guards/is-plain-object.js

@@ -1 +0,0 @@
-function t(r){return typeof r=="object"&&r!==null&&!Array.isArray(r)}export{t as isPlainObject};

package/dist/utils/guards/is-primitive.d.ts

@@ -1,14 +0,0 @@
-/**
- * Checks if the provided argument is a primitive of type string, boolean, or number.
- *
- * @param arg - The value to check.
- * @returns True if the value is a string, boolean, or number; otherwise false.
- *
- * @example
- * isPrimitive("hello"); // true
- * isPrimitive(42);      // true
- * isPrimitive(false);   // true
- * isPrimitive({});      // false
- */
-export declare function isPrimitive(arg: any): arg is string | boolean | number;
-//# sourceMappingURL=is-primitive.d.ts.map

package/dist/utils/guards/is-primitive.js

@@ -1 +0,0 @@
-function i(e){return["string","boolean","number"].includes(typeof e)}export{i as isPrimitive};

package/dist/utils/guards/is-truthy.d.ts

@@ -1,18 +0,0 @@
-type Falsy = undefined | null | false | '' | 0;
-/**
- * Type guard that checks if a value is *truthy*.
- *
- * This narrows out common falsy values: `undefined`, `null`, `false`, `''` (empty string), and `0`.
- * It’s especially useful for filtering arrays to remove falsy values with proper TypeScript narrowing.
- *
- * @template Truthy The inferred type of a truthy value.
- * @param value The value to check.
- * @returns `true` if the value is truthy; otherwise `false`.
- *
- * @example
- * const arr = [0, 1, '', 'hello', false, true];
- * const truthyValues = arr.filter(isTruthy); // [1, 'hello', true]
- */
-export declare function isTruthy<Truthy>(value: Truthy | Falsy): value is Truthy;
-export {};
-//# sourceMappingURL=is-truthy.d.ts.map

package/dist/utils/guards/is-truthy.js

@@ -1 +0,0 @@
-function t(r){return!!r}export{t as isTruthy};

package/dist/utils/l10n/build-i18n-config.d.ts

@@ -1,24 +0,0 @@
-import type { InitOptions } from 'i18next';
-import type { GlobalData } from '../../types/index.js';
-/**
- * Builds the i18next init config shared by the client runtime (`initL10n`) and the
- * build-time translate used in `renderForLlms` (`createBuildTranslate`), so both
- * resolve translations identically: same default-translation merge, same locale
- * fallback chain.
- *
- * @param l10n - The project's l10n data (`defaultLocale`, configured `locales`, and
- * `translations` overrides), or `undefined` for a project with no l10n config.
- * @param locale - The `lng` to set on the resulting config (the instance's `resources`
- * still cover every configured locale, so a fixed translator for any other locale can
- * still be derived from the same config via `i18next.getFixedT(otherLocale)`).
- * @returns An i18next `InitOptions` object with merged default + project translations
- * and a `code → langPart → defaultLocale` fallback chain.
- *
- * @example
- * ```ts
- * const config = await buildI18nConfig(l10n, 'ja');
- * await i18next.init(config);
- * ```
- */
-export declare function buildI18nConfig(l10n: GlobalData['l10n'], locale: InitOptions['lng']): Promise<InitOptions>;
-//# sourceMappingURL=build-i18n-config.d.ts.map

package/dist/utils/l10n/build-i18n-config.js

@@ -1 +0,0 @@
-import{DEFAULT_LOCALE_PLACEHOLDER as u}from"../../constants/common.js";import{defaultTranslationImports as c}from"../../constants/l10n/default-translations.js";async function L(s,r){const a=s?.defaultLocale||u,e=s?.translations??{},i=s?.locales?[...new Set(s.locales.flatMap(t=>[t.code,t.code.split("-")[0]]))]:[a],l={};for(const t of i){const n=await c[t]?.()||{};l[t]={translation:{...n,...e[t]?.translation}}}return{load:"currentOnly",lng:r,nonExplicitSupportedLngs:!0,fallbackLng:t=>{if(!t)return[a];const n=t.split("-")[0];if(t===a)return n!==t?[n,a]:[a];const o=[t];return n!==t&&o.push(n),o.push(a),o},interpolation:{escapeValue:!1},debug:!1,resources:{...l}}}export{L as buildI18nConfig};

package/dist/utils/l10n/create-translate.d.ts

@@ -1,19 +0,0 @@
-import type { TFunction, TOptions } from '@redocly/theme/core/types';
-/**
- * Wraps a raw i18next `t`-like function (`useTranslate`'s `i18next.t`, or a
- * build-time `instance.getFixedT(locale)`) with the shared value/defaultValue/options
- * resolution used across the client and build-time translate paths.
- *
- * @param rawT - The underlying i18next translate function to resolve keys against.
- * @returns A `TFunction` that resolves `value` via `rawT`, falling back to
- * `defaultValue` (when passed as the second argument or via `options.defaultValue`)
- * and then to `value` itself when the key is untranslated.
- *
- * @example
- * ```ts
- * const translate = createTranslate(i18next.t);
- * translate('greeting.hello', 'Hello'); // translated string, or 'Hello' if missing
- * ```
- */
-export declare function createTranslate(rawT: (key: string, opts?: TOptions) => string): TFunction;
-//# sourceMappingURL=create-translate.d.ts.map

package/dist/utils/l10n/create-translate.js

@@ -1 +0,0 @@
-function u(r){return(n,t)=>{const e=typeof t=="string"?t:void 0,f=e?void 0:t;return n?r(n,{defaultValue:e,...f})||e||n||"":e??""}}export{u as createTranslate};

package/dist/utils/object/allowlist-object.d.ts

@@ -1,16 +0,0 @@
-/**
- * Allows a subset of keys from an object.
- *
- * @param object - The object to allow.
- * @param allowedKeys - The keys to allow.
- * @returns A new object with the allowed keys.
- *
- * @example
- * ```ts
- * const object = { a: 1, b: 2, c: 3 };
- * const allowedObject = allowlistObject(object, ['a', 'c']);
- * // { a: 1, c: 3 }
- * ```
- */
-export declare function allowlistObject<T extends Record<string, unknown>, K extends keyof T>(object: T, allowedKeys: readonly K[]): Pick<T, K>;
-//# sourceMappingURL=allowlist-object.d.ts.map

package/dist/utils/object/allowlist-object.js

@@ -1 +0,0 @@
-function i(e,t){return Object.fromEntries(Object.entries(e).filter(([r])=>t.includes(r)))}export{i as allowlistObject};

package/dist/utils/object/deep-equal.d.ts

@@ -1,32 +0,0 @@
-/**
- * Performs a deep equality comparison between two values.
- *
- * Recursively compares values, handling:
- * - Primitives (strict equality)
- * - Arrays (element-by-element comparison)
- * - Map (size and key-value comparison)
- * - Set (size and entry comparison)
- * - TypedArrays (ArrayBuffer views like Int8Array, Uint8Array, etc.)
- * - RegExp (source and flags comparison)
- * - Objects with custom valueOf/toString methods
- * - Plain objects (key-by-key comparison)
- * - NaN values (considered equal to each other)
- *
- * @param a - The first value to compare.
- * @param b - The second value to compare.
- * @returns True if the values are deeply equal, otherwise false.
- *
- * @example
- * ```ts
- * deepEqual(1, 1); // true
- * deepEqual({ a: 1 }, { a: 1 }); // true
- * deepEqual([1, 2], [1, 2]); // true
- * deepEqual({ a: { b: 1 } }, { a: { b: 1 } }); // true
- * deepEqual(NaN, NaN); // true
- * deepEqual(new Map([['a', 1]]), new Map([['a', 1]])); // true
- * deepEqual(new Set([1, 2]), new Set([1, 2])); // true
- * deepEqual({ a: 1 }, { a: 2 }); // false
- * ```
- */
-export declare function deepEqual(a: unknown, b: unknown): boolean;
-//# sourceMappingURL=deep-equal.d.ts.map

package/dist/utils/object/deep-equal.js

@@ -1 +0,0 @@
-function u(e,t){if(e===t)return!0;if(e&&t&&typeof e=="object"&&typeof t=="object"){if(e.constructor!==t.constructor)return!1;if(Array.isArray(e)&&Array.isArray(t)){const r=e.length;if(r!==t.length)return!1;for(let n=r;n--!==0;)if(!u(e[n],t[n]))return!1;return!0}if(e instanceof Map&&t instanceof Map){if(e.size!==t.size)return!1;for(const[r]of e.entries())if(!t.has(r))return!1;for(const[r,n]of e.entries())if(!u(n,t.get(r)))return!1;return!0}if(e instanceof Set&&t instanceof Set){if(e.size!==t.size)return!1;for(const r of e.entries())if(!t.has(r[0]))return!1;return!0}if(ArrayBuffer.isView(e)&&ArrayBuffer.isView(t)){const r=e,n=t,c=r.length;if(c!==n.length)return!1;for(let i=c;i--!==0;)if(r[i]!==n[i])return!1;return!0}if(e instanceof RegExp&&t instanceof RegExp)return e.source===t.source&&e.flags===t.flags;if(e.valueOf!==Object.prototype.valueOf)return e.valueOf()===t.valueOf();if(e.toString!==Object.prototype.toString)return e.toString()===t.toString();const l=e,f=t,s=Object.keys(l),o=s.length;if(o!==Object.keys(f).length)return!1;for(let r=o;r--!==0;)if(!Object.prototype.hasOwnProperty.call(f,s[r]))return!1;for(let r=o;r--!==0;){const n=s[r];if(!u(l[n],f[n]))return!1}return!0}return e!==e&&t!==t}export{u as deepEqual};

package/dist/utils/object/deep-merge.d.ts

@@ -1,39 +0,0 @@
-/**
- * Converts a union type to an intersection type.
- *
- * This utility type is used internally to represent the result of merging multiple
- * object types into a single type containing all their properties.
- *
- * Example:
- * ```ts
- * type A = { a: number };
- * type B = { b: string };
- * type C = TUnionToIntersection<A | B>; // { a: number } & { b: string }
- * ```
- */
-type TUnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-/**
- * Deeply merges multiple plain objects into a single object.
- *
- * For each property:
- * - If both source and target properties are plain objects, they are merged recursively.
- * - If both are arrays, the source array overwrites the target array.
- * - Otherwise, the source property overwrites the target property.
- *
- * This function skips dangerous keys like `__proto__`, `constructor`, and `prototype`
- * to prevent prototype pollution.
- *
- * @param objects - Two or more plain objects to merge.
- * @returns A new object that is the deep merge of all input objects.
- *
- * @example
- * ```ts
- * const a = { x: 1, nested: { y: 2 } };
- * const b = { nested: { z: 3 }, arr: [1, 2] };
- * const merged = deepMerge(a, b);
- * // { x: 1, nested: { y: 2, z: 3 }, arr: [1, 2] }
- * ```
- */
-export declare function deepMerge<T extends object[]>(...objects: T): TUnionToIntersection<T[number]>;
-export {};
-//# sourceMappingURL=deep-merge.d.ts.map

package/dist/utils/object/deep-merge.js

@@ -1 +0,0 @@
-import{isObject as f}from"../guards/is-object.js";function p(...y){return y.reduce((i,e={})=>{for(const o of Object.keys(e))["__proto__","constructor","prototype"].includes(o)||(Array.isArray(i[o])&&Array.isArray(e[o])?i[o]=e[o]:f(i[o])&&f(e[o])?i[o]=p(i[o],e[o]):i[o]=e[o]);return i},{})}export{p as deepMerge};

package/dist/utils/object/get-value-deep.d.ts

@@ -1,22 +0,0 @@
-type GetValueDeep<T> = {
-    error: null;
-    value: T;
-} | {
-    error: Error;
-    value: null;
-};
-/**
- * Retrieves a value from a nested object structure using an array of property names as a path.
- * Returns an object containing either the result or any error encountered during traversal.
- *
- * @param {any} obj - The object to traverse
- * @param {string[]} path - Array of property names defining the path to the desired value
- * @returns {GetValueDeep} - Object containing the result or error
- *
- * @example
- * const obj = { user: { address: { city: 'New York' } } };
- * getValueDeep(obj, ['user', 'address', 'city']); // { error: null, value: 'New York' }
- */
-export declare function getValueDeep<T>(obj: any, path: string[]): GetValueDeep<T>;
-export {};
-//# sourceMappingURL=get-value-deep.d.ts.map

package/dist/utils/object/get-value-deep.js

@@ -1 +0,0 @@
-function u(t,l){let r=t;try{for(let e=0;e<l.length;e++)r=r[l[e]]}catch(e){return{error:e,value:null}}return{error:null,value:r}}export{u as getValueDeep};