tspo 1.0.4 → 1.0.5

package/dist/cjs/helpers/isPlainObject.js

@@ -0,0 +1,13 @@
+const objectProto = Object.prototype;
+function isPlainObject(arg) {
+    if (typeof arg !== 'object' || arg === null) {
+        return false;
+    }
+    const argProto = Object.getPrototypeOf(arg);
+    return ((argProto === null ||
+        argProto === objectProto ||
+        Object.getPrototypeOf(argProto) === null) &&
+        !(Symbol.toStringTag in arg) &&
+        !(Symbol.iterator in arg));
+}
+export default isPlainObject;

package/dist/cjs/helpers/utility-types.js

@@ -0,0 +1 @@
+export {};

package/dist/cjs/index.js

@@ -0,0 +1,4 @@
+import tspo from './tspo.js';
+const typedTspo = tspo;
+export {} from './helpers/utility-types.js';
+export default typedTspo;

package/dist/cjs/tspo.js

@@ -0,0 +1,189 @@
+import isPlainObject from './helpers/isPlainObject.js';
+import compare from './utils/compare.js';
+import copy from './utils/copy.js';
+import iterate from './utils/iterate.js';
+const hop = Object.prototype.hasOwnProperty;
+function omit(obj, keys) {
+    const retVal = {};
+    const dict = obj;
+    if (Array.isArray(keys)) {
+        const set = new Set(keys);
+        for (const key in obj) {
+            if (!set.has(key)) {
+                retVal[key] = dict[key];
+            }
+        }
+        return retVal;
+    }
+    const omittedKey = keys;
+    for (const key in obj) {
+        if (key !== omittedKey) {
+            retVal[key] = dict[key];
+        }
+    }
+    return retVal;
+}
+function pick(obj, keys) {
+    const retVal = {};
+    const dict = obj;
+    if (Array.isArray(keys)) {
+        const set = new Set(keys);
+        for (const key in obj) {
+            if (set.has(key)) {
+                retVal[key] = dict[key];
+            }
+        }
+        return retVal;
+    }
+    const pickedKey = keys;
+    for (const key in obj) {
+        if (key === pickedKey) {
+            retVal[key] = dict[key];
+        }
+    }
+    return retVal;
+}
+function merge(a, b) {
+    return { ...a, ...b };
+}
+function mergeArray(arr) {
+    return Object.assign({}, ...arr);
+}
+function addEntry(obj, entry) {
+    return { ...obj, [entry[0]]: entry[1] };
+}
+function addEntries(obj, entries) {
+    return {
+        ...obj,
+        ...Object.fromEntries(entries),
+    };
+}
+function append(obj, addOn) {
+    for (const key in addOn) {
+        obj[key] = addOn[key];
+    }
+}
+function remove(obj, keys) {
+    const keyArr = Array.isArray(keys) ? keys : [keys];
+    for (const key of keyArr) {
+        delete obj[key];
+    }
+}
+function index(obj, key) {
+    return obj[key];
+}
+function safeIndex(obj, key) {
+    if (key in obj) {
+        return obj[key];
+    }
+    else {
+        throw new Error('safeIndex was passed a key not present on the object. key: ' + key);
+    }
+}
+function reverseIndex(obj, value) {
+    const retVal = [];
+    for (const key in obj) {
+        if (obj[key] === value) {
+            retVal.push(key);
+        }
+    }
+    return retVal;
+}
+function safeReverseIndex(obj, value) {
+    let found = false;
+    let retVal;
+    for (const key in obj) {
+        if (obj[key] === value) {
+            if (found) {
+                throw new Error('.safeReverseIndex found 0 or more than 1 keys for value: ' +
+                    String(value));
+            }
+            found = true;
+            retVal = key;
+        }
+    }
+    if (!found) {
+        throw new Error('.safeReverseIndex found 0 or more than 1 keys for value: ' +
+            String(value));
+    }
+    return retVal;
+}
+function isKey(obj, arg) {
+    const keyArr = Array.isArray(arg) ? arg : [arg];
+    for (const key of keyArr) {
+        if (!(typeof arg === 'string' && arg in obj))
+            return false;
+    }
+    return true;
+}
+function isValue(obj, arg) {
+    const dict = obj;
+    if (!Array.isArray(arg)) {
+        for (const key in obj) {
+            if (hop.call(obj, key) && sameValueZero(dict[key], arg))
+                return true;
+        }
+        return false;
+    }
+    for (const val of arg) {
+        let found = false;
+        for (const key in obj) {
+            if (hop.call(obj, key) && sameValueZero(dict[key], val)) {
+                found = true;
+                break;
+            }
+        }
+        if (!found)
+            return false;
+    }
+    return true;
+}
+function sameValueZero(a, b) {
+    return a === b || (a !== a && b !== b);
+}
+function isDict(arg) {
+    return isPlainObject(arg) && Object.getOwnPropertySymbols(arg).length === 0;
+}
+function keys(obj) {
+    return Object.keys(obj);
+}
+function values(obj) {
+    return Object.values(obj);
+}
+function entries(obj) {
+    return Object.entries(obj);
+}
+function firstEntry(obj) {
+    const dict = obj;
+    for (const key in obj) {
+        if (hop.call(obj, key)) {
+            return [key, dict[key]];
+        }
+    }
+    return undefined;
+}
+export default {
+    omit,
+    pick,
+    merge,
+    mergeArray,
+    append,
+    addEntry,
+    addEntries,
+    index,
+    remove,
+    safeIndex,
+    reverseIndex,
+    safeReverseIndex,
+    is: isPlainObject,
+    isKey,
+    isValue,
+    keys,
+    values,
+    entries,
+    firstEntry,
+    iterate,
+    copy,
+    compare,
+    isDict,
+};

