@stryke/helpers 0.1.0

package/dist/deep-clone.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Creates a deep clone of the given object.
+ *
+ * @param obj - The object to clone.
+ * @returns A deep clone of the given object.
+ *
+ * @example
+ * ```typescript
+ * // Clone a primitive values
+ * const num = 29;
+ * const clonedNum = clone(num);
+ * console.log(clonedNum); // 29
+ * console.log(clonedNum === num) ; // true
+ *
+ * // Clone an array
+ * const arr = [1, 2, 3];
+ * const clonedArr = clone(arr);
+ * console.log(clonedArr); // [1, 2, 3]
+ * console.log(clonedArr === arr); // false
+ *
+ * // Clone an array with nested objects
+ * const arr = [1, { a: 1 }, [1, 2, 3]];
+ * const clonedArr = clone(arr);
+ * arr[1].a = 2;
+ * console.log(arr); // [2, { a: 2 }, [1, 2, 3]]
+ * console.log(clonedArr); // [1, { a: 1 }, [1, 2, 3]]
+ * console.log(clonedArr === arr); // false
+ *
+ * // Clone an object
+ * const obj = { a: 1, b: 'es-toolkit', c: [1, 2, 3] };
+ * const clonedObj = clone(obj);
+ * console.log(clonedObj); // { a: 1, b: 'es-toolkit', c: [1, 2, 3] }
+ * console.log(clonedObj === obj); // false
+ *
+ *
+ * // Clone an object with nested objects
+ * const obj = { a: 1, b: { c: 1 } };
+ * const clonedObj = clone(obj);
+ * obj.b.c = 2;
+ * console.log(obj); // { a: 1, b: { c: 2 } }
+ * console.log(clonedObj); // { a: 1, b: { c: 1 } }
+ * console.log(clonedObj === obj); // false
+ * ```
+ */
+export declare function deepClone<T>(obj: T): Resolved<T>;
+export type Resolved<T> = Equal<T, ResolvedMain<T>> extends true ? T : ResolvedMain<T>;
+type Equal<X, Y> = X extends Y ? (Y extends X ? true : false) : false;
+type ResolvedMain<T> = T extends [never] ? never : ValueOf<T> extends boolean | number | bigint | string ? ValueOf<T> : T extends (...args: any[]) => any ? never : T extends object ? ResolvedObject<T> : ValueOf<T>;
+type ResolvedObject<T extends object> = T extends (infer U)[] ? IsTuple<T> extends true ? ResolvedTuple<T> : ResolvedMain<U>[] : T extends Set<infer U> ? Set<ResolvedMain<U>> : T extends Map<infer K, infer V> ? Map<ResolvedMain<K>, ResolvedMain<V>> : T extends WeakSet<any> | WeakMap<any, any> ? never : T extends Date | Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | BigUint64Array | Int8Array | Int16Array | Int32Array | BigInt64Array | Float32Array | Float64Array | ArrayBuffer | SharedArrayBuffer | DataView | Blob | File ? T : {
+    [P in keyof T]: ResolvedMain<T[P]>;
+};
+type ResolvedTuple<T extends readonly any[]> = T extends [] ? [] : T extends [infer F] ? [ResolvedMain<F>] : T extends [infer F, ...infer Rest extends readonly any[]] ? [ResolvedMain<F>, ...ResolvedTuple<Rest>] : T extends [(infer F)?] ? [ResolvedMain<F>?] : T extends [(infer F)?, ...infer Rest extends readonly any[]] ? [ResolvedMain<F>?, ...ResolvedTuple<Rest>] : [];
+type IsTuple<T extends readonly any[] | {
+    length: number;
+}> = [T] extends [
+    never
+] ? false : T extends readonly any[] ? number extends T["length"] ? false : true : false;
+type ValueOf<Instance> = IsValueOf<Instance, boolean> extends true ? boolean : IsValueOf<Instance, number> extends true ? number : IsValueOf<Instance, string> extends true ? string : Instance;
+type IsValueOf<Instance, O extends IValueOf<any>> = Instance extends O ? O extends IValueOf<infer Primitive> ? Instance extends Primitive ? false : true : false : false;
+interface IValueOf<T> {
+    valueOf(): T;
+}
+export {};

package/dist/deep-clone.mjs

@@ -0,0 +1 @@
+import{isPrimitive as l,isTypedArray as i}from"@stryke/types";export function deepClone(e){if(l(e))return e;if(Array.isArray(e))return e.map(n=>deepClone(n));if(e instanceof Date)return new Date(e.getTime());if(e instanceof RegExp)return new RegExp(e.source,e.flags);if(e instanceof Map){const n=new Map;for(const[t,s]of e.entries())n.set(t,deepClone(s));return n}if(e instanceof Set){const n=new Set;for(const t of e.values())n.add(deepClone(t));return n}if(i(e)){const n=new(Object.getPrototypeOf(e)).constructor(e.length);for(const[t,s]of e.entries())n[t]=deepClone(s);return n}if(e instanceof ArrayBuffer||typeof SharedArrayBuffer<"u"&&e instanceof SharedArrayBuffer)return[...e];if(e instanceof DataView){const n=new DataView([...e.buffer]);return r(e,n),n}if(typeof File<"u"&&e instanceof File){const n=new File([e],e.name,{type:e.type});return r(e,n),n}if(e instanceof Blob){const n=new Blob([e],{type:e.type});return r(e,n),n}if(e instanceof Error){const n=new e.constructor;return n.message=e.message,n.name=e.name,n.stack=e.stack,n.cause=e.cause,r(e,n),n}if(typeof e=="object"&&e!==null){const n={};return r(e,n),n}return e}function r(e,n){const t=Object.keys(e);for(const s of t){const a=Object.getOwnPropertyDescriptor(e,s);(a?.writable||a?.set)&&(n[s]=deepClone(e[s]))}}

package/dist/deep-merge.cjs

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deepMerge = void 0;
+var _types = require("@stryke/types");
+const b = e => Array.isArray(e) ? [] : {},
+  s = (e, r) => r.clone !== !1 && r.isMergeableObject(e) ? deepMerge(b(e), e, r) : e,
+  l = (e, r, n) => [...e, ...r].map(t => s(t, n)),
+  f = (e, r) => {
+    if (!r.customMerge) return deepMerge;
+    const n = r.customMerge(e);
+    return (0, _types.isFunction)(n) ? n : deepMerge;
+  },
+  y = e => [...Object.keys(e), ...(Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(e).filter(r => Object.propertyIsEnumerable.call(e, r)) : [])],
+  u = (e, r, n) => {
+    const t = {};
+    if (n.isMergeableObject(e)) for (const a of y(e)) t[a] = s(e[a], n);
+    for (const a of y(r)) t[a] = (0, _types.propertyUnsafe)(e, a) && n.isMergeableObject(r[a]) ? f(a, n)(e[a], r[a], n) : s(r[a], n);
+    return t;
+  };
+const deepMerge = (e, r, n = {}) => {
+  if (!e || !r) return e || r;
+  const t = n || {};
+  t.arrayMerge = n.arrayMerge || l, t.isMergeableObject = t.isMergeableObject || _types.isMergeableObject, t.cloneUnlessOtherwiseSpecified = s;
+  const a = Array.isArray(r),
+    c = Array.isArray(e);
+  return a === c ? a ? t.arrayMerge(e, r, t) : u(e, r, t) : s(r, t);
+};
+exports.deepMerge = deepMerge;
+deepMerge.all = function (r, n) {
+  if (!Array.isArray(r)) throw new TypeError("first argument should be an array");
+  return r.reduce((t, a) => deepMerge(t, a, n), {});
+};

package/dist/deep-merge.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Deep merge two objects
+ *
+ * @param target - The target object
+ * @param source - The source object
+ * @param options - The options object
+ * @returns The merged object
+ */
+export declare const deepMerge: {
+    <X = any, Y = any, Z = X & Y>(target: X, source: Y, options?: any): Z;
+    all(array: any[], options?: any): any;
+};

package/dist/deep-merge.mjs