package/dist/cjs/utils/compare.js

@@ -0,0 +1,58 @@
+import isPlainObject, {} from '../helpers/isPlainObject.js';
+const hop = Object.prototype.hasOwnProperty;
+function compare(a, b) {
+    if (!isPlainObject(a) || !isPlainObject(b)) {
+        throw new Error('compare only works for plain-objects');
+    }
+    return comparePlainObjects(a, b);
+}
+function comparePlainObjects(a, b) {
+    let aSize = 0;
+    for (const key in a) {
+        if (!hop.call(a, key))
+            continue;
+        aSize++;
+        if (!hop.call(b, key))
+            return false;
+        if (!compareValue(a[key], b[key]))
+            return false;
+    }
+    let bSize = 0;
+    for (const key in b) {
+        if (hop.call(b, key))
+            bSize++;
+    }
+    return aSize === bSize;
+}
+function compareValue(a, b) {
+    if (Object.is(a, b))
+        return true;
+    if (a instanceof Date || b instanceof Date) {
+        return (a instanceof Date && b instanceof Date && a.getTime() === b.getTime());
+    }
+    const aIsArray = Array.isArray(a), bIsArray = Array.isArray(b);
+    if (aIsArray || bIsArray) {
+        return aIsArray && bIsArray && compareArrays(a, b);
+    }
+    const aIsPlainObject = isPlainObject(a), bIsPlainObject = isPlainObject(b);
+    if (aIsPlainObject || bIsPlainObject) {
+        return aIsPlainObject && bIsPlainObject && comparePlainObjects(a, b);
+    }
+    if (typeof a === 'object' &&
+        a !== null &&
+        typeof b === 'object' &&
+        b !== null) {
+        return a === b;
+    }
+    return false;
+}
+function compareArrays(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (!compareValue(a[i], b[i]))
+            return false;
+    }
+    return true;
+}
+export default compare;

package/dist/cjs/utils/copy.js