@@ -0,0 +1 @@
+import{isFunction as i,isMergeableObject as o,propertyUnsafe as g}from"@stryke/types";const b=e=>Array.isArray(e)?[]:{},s=(e,r)=>r.clone!==!1&&r.isMergeableObject(e)?deepMerge(b(e),e,r):e,l=(e,r,n)=>[...e,...r].map(t=>s(t,n)),f=(e,r)=>{if(!r.customMerge)return deepMerge;const n=r.customMerge(e);return i(n)?n:deepMerge},y=e=>[...Object.keys(e),...Object.getOwnPropertySymbols?Object.getOwnPropertySymbols(e).filter(r=>Object.propertyIsEnumerable.call(e,r)):[]],u=(e,r,n)=>{const t={};if(n.isMergeableObject(e))for(const a of y(e))t[a]=s(e[a],n);for(const a of y(r))t[a]=g(e,a)&&n.isMergeableObject(r[a])?f(a,n)(e[a],r[a],n):s(r[a],n);return t};export const deepMerge=(e,r,n={})=>{if(!e||!r)return e||r;const t=n||{};t.arrayMerge=n.arrayMerge||l,t.isMergeableObject=t.isMergeableObject||o,t.cloneUnlessOtherwiseSpecified=s;const a=Array.isArray(r),c=Array.isArray(e);return a===c?a?t.arrayMerge(e,r,t):u(e,r,t):s(r,t)};deepMerge.all=function(r,n){if(!Array.isArray(r))throw new TypeError("first argument should be an array");return r.reduce((t,a)=>deepMerge(t,a,n),{})};

package/dist/delay.cjs

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.delay = delay;
+exports.sleep = sleep;
+var _errors = require("./errors.cjs");
+function delay(r, {
+  signal: e
+} = {}) {
+  return new Promise((t, n) => {
+    const o = () => {
+        n(new _errors.AbortError());
+      },
+      i = () => {
+        clearTimeout(a), o();
+      };
+    if (e?.aborted) return o();
+    const a = setTimeout(t, r);
+    e?.addEventListener("abort", i, {
+      once: !0
+    });
+  });
+}
+function sleep(r, e) {
+  return delay(r, e);
+}

package/dist/delay.d.ts

@@ -0,0 +1,72 @@
+interface DelayOptions {
+    signal?: AbortSignal;
+}
+/**
+ * Delays the execution of code for a specified number of milliseconds.
+ *
+ * This function returns a Promise that resolves after the specified delay, allowing you to use it
+ * with async/await to pause execution.
+ *
+ * @example
+ * ```typescript
+ * async function foo() {
+ *   console.log('Start');
+ *   await delay(1000); // Delays execution for 1 second
+ *   console.log('End');
+ * }
+ *
+ * foo();
+ *
+ * // With AbortSignal
+ * const controller = new AbortController();
+ * const { signal } = controller;
+ *
+ * setTimeout(() => controller.abort(), 50); // Will cancel the delay after 50ms
+ * try {
+ *   await delay(100, { signal });
+ *  } catch (error) {
+ *   console.error(error); // Will log 'AbortError'
+ *  }
+ * }
+ * ```
+ *
+ * @param ms - The number of milliseconds to delay.
+ * @param options - The options object.
+ * @returns A Promise that resolves after the specified delay.
+ */
+export declare function delay(ms: number, { signal }?: DelayOptions): Promise<void>;
+/**
+ * Delays the execution of code for a specified number of milliseconds.
+ *
+ * This function returns a Promise that resolves after the specified delay, allowing you to use it
+ * with async/await to pause execution.
+ *
+ * @example
+ * ```typescript
+ * async function foo() {
+ *   console.log('Start');
+ *   await sleep(1000); // Delays execution for 1 second
+ *   console.log('End');
+ * }
+ *
+ * foo();
+ *
+ * // With AbortSignal
+ * const controller = new AbortController();
+ * const { signal } = controller;
+ *
+ * setTimeout(() => controller.abort(), 50); // Will cancel the delay after 50ms
+ * try {
+ *   await sleep(100, { signal });
+ *  } catch (error) {
+ *   console.error(error); // Will log 'AbortError'
+ *  }
+ * }
+ * ```
+ *
+ * @param ms - The number of milliseconds to sleep.
+ * @param options - The options object.
+ * @returns A Promise that resolves after the specified sleep.
+ */
+export declare function sleep(ms: number, options?: DelayOptions): Promise<void>;
+export {};

package/dist/delay.mjs

@@ -0,0 +1 @@
+import{AbortError as s}from"./errors";export function delay(r,{signal:e}={}){return new Promise((t,n)=>{const o=()=>{n(new s)},i=()=>{clearTimeout(a),o()};if(e?.aborted)return o();const a=setTimeout(t,r);e?.addEventListener("abort",i,{once:!0})})}export function sleep(r,e){return delay(r,e)}

package/dist/errors.cjs

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TimeoutError = exports.AbortError = void 0;
+class AbortError extends Error {
+  constructor(r = "The operation was aborted") {
+    super(r), this.name = "AbortError";
+  }
+}
+exports.AbortError = AbortError;
+class TimeoutError extends Error {
+  constructor(r = "The operation was timed out") {
+    super(r), this.name = "TimeoutError";
+  }
+}
+exports.TimeoutError = TimeoutError;

package/dist/errors.d.ts

@@ -0,0 +1,12 @@
+/**
+ * An error class representing an aborted operation.
+ */
+export declare class AbortError extends Error {
+    constructor(message?: string);
+}
+/**
+ * An error class representing an timeout operation.
+ */
+export declare class TimeoutError extends Error {
+    constructor(message?: string);
+}

package/dist/errors.mjs

@@ -0,0 +1 @@
+export class AbortError extends Error{constructor(r="The operation was aborted"){super(r),this.name="AbortError"}}export class TimeoutError extends Error{constructor(r="The operation was timed out"){super(r),this.name="TimeoutError"}}

package/dist/flatten-object.cjs

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.flattenObject = flattenObject;
+var _types = require("@stryke/types");
+function flattenObject(t) {
+  return T(t);
+}
+function T(t, s = "") {
+  const n = {},
+    O = Object.keys(t);
+  for (const c of O) {
+    const e = t[c],
+      y = s ? `${s}.${c}` : c;
+    if ((0, _types.isPlainObject)(e) && Object.keys(e).length > 0) Object.assign(n, T(e, y));else if (Array.isArray(e)) for (const [a, b] of e.entries()) n[`${y}.${a}`] = b;else n[y] = e;
+  }
+  return n;
+}

package/dist/flatten-object.d.ts

@@ -0,0 +1,33 @@
+import { type DeepKey, type DeepValue } from "@stryke/types";
+/**
+ * Flattens a nested object into a single level object with dot-separated keys.
+ *
+ * @example
+ * ```typescript
+ * const nestedObject = {
+ *   a: {
+ *     b: {
+ *       c: 1
+ *     }
+ *   },
+ *   d: [2, 3]
+ * };
+ *
+ * const flattened = flattenObject(nestedObject);
+ * console.log(flattened);
+ * // Output:
+ * // {
+ * //   'a.b.c': 1,
+ * //   'd.0': 2,
+ * //   'd.1': 3
+ * // }
+ * ```
+ *
+ * @param object - The object to flatten.
+ * @returns - The flattened object.
+ */
+export declare function flattenObject<TObject extends Record<string, any> = Record<string, any>, TDeepKeyObject extends {
+    [TKey in DeepKey<TObject>]: DeepValue<TObject, TKey>;
+} = {
+    [TKey in DeepKey<TObject>]: DeepValue<TObject, TKey>;
+}>(object: TObject): TDeepKeyObject;

package/dist/flatten-object.mjs

@@ -0,0 +1 @@
+import{isPlainObject as j}from"@stryke/types";export function flattenObject(t){return T(t)}function T(t,s=""){const n={},O=Object.keys(t);for(const c of O){const e=t[c],y=s?`${s}.${c}`:c;if(j(e)&&Object.keys(e).length>0)Object.assign(n,T(e,y));else if(Array.isArray(e))for(const[a,b]of e.entries())n[`${y}.${a}`]=b;else n[y]=e}return n}