@@ -0,0 +1,113 @@
+import isPlainObject, {} from '../helpers/isPlainObject.js';
+const hop = Object.prototype.hasOwnProperty;
+function copy(value, options) {
+    if (!isPlainObject(value)) {
+        throw new TypeError('.copy only accepts a plain-object as the root value');
+    }
+    const resetDates = options?.resetDates === true, deepCloneAll = options?.deepCloneAll === true;
+    return clonePlainObject(value, Object.getPrototypeOf(value), resetDates, deepCloneAll);
+}
+function clonePlainObject(source, proto, resetDates, deepCloneAll) {
+    const out = proto === null ? Object.create(null) : {};
+    for (const key in source) {
+        if (!hop.call(source, key))
+            continue;
+        out[key] = cloneValue(source[key], resetDates, deepCloneAll);
+    }
+    return out;
+}
+function cloneValue(value, resetDates, deepCloneAll) {
+    if (isPlainObject(value)) {
+        return clonePlainObject(value, Object.getPrototypeOf(value), resetDates, deepCloneAll);
+    }
+    if (Array.isArray(value)) {
+        return cloneArray(value, resetDates, deepCloneAll);
+    }
+    if (value instanceof Date) {
+        if (resetDates) {
+            return new Date();
+        }
+        return new Date(value.getTime());
+    }
+    if (typeof value === 'object' && value !== null) {
+        if (deepCloneAll) {
+            return cloneNonPlainDeep(value, resetDates);
+        }
+        return cloneNonPlainShallow(value);
+    }
+    return value;
+}
+function cloneArray(source, resetDates, deepCloneAll) {
+    const len = source.length, out = new Array(len);
+    for (let i = 0; i < len; i++) {
+        out[i] = cloneValue(source[i], resetDates, deepCloneAll);
+    }
+    return out;
+}
+function cloneNonPlainShallow(value) {
+    if (value instanceof RegExp) {
+        const re = new RegExp(value.source, value.flags);
+        re.lastIndex = value.lastIndex;
+        return re;
+    }
+    if (value instanceof Map)
+        return new Map(value);
+    if (value instanceof Set)
+        return new Set(value);
+    const clonedView = cloneArrayBufferView(value);
+    if (clonedView !== undefined)
+        return clonedView;
+    if (value instanceof ArrayBuffer)
+        return value.slice(0);
+    const proto = Object.getPrototypeOf(value), out = Object.create(proto);
+    for (const key in value) {
+        if (hop.call(value, key))
+            out[key] = value[key];
+    }
+    return out;
+}
+function cloneNonPlainDeep(value, resetDates) {
+    if (value instanceof RegExp) {
+        const re = new RegExp(value.source, value.flags);
+        re.lastIndex = value.lastIndex;
+        return re;
+    }
+    if (value instanceof Map) {
+        const out = new Map();
+        for (const [key, val] of value) {
+            out.set(cloneValue(key, resetDates, true), cloneValue(val, resetDates, true));
+        }
+        return out;
+    }
+    if (value instanceof Set) {
+        const out = new Set();
+        for (const entry of value) {
+            out.add(cloneValue(entry, resetDates, true));
+        }
+        return out;
+    }
+    const clonedView = cloneArrayBufferView(value);
+    if (clonedView !== undefined)
+        return clonedView;
+    if (value instanceof ArrayBuffer)
+        return value.slice(0);
+    const proto = Object.getPrototypeOf(value), out = Object.create(proto);
+    for (const key in value) {
+        if (!hop.call(value, key))
+            continue;
+        out[key] = cloneValue(value[key], resetDates, true);
+    }
+    return out;
+}
+function cloneArrayBufferView(value) {
+    if (!ArrayBuffer.isView(value))
+        return undefined;
+    const anyVal = value;
+    if (typeof anyVal.slice === 'function')
+        return anyVal.slice();
+    if (value instanceof DataView) {
+        return new DataView(value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength));
+    }
+    return new anyVal.constructor(value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength));
+}
+export default copy;

package/dist/cjs/utils/iterate.js

@@ -0,0 +1,34 @@
+import isPlainObject, {} from '../helpers/isPlainObject.js';
+const hop = Object.prototype.hasOwnProperty;
+function iterate(root, cb) {
+    if (!isPlainObject(root))
+        return;
+    iterateHelper(root, [], cb);
+}
+function iterateHelper(node, path, cb) {
+    if (Array.isArray(node)) {
+        for (let i = 0; i < node.length; i++) {
+            const value = node[i];
+            cb({ parent: node, key: i, value, path: path.slice() });
+            if (isPlainObject(value) || Array.isArray(value)) {
+                path.push(i);
+                iterateHelper(value, path, cb);
+                path.pop();
+            }
+        }
+        return;
+    }
+    const dict = node;
+    for (const key in dict) {
+        if (!hop.call(dict, key))
+            continue;
+        const value = dict[key];
+        cb({ parent: dict, key, value, path: path.slice() });
+        if (isPlainObject(value) || Array.isArray(value)) {
+            path.push(key);
+            iterateHelper(value, path, cb);
+            path.pop();
+        }
+    }
+}
+export default iterate;

package/dist/types/helpers/isPlainObject.d.ts