package/dist/get-field.cjs

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getField = getField;
+var _types = require("@stryke/types");
+var _toPath = require("./to-path.cjs");
+function getField(t, e, d) {
+  if (t === null) return d;
+  switch (typeof e) {
+    case "string":
+      {
+        const n = t[e];
+        return n === void 0 ? (0, _types.isDeepKey)(e) ? getField(t, (0, _toPath.toPath)(e), d) : d : n;
+      }
+    case "number":
+    case "symbol":
+      {
+        (0, _types.isNumber)(e) && (e = (0, _types.toStringKey)(e));
+        const n = Array.isArray(e) ? void 0 : t[e];
+        return n === void 0 ? d : n;
+      }
+    default:
+      {
+        if (Array.isArray(e)) return u(t, e, d);
+        e = Object.is(e?.valueOf(), -0) ? "-0" : String(e);
+        const n = t[e];
+        return n === void 0 ? d : n;
+      }
+  }
+}
+function u(t, e, d) {
+  if (e.length === 0) return d;
+  let n = t;
+  for (const i of e) {
+    if (n === null) return d;
+    n = n[i];
+  }
+  return n === void 0 ? d : n;
+}

package/dist/get-field.d.ts

@@ -0,0 +1,251 @@
+/**
+ * See the definition of `@types/lodash`.
+ */
+type GetIndexedField<T, K> = K extends keyof T ? T[K] : K extends `${number}` ? "length" extends keyof T ? number extends T["length"] ? number extends keyof T ? T[number] : undefined : undefined : undefined : undefined;
+type FieldWithPossiblyUndefined<T, Key> = GetField<Exclude<T, undefined>, Key> | Extract<T, undefined>;
+type IndexedFieldWithPossiblyUndefined<T, Key> = GetIndexedField<Exclude<T, undefined>, Key> | Extract<T, undefined>;
+export type GetField<T, P> = P extends `${infer Left}.${infer Right}` ? Left extends keyof Exclude<T, undefined> ? FieldWithPossiblyUndefined<Exclude<T, undefined>[Left], Right> | Extract<T, undefined> : Left extends `${infer FieldKey}[${infer IndexKey}]` ? FieldKey extends keyof T ? FieldWithPossiblyUndefined<IndexedFieldWithPossiblyUndefined<T[FieldKey], IndexKey>, Right> : undefined : undefined : P extends keyof T ? T[P] : P extends `${infer FieldKey}[${infer IndexKey}]` ? FieldKey extends keyof T ? IndexedFieldWithPossiblyUndefined<T[FieldKey], IndexKey> : undefined : IndexedFieldWithPossiblyUndefined<T, P>;
+/**
+ * Retrieves the value at a given path from an object. If the resolved value is undefined, the defaultValue is returned instead.
+ *
+ * @template T - The type of the object.
+ * @template K - The type of the key in the object.
+ * @template D - The type of the default value.
+ *
+ * @param {T} object - The object to query.
+ * @param {K | [K]} path - The path of the property to get.
+ * @returns {T[K]} - Returns the resolved value.
+ */
+export declare function getField<T extends object, K extends keyof T>(object: T, path: K | readonly [K]): T[K];
+/**
+ * Retrieves the value at a given path from an object. If the resolved value is undefined, the defaultValue is returned instead.
+ *
+ * @template T - The type of the object.
+ * @template K - The type of the key in the object.
+ *
+ * @param {T | null | undefined} object - The object to query.
+ * @param {K | [K]} path - The path of the property to get.
+ * @returns {T[K] | undefined} - Returns the resolved value.
+ */
+export declare function getField<T extends object, K extends keyof T>(object: T | null | undefined, path: K | readonly [K]): T[K] | undefined;
+/**
+ * Retrieves the value at a given path from an object. If the resolved value is undefined, the defaultValue is returned instead.
+ *
+ * @template T - The type of the object.
+ * @template K - The type of the key in the object.
+ * @template D - The type of the default value.
+ *
+ * @param {T | null | undefined} object - The object to query.
+ * @param {K | [K]} path - The path of the property to get.
+ * @param {D} defaultValue - The value returned if the resolved value is undefined.
+ * @returns {Exclude<T[K], undefined> | D} - Returns the resolved value.
+ */
+export declare function getField<T extends object, K extends keyof T, D>(object: T | null | undefined, path: K | readonly [K], defaultValue: D): Exclude<T[K], undefined> | D;
+/**
+ * Retrieves the value at a given path from an object. If the resolved value is undefined, the defaultValue is returned instead.
+ *
+ * @template T - The type of the object.
+ * @template K1 - The type of the first key in the object.
+ * @template K2 - The type of the second key in the object.
+ *
+ * @param {T} object - The object to query.
+ * @param {[K1, K2]} path - The path of the property to get.
+ * @returns {T[K1][K2]} - Returns the resolved value.
+ */
+export declare function getField<T extends object, K1 extends keyof T, K2 extends keyof T[K1]>(object: T, path: readonly [K1, K2]): T[K1][K2];
+/**
+ * Retrieves the value at a given path from an object. If the resolved value is undefined, the defaultValue is returned instead.
+ *
+ * @template T - The type of the object.
+ * @template K1 - The type of the first key in the object.
+ * @template K2 - The type of the second key in the object.
+ *
+ * @param {T | null | undefined} object - The object to query.
+ * @param {[K1, K2]} path - The path of the property to get.
+ * @returns {T[K1][K2] | undefined} - Returns the resolved value.
+ */
+export declare function getField<T extends object, K1 extends keyof T, K2 extends keyof T[K1]>(object: T | null | undefined, path: readonly [K1, K2]): T[K1][K2] | undefined;
+/**
+ * Retrieves the value at a given path from an object. If the resolved value is undefined, the defaultValue is returned instead.
+ *
+ * @template T - The type of the object.
+ * @template K1 - The type of the first key in the object.
+ * @template K2 - The type of the second key in the object.
+ * @template D - The type of the default value.
+ *
+ * @param {T | null | undefined} object - The object to query.
+ * @param {[K1, K2]} path - The path of the property to get.
+ * @param {D} defaultValue - The value returned if the resolved value is undefined.
+ * @returns {Exclude<T[K1][K2], undefined> | D} - Returns the resolved value.
+ */
+export declare function getField<T extends object, K1 extends keyof T, K2 extends keyof T[K1], D>(object: T | null | undefined, path: readonly [K1, K2], defaultValue: D): Exclude<T[K1][K2], undefined> | D;
+/**
+ * Retrieves the value at a given path from an object. If the resolved value is undefined, the defaultValue is returned instead.
+ *
+ * @template T - The type of the object.
+ * @template K1 - The type of the first key in the object.
+ * @template K2 - The type of the second key in the object.
+ * @template K3 - The type of the third key in the object.
+ *
+ * @param {T} object - The object to query.
+ * @param {[K1, K2, K3]} path - The path of the property to get.
+ * @returns {T[K1][K2][K3]} - Returns the resolved value.
+ */
+export declare function getField<T extends object, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2]>(object: T, path: readonly [K1, K2, K3]): T[K1][K2][K3];
+/**
+ * Retrieves the value at a given path from an object. If the resolved value is undefined, the defaultValue is returned instead.
+ *
+ * @template T - The type of the object.
+ * @template K1 - The type of the first key in the object.
+ * @template K2 - The type of the second key in the object.
+ * @template K3 - The type of the third key in the object.
+ *
+ * @param {T | null | undefined} object - The object to query.
+ * @param {[K1, K2, K3]} path - The path of the property to get.
+ * @returns {T[K1][K2][K3] | undefined} - Returns the resolved value.
+ */
+export declare function getField<T extends object, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2]>(object: T | null | undefined, path: readonly [K1, K2, K3]): T[K1][K2][K3] | undefined;
+/**
+ * Retrieves the value at a given path from an object. If the resolved value is undefined, the defaultValue is returned instead.
+ *
+ * @template T - The type of the object.
+ * @template K1 - The type of the first key in the object.
+ * @template K2 - The type of the second key in the object.
+ * @template K3 - The type of the third key in the object.
+ * @template D - The type of the default value.
+ *
+ * @param {T | null | undefined} object - The object to query.
+ * @param {[K1, K2, K3]} path - The path of the property to get.
+ * @param {D} defaultValue - The value returned if the resolved value is undefined.
+ * @returns {Exclude<T[K1][K2][K3], undefined> | D} - Returns the resolved value.
+ */
+export declare function getField<T extends object, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2], D>(object: T | null | undefined, path: readonly [K1, K2, K3], defaultValue: D): Exclude<T[K1][K2][K3], undefined> | D;
+/**
+ * Retrieves the value at a given path from an object. If the resolved value is undefined, the defaultValue is returned instead.
+ *
+ * @template T - The type of the object.
+ * @template K1 - The type of the first key in the object.
+ * @template K2 - The type of the second key in the object.
+ * @template K3 - The type of the third key in the object.
+ * @template K4 - The type of the fourth key in the object.
+ *
+ * @param {T} object - The object to query.
+ * @param {[K1, K2, K3, K4]} path - The path of the property to get.
+ * @returns {T[K1][K2][K3][K4]} - Returns the resolved value.
+ */
+export declare function getField<T extends object, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2], K4 extends keyof T[K1][K2][K3]>(object: T, path: readonly [K1, K2, K3, K4]): T[K1][K2][K3][K4];
+/**
+ * Retrieves the value at a given path from an object. If the resolved value is undefined, the defaultValue is returned instead.
+ *
+ * @template T - The type of the object.
+ * @template K1 - The type of the first key in the object.
+ * @template K2 - The type of the second key in the object.
+ * @template K3 - The type of the third key in the object.
+ * @template K4 - The type of the fourth key in the object.
+ *
+ * @param {T | null | undefined} object - The object to query.
+ * @param {[K1, K2, K3, K4]} path - The path of the property to get.
+ * @returns {T[K1][K2][K3][K4] | undefined} - Returns the resolved value.
+ */
+export declare function getField<T extends object, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2], K4 extends keyof T[K1][K2][K3]>(object: T | null | undefined, path: readonly [K1, K2, K3, K4]): T[K1][K2][K3][K4] | undefined;
+/**
+ * Retrieves the value at a given path from an object. If the resolved value is undefined, the defaultValue is returned instead.
+ *
+ * @template T - The type of the object.
+ * @template K1 - The type of the first key in the object.
+ * @template K2 - The type of the second key in the object.
+ * @template K3 - The type of the third key in the object.
+ * @template K4 - The type of the fourth key in the object.
+ * @template D - The type of the default value.
+ *
+ * @param {T | null | undefined} object - The object to query.
+ * @param {[K1, K2, K3, K4]} path - The path of the property to get.
+ * @param {D} defaultValue - The value returned if the resolved value is undefined.
+ * @returns {Exclude<T[K1][K2][K3][K4], undefined> | D} - Returns the resolved value.
+ */
+export declare function getField<T extends object, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2], K4 extends keyof T[K1][K2][K3], D>(object: T | null | undefined, path: readonly [K1, K2, K3, K4], defaultValue: D): Exclude<T[K1][K2][K3][K4], undefined> | D;
+/**
+ * Retrieves the value at a given path from an object with numeric keys. If the resolved value is undefined, the defaultValue is returned instead.
+ *
+ * @template T - The type of the value.
+ *
+ * @param {Record<number, T>} object - The object to query.
+ * @param {number} path - The path of the property to get.
+ * @returns {T} - Returns the resolved value.
+ */
+export declare function getField<T>(object: Record<number, T>, path: number): T;
+/**
+ * Retrieves the value at a given path from an object with numeric keys. If the resolved value is undefined, the defaultValue is returned instead.
+ *
+ * @template T - The type of the value.
+ *
+ * @param {Record<number, T> | null | undefined} object - The object to query.
+ * @param {number} path - The path of the property to get.
+ * @returns {T | undefined} - Returns the resolved value.
+ */
+export declare function getField<T>(object: Record<number, T> | null | undefined, path: number): T | undefined;
+/**
+ * Retrieves the value at a given path from an object with numeric keys. If the resolved value is undefined, the defaultValue is returned instead.
+ *
+ * @template T - The type of the value.
+ * @template D - The type of the default value.
+ *
+ * @param {Record<number, T> | null | undefined} object - The object to query.
+ * @param {number} path - The path of the property to get.
+ * @param {D} defaultValue - The value returned if the resolved value is undefined.
+ * @returns {T | D} - Returns the resolved value.
+ */
+export declare function getField<T, D>(object: Record<number, T> | null | undefined, path: number, defaultValue: D): T | D;
+/**
+ * Retrieves the value at a given path from a null or undefined object, returning the default value.
+ *
+ * @template D - The type of the default value.
+ *
+ * @param {null | undefined} object - The object to query.
+ * @param {PropertyKey} path - The path of the property to get.
+ * @param {D} defaultValue - The value returned if the resolved value is undefined.
+ * @returns {D} - Returns the default value.
+ */
+export declare function getField<D>(object: null | undefined, path: PropertyKey, defaultValue: D): D;
+/**
+ * Retrieves the value at a given path from a null or undefined object, returning undefined.
+ *
+ * @param {null | undefined} object - The object to query.
+ * @param {PropertyKey} path - The path of the property to get.
+ * @returns {undefined} - Returns undefined.
+ */
+export declare function getField(object: null | undefined, path: PropertyKey): undefined;
+/**
+ * Retrieves the value at a given path from a string-keyed object. If the resolved value is undefined, the defaultValue is returned instead.
+ *
+ * @template T - The type of the object.
+ * @template P - The type of the path.
+ *
+ * @param {T} data - The object to query.
+ * @param {P} path - The path of the property to get.
+ * @returns {string extends P ? any : GetField<T, P>} - Returns the resolved value.
+ */
+export declare function getField<T, P extends string>(data: T, path: P): string extends P ? any : GetField<T, P>;
+/**
+ * Retrieves the value at a given path from a string-keyed object. If the resolved value is undefined, the defaultValue is returned instead.
+ *
+ * @template T - The type of the object.
+ * @template P - The type of the path.
+ * @template D - The type of the default value.
+ *
+ * @param {T} data - The object to query.
+ * @param {P} path - The path of the property to get.
+ * @param {D} defaultValue - The value returned if the resolved value is undefined.
+ * @returns {Exclude<GetField<T, P>, null | undefined> | D} - Returns the resolved value.
+ */
+export declare function getField<T, P extends string, D = GetField<T, P>>(data: T, path: P, defaultValue: D): Exclude<GetField<T, P>, null | undefined> | D;
+/**
+ * Retrieves the value at a given path from an object. If the resolved value is undefined, the defaultValue is returned instead.
+ *
+ * @param {unknown} object - The object to query.
+ * @param {PropertyKey | readonly PropertyKey[]} path - The path of the property to get.
+ * @param {unknown} [defaultValue] - The value returned if the resolved value is undefined.
+ * @returns {any} - Returns the resolved value.
+ */
+export declare function getField(object: unknown, path: PropertyKey | readonly PropertyKey[], defaultValue?: unknown): any;
+export {};

package/dist/get-field.mjs

@@ -0,0 +1 @@
+import{isDeepKey as o,isNumber as K,toStringKey as f}from"@stryke/types";import{toPath as r}from"./to-path";export function getField(t,e,d){if(t===null)return d;switch(typeof e){case"string":{const n=t[e];return n===void 0?o(e)?getField(t,r(e),d):d:n}case"number":case"symbol":{K(e)&&(e=f(e));const n=Array.isArray(e)?void 0:t[e];return n===void 0?d:n}default:{if(Array.isArray(e))return u(t,e,d);e=Object.is(e?.valueOf(),-0)?"-0":String(e);const n=t[e];return n===void 0?d:n}}}function u(t,e,d){if(e.length===0)return d;let n=t;for(const i of e){if(n===null)return d;n=n[i]}return n===void 0?d:n}

package/dist/get-ordered-by.cjs

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getOrderedBy = getOrderedBy;
+function getOrderedBy(f, n, o) {
+  const u = (r, e, t) => r < e ? t === "asc" ? -1 : 1 : r > e ? t === "asc" ? 1 : -1 : 0,
+    T = n.map((r, e) => o[e] ?? o.at(-1));
+  return [...f].sort((r, e) => {
+    for (const [t, c] of n.entries()) {
+      const i = T[t],
+        s = u(r[c], e[c], i);
+      if (s !== 0) return s;
+    }
+    return 0;
+  });
+}