@@ -0,0 +1,15 @@
+/******************************************************************************
+                                  Constants/Types
+******************************************************************************/
+export type PlainObject = Record<PropertyKey, unknown>;
+/******************************************************************************
+                                     Functions
+******************************************************************************/
+/**
+ * Check if a 'unknown' is a 'PlainObject.
+ */
+declare function isPlainObject(arg: unknown): arg is PlainObject;
+/******************************************************************************
+                                    Export
+******************************************************************************/
+export default isPlainObject;

package/dist/types/helpers/utility-types.d.ts

@@ -0,0 +1,47 @@
+/******************************************************************************
+                                       Types
+******************************************************************************/
+export type TruthyObject = NonNullable<object>;
+type Primitive = string | number | boolean | bigint | symbol | null | undefined;
+export type Dict = Record<string, unknown>;
+export type KeysParam<T extends object> = keyof T | (keyof T)[];
+export type Mutable<T> = {
+    -readonly [K in keyof T]: T[K];
+};
+export type KeyUnion<T extends object, K extends KeysParam<T>> = K extends (keyof T)[] ? K[number] : K;
+export type OmitKeys<T extends object, K extends KeysParam<T>> = Omit<T, KeyUnion<T, K>>;
+export type PickKeys<T extends object, K extends KeysParam<T>> = Pick<T, KeyUnion<T, K>>;
+export type Entry<T extends object> = T extends object ? {
+    [K in keyof T]-?: [K, T[K]];
+}[keyof T] : never;
+export type SetToNever<T, K extends PropertyKey> = T & {
+    [P in K]: never;
+};
+type NonNeverKeys<T extends object> = {
+    [K in keyof T]-?: [T[K]] extends [never] ? never : K;
+}[keyof T];
+export type OmitNever<T extends object> = Pick<T, NonNeverKeys<T>>;
+type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
+type LastOf<U> = UnionToIntersection<U extends any ? () => U : never> extends () => infer L ? L : never;
+type UnionToTuple<U, R extends any[] = []> = [U] extends [never] ? R : UnionToTuple<Exclude<U, LastOf<U>>, [LastOf<U>, ...R]>;
+type Entries<T extends object> = {
+    [K in keyof T]-?: [K, T[K]];
+}[keyof T];
+export type EntriesTuple<T extends object> = UnionToTuple<Entries<T>>;
+export type KeyTuple<T extends object> = UnionToTuple<keyof T>;
+export type ValueTuple<T extends object> = UnionToTuple<T[keyof T]>;
+type WidenPrimitive<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T extends bigint ? bigint : T extends symbol ? symbol : T;
+export type DeepWiden<T> = T extends Primitive ? WidenPrimitive<T> : T extends (...args: any[]) => any ? T : T extends readonly (infer U)[] ? DeepWiden<U>[] : T extends object ? {
+    [K in keyof T]: DeepWiden<T[K]>;
+} : T;
+export type EntryToAdd = readonly [PropertyKey, unknown];
+export type AddEntries<T extends object, Entries extends readonly EntryToAdd[]> = T & {
+    [K in Entries[number] as K[0]]: Extract<Entries[number], readonly [K[0], unknown]>[1];
+};
+type UnionKeys<U extends object> = U extends unknown ? keyof U : never;
+type UnionValuesForKey<U extends object, K extends PropertyKey> = U extends unknown ? (K extends keyof U ? U[K] : never) : never;
+type MergeUnion<U extends object> = [UnionKeys<U>] extends [never] ? Dict : {
+    [K in UnionKeys<U>]: UnionValuesForKey<U, K>;
+};
+export type MergeArray<A extends readonly TruthyObject[]> = MergeUnion<A[number]>;
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,25 @@
+import type { PlainObject } from './helpers/isPlainObject.js';
+import type { KeysParam, KeyUnion, SetToNever } from './helpers/utility-types.js';
+import tspo from './tspo.js';
+/******************************************************************************
+                                   Types
+******************************************************************************/
+type CollapseType<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type Append = <T extends PlainObject, U extends PlainObject>(obj: T, addOn: U) => asserts obj is CollapseType<T & U>;
+type AddEntry = <T extends PlainObject, K extends string, V>(obj: T, entry: [K, V]) => asserts obj is CollapseType<T & Record<K, V>>;
+type Remove = <T extends PlainObject, K extends KeysParam<T>>(obj: T, keys: K) => asserts obj is CollapseType<SetToNever<T, KeyUnion<T, K>>>;
+/******************************************************************************
+                                  Constants
+******************************************************************************/
+declare const typedTspo: Readonly<typeof tspo> & {
+    readonly append: Append;
+    readonly addEntry: AddEntry;
+    readonly remove: Remove;
+};
+/******************************************************************************
+                                   Export
+******************************************************************************/
+export { type OmitNever } from './helpers/utility-types.js';
+export default typedTspo;

package/dist/types/tspo.d.ts

@@ -0,0 +1,122 @@
+import isPlainObject from './helpers/isPlainObject.js';
+import type { AddEntries, DeepWiden, EntriesTuple, Entry, EntryToAdd, KeysParam, KeyTuple, KeyUnion, MergeArray, OmitKeys, PickKeys, SetToNever, TruthyObject, ValueTuple } from './helpers/utility-types.js';
+import compare from './utils/compare.js';
+import copy from './utils/copy.js';
+import iterate from './utils/iterate.js';
+/******************************************************************************
+                                       Types
+******************************************************************************/
+type CollapseType<T> = {
+    -readonly [K in keyof T]: T[K];
+} & {};
+/******************************************************************************
+                                     Functions
+******************************************************************************/
+/**
+ * Return a new object by excluding certains keys from an object.
+ */
+declare function omit<T extends TruthyObject, K extends KeysParam<T>>(obj: T, keys: K): CollapseType<OmitKeys<T, K>>;
+/**
+ * Return a new object by selecting a specific set of keys on an object.
+ */
+declare function pick<T extends TruthyObject, K extends KeysParam<T>>(obj: T, keys: K): CollapseType<PickKeys<T, K>>;
+/**
+ * Merge two object together and return a new type.
+ */
+declare function merge<T extends TruthyObject, U extends TruthyObject>(a: T, b: U): CollapseType<Omit<T, keyof U> & U>;
+/**
+ * Merge an array of objects together
+ */
+declare function mergeArray<const A extends readonly TruthyObject[]>(arr: A): CollapseType<MergeArray<A>>;
+/**
+ * Append a single entry to an object.
+ */
+declare function addEntry<T extends TruthyObject, K extends string, V>(obj: T, entry: [K, V]): CollapseType<T & Record<K, V>>;
+/**
+ * Append a single entry to an object.
+ */
+declare function addEntries<T extends TruthyObject, const E extends readonly EntryToAdd[]>(obj: T, entries: E): CollapseType<DeepWiden<AddEntries<T, E>>>;
+/**
+ * Append one object to another, modifying the reference to the original
+ * object.
+ */
+declare function append<T extends TruthyObject, U extends TruthyObject>(obj: T, addOn: U): asserts obj is CollapseType<T & U>;
+/**
+ * Remove keys from an object and set the type to 'never'.
+ */
+declare function remove<T extends TruthyObject, K extends KeysParam<T>>(obj: T, keys: K): asserts obj is CollapseType<SetToNever<T, KeyUnion<T, K>>>;
+/**
+ * Get a value on an object and return 'undefined' if not found.
+ */
+declare function index<T extends TruthyObject>(obj: T, key: string | number): T[keyof T] | undefined;
+/**
+ * Get a value on an object and return 'undefined' if not found.
+ */
+declare function safeIndex<T extends TruthyObject>(obj: T, key: string | number): T[keyof T];
+/**
+ * Get a list of keys for which the value matches.
+ */
+declare function reverseIndex<T extends TruthyObject>(obj: T, value: unknown): (keyof T)[];
+/**
+ * Get a key for a value only if you know the value is unique.
+ */
+declare function safeReverseIndex<T extends TruthyObject>(obj: T, value: unknown): keyof T;
+/**
+ * Validator function to check
+ */
+declare function isKey<T extends TruthyObject>(obj: T, arg: PropertyKey): arg is keyof T;
+/**
+ * Validator function to check
+ */
+declare function isValue<T extends TruthyObject>(obj: T, arg: unknown): arg is T[keyof T];
+/**
+ * Similar to `isPlainObject` but narrows a plain-object even further to
+ * exclude symbols. Note that when numbers are added as keys to objects they
+ * are converted to strings so we don't have to check for those.
+ */
+declare function isDict(arg: unknown): arg is Record<string, unknown>;
+/**
+ * Get a type-safe array of the object keys.
+ */
+declare function keys<T extends TruthyObject>(obj: T): KeyTuple<T>;
+/**
+ * Get a type-safe array of the object values
+ */
+declare function values<T extends TruthyObject>(obj: T): ValueTuple<T>;
+/**
+ * Get a type-safe array of the object entries
+ */
+declare function entries<T extends TruthyObject>(obj: T): EntriesTuple<T>;
+/**
+ * Get a type-safe array of the object e
+ */
+declare function firstEntry<T extends TruthyObject>(obj: T): Entry<T>;
+/******************************************************************************
+                                       Export
+******************************************************************************/
+declare const _default: {
+    readonly omit: typeof omit;
+    readonly pick: typeof pick;
+    readonly merge: typeof merge;
+    readonly mergeArray: typeof mergeArray;
+    readonly append: typeof append;
+    readonly addEntry: typeof addEntry;
+    readonly addEntries: typeof addEntries;
+    readonly index: typeof index;
+    readonly remove: typeof remove;
+    readonly safeIndex: typeof safeIndex;
+    readonly reverseIndex: typeof reverseIndex;
+    readonly safeReverseIndex: typeof safeReverseIndex;
+    readonly is: typeof isPlainObject;
+    readonly isKey: typeof isKey;
+    readonly isValue: typeof isValue;
+    readonly keys: typeof keys;
+    readonly values: typeof values;
+    readonly entries: typeof entries;
+    readonly firstEntry: typeof firstEntry;
+    readonly iterate: typeof iterate;
+    readonly copy: typeof copy;
+    readonly compare: typeof compare;
+    readonly isDict: typeof isDict;
+};
+export default _default;

package/dist/types/utils/compare.d.ts

@@ -0,0 +1,18 @@
+import { type PlainObject } from '../helpers/isPlainObject.js';
+/******************************************************************************
+                                  Functions
+******************************************************************************/
+/**
+ * Recursively compares two plain objects.
+ *
+ * Traversal rules:
+ * - recurse into plain objects
+ * - recurse into arrays
+ * - compare Date by epoch (`getTime()`)
+ * - compare any other object values by reference
+ */
+declare function compare(a: PlainObject, b: PlainObject): boolean;
+/******************************************************************************
+                                    Export
+******************************************************************************/
+export default compare;

package/dist/types/utils/copy.d.ts

@@ -0,0 +1,27 @@
+import { type PlainObject } from '../helpers/isPlainObject.js';
+import type { Mutable } from '../helpers/utility-types.js';
+/******************************************************************************
+                                     Types
+******************************************************************************/
+interface CopyOptions {
+    resetDates?: boolean;
+    deepCloneAll?: boolean;
+}
+/******************************************************************************
+                                  Functions
+******************************************************************************/
+/**
+ * Deep clones ONLY plain-objects (incl. null-prototype).
+ *
+ * - Root value must be a plain-object.
+ * - Recursion descends only into plain-objects and arrays.
+ * - Nested Date values are copied by epoch.
+ * - `resetDates` resets all nested Date values to current time.
+ * - Other nested non-plain objects are shallow-cloned by default.
+ * - `deepCloneAll` deep-clones all nested object values.
+ */
+declare function copy<T extends PlainObject>(value: T, options?: CopyOptions): Mutable<T>;
+/******************************************************************************
+                                  Functions
+******************************************************************************/
+export default copy;

package/dist/types/utils/iterate.d.ts

@@ -0,0 +1,25 @@
+import { type PlainObject } from '../helpers/isPlainObject.js';
+/******************************************************************************
+                                     Types
+******************************************************************************/
+type IterateCb = (args: {
+    parent: PlainObject | unknown[];
+    key: string | number;
+    value: unknown;
+    path: readonly (string | number)[];
+}) => void;
+/******************************************************************************
+                                  Functions
+******************************************************************************/
+/**
+ * Recursively walks plain-objects and arrays, and calls a callback for
+ * every key before descending into nested values.
+ *
+ * - Descends into a value if it is a plain-object or array.
+ * - Fires callback for every entry (including plain-objects/arrays).
+ */
+declare function iterate(root: unknown, cb: IterateCb): void;
+/******************************************************************************
+                                   Export
+******************************************************************************/
+export default iterate;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tspo",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "A collection of utilities for handling both runtime and compile-time behavior for plain-objects.",
   "keywords": [
     "typescript",