tspo 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Sean Maxwell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,9 @@
+# tspo ✈️
+
+[![npm](https://img.shields.io/npm/v/tspo?label=npm&color=0ea5e9)](https://www.npmjs.com/package/tspo)
+[![downloads](https://img.shields.io/npm/dm/tspo?label=downloads&color=38bdf8)](https://www.npmjs.com/package/tspo)
+[![types](https://img.shields.io/npm/types/tspo?label=types&color=22c55e)](https://www.npmjs.com/package/tspo)
+[![bundle size](https://img.shields.io/bundlephobia/minzip/tspo?label=bundle&color=0f172a)](https://bundlephobia.com/package/tspo)
+[![license](https://img.shields.io/npm/l/tspo?label=license&color=334155)](LICENSE)
+
+Please refer to the official <a href="https://github.com/seanpmaxwell/tspo">github repo</a> for the most up-to-date documentation.

package/dist/cjs/index.js

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

package/dist/cjs/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/tspo.js

@@ -0,0 +1,133 @@
+import isPlainObject, {} from './isPlainObject.js';
+import compare from './utils/compare.js';
+import copy from './utils/copy.js';
+import iterate from './utils/iterate.js';
+function omit(obj, keys) {
+    const retVal = {}, set = new Set(Array.isArray(keys) ? keys : [keys]);
+    for (const key in obj) {
+        if (!set.has(key)) {
+            retVal[key] = obj[key];
+        }
+    }
+    return retVal;
+}
+function pick(obj, keys) {
+    const retVal = {}, set = new Set(Array.isArray(keys) ? keys : [keys]);
+    for (const key in obj) {
+        if (set.has(key)) {
+            retVal[key] = obj[key];
+        }
+    }
+    return retVal;
+}
+function merge(a, b) {
+    return { ...a, ...b };
+}
+function fill(defaults, partial) {
+    return { ...defaults, ...(partial ?? {}) };
+}
+function append(obj, addOn) {
+    for (const key in addOn) {
+        obj[key] = addOn[key];
+    }
+}
+function appendOne(obj, entry) {
+    obj[entry[0]] = entry[1];
+}
+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) {
+    const retVal = [];
+    for (const key in obj) {
+        if (obj[key] === value) {
+            retVal.push(key);
+        }
+    }
+    if (retVal.length !== 1) {
+        throw new Error('.safeReverseIndex found 0 or more than 1 keys for value: ' +
+            String(value));
+    }
+    return retVal[0];
+}
+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 valArr = Array.isArray(arg) ? arg : [arg], valSet = new Set(Object.values(obj));
+    for (const val of valArr) {
+        if (!valSet.has(val))
+            return false;
+    }
+    return true;
+}
+function keys(obj) {
+    return Object.keys(obj);
+}
+function values(obj) {
+    return Object.values(obj);
+}
+function entries(obj) {
+    return Object.entries(obj);
+}
+function firstEntry(obj) {
+    return Object.entries(obj)[0];
+}
+function toDict(obj) {
+    if (!isPlainObject(obj)) {
+        throw new Error('value passed to ".toDict" not a plain-object');
+    }
+    return obj;
+}
+export default {
+    omit,
+    pick,
+    merge,
+    fill,
+    append,
+    appendOne,
+    index,
+    remove,
+    toDict,
+    safeIndex,
+    reverseIndex,
+    safeReverseIndex,
+    is: isPlainObject,
+    isKey,
+    isValue,
+    keys,
+    values,
+    entries,
+    firstEntry,
+    iterate,
+    copy,
+    compare,
+};

package/dist/cjs/utility-types.js

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

package/dist/cjs/utils/compare.js

@@ -0,0 +1,52 @@
+import isPlainObject, {} from '../isPlainObject.js';
+const hop = Object.prototype.hasOwnProperty;
+function compare(a, b) {
+    if (!isPlainObject(a) || !isPlainObject(b)) {
+        return false;
+    }
+    return comparePlainObjects(a, b);
+}
+function comparePlainObjects(a, b) {
+    const aKeys = Object.keys(a), bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length)
+        return false;
+    for (const key of aKeys) {
+        if (!hop.call(b, key))
+            return false;
+        if (!compareValue(a[key], b[key]))
+            return false;
+    }
+    return true;
+}
+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,75 @@
+import isPlainObject, {} from '../isPlainObject.js';
+import {} from '../utility-types.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;
+    return clonePlainObject(value, Object.getPrototypeOf(value), resetDates);
+}
+function clonePlainObject(source, proto, resetDates) {
+    const out = proto === null ? Object.create(null) : {};
+    for (const key in source) {
+        if (!hop.call(source, key))
+            continue;
+        out[key] = cloneValue(source[key], resetDates);
+    }
+    return out;
+}
+function cloneValue(value, resetDates) {
+    if (isPlainObject(value)) {
+        return clonePlainObject(value, Object.getPrototypeOf(value), resetDates);
+    }
+    if (Array.isArray(value)) {
+        return cloneArray(value, resetDates);
+    }
+    if (value instanceof Date) {
+        if (resetDates) {
+            return new Date();
+        }
+        return new Date(value.getTime());
+    }
+    if (typeof value === 'object' && value !== null) {
+        return cloneNonPlainShallow(value);
+    }
+    return value;
+}
+function cloneArray(source, resetDates) {
+    const len = source.length;
+    const out = new Array(len);
+    for (let i = 0; i < len; i++) {
+        out[i] = cloneValue(source[i], resetDates);
+    }
+    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);
+    if (ArrayBuffer.isView(value)) {
+        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));
+    }
+    if (value instanceof ArrayBuffer)
+        return value.slice(0);
+    const proto = Object.getPrototypeOf(value);
+    const out = Object.create(proto);
+    for (const key in value) {
+        if (hop.call(value, key))
+            out[key] = value[key];
+    }
+    return out;
+}
+export default copy;

package/dist/cjs/utils/iterate.js

@@ -0,0 +1,30 @@
+import isPlainObject, {} from '../isPlainObject.js';
+function iterate(root, cb) {
+    if (!isPlainObject(root))
+        return;
+    iterateHelper(root, [], cb);
+}
+function iterateHelper(node, path, cb) {
+    if (Array.isArray(node)) {
+        let i = 0;
+        for (const [key, value] of node.entries()) {
+            if (isPlainObject(value) || Array.isArray(value)) {
+                iterateHelper(value, [...path, key, i], cb);
+            }
+            else {
+                cb({ parent: node, key, value, path });
+            }
+            i++;
+        }
+        return;
+    }
+    for (const [key, value] of Object.entries(node)) {
+        if (isPlainObject(value) || Array.isArray(value)) {
+            iterateHelper(value, [...path, key], cb);
+        }
+        else {
+            cb({ parent: node, key, value, path });
+        }
+    }
+}
+export default iterate;

package/dist/esm/index.js

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

package/dist/esm/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/esm/tspo.js

@@ -0,0 +1,133 @@
+import isPlainObject, {} from './isPlainObject.js';
+import compare from './utils/compare.js';
+import copy from './utils/copy.js';
+import iterate from './utils/iterate.js';
+function omit(obj, keys) {
+    const retVal = {}, set = new Set(Array.isArray(keys) ? keys : [keys]);
+    for (const key in obj) {
+        if (!set.has(key)) {
+            retVal[key] = obj[key];
+        }
+    }
+    return retVal;
+}
+function pick(obj, keys) {
+    const retVal = {}, set = new Set(Array.isArray(keys) ? keys : [keys]);
+    for (const key in obj) {
+        if (set.has(key)) {
+            retVal[key] = obj[key];
+        }
+    }
+    return retVal;
+}
+function merge(a, b) {
+    return { ...a, ...b };
+}
+function fill(defaults, partial) {
+    return { ...defaults, ...(partial ?? {}) };
+}
+function append(obj, addOn) {
+    for (const key in addOn) {
+        obj[key] = addOn[key];
+    }
+}
+function appendOne(obj, entry) {
+    obj[entry[0]] = entry[1];
+}
+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) {
+    const retVal = [];
+    for (const key in obj) {
+        if (obj[key] === value) {
+            retVal.push(key);
+        }
+    }
+    if (retVal.length !== 1) {
+        throw new Error('.safeReverseIndex found 0 or more than 1 keys for value: ' +
+            String(value));
+    }
+    return retVal[0];
+}
+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 valArr = Array.isArray(arg) ? arg : [arg], valSet = new Set(Object.values(obj));
+    for (const val of valArr) {
+        if (!valSet.has(val))
+            return false;
+    }
+    return true;
+}
+function keys(obj) {
+    return Object.keys(obj);
+}
+function values(obj) {
+    return Object.values(obj);
+}
+function entries(obj) {
+    return Object.entries(obj);
+}
+function firstEntry(obj) {
+    return Object.entries(obj)[0];
+}
+function toDict(obj) {
+    if (!isPlainObject(obj)) {
+        throw new Error('value passed to ".toDict" not a plain-object');
+    }
+    return obj;
+}
+export default {
+    omit,
+    pick,
+    merge,
+    fill,
+    append,
+    appendOne,
+    index,
+    remove,
+    toDict,
+    safeIndex,
+    reverseIndex,
+    safeReverseIndex,
+    is: isPlainObject,
+    isKey,
+    isValue,
+    keys,
+    values,
+    entries,
+    firstEntry,
+    iterate,
+    copy,
+    compare,
+};

package/dist/esm/utility-types.js

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

package/dist/esm/utils/compare.js

@@ -0,0 +1,52 @@
+import isPlainObject, {} from '../isPlainObject.js';
+const hop = Object.prototype.hasOwnProperty;
+function compare(a, b) {
+    if (!isPlainObject(a) || !isPlainObject(b)) {
+        return false;
+    }
+    return comparePlainObjects(a, b);
+}
+function comparePlainObjects(a, b) {
+    const aKeys = Object.keys(a), bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length)
+        return false;
+    for (const key of aKeys) {
+        if (!hop.call(b, key))
+            return false;
+        if (!compareValue(a[key], b[key]))
+            return false;
+    }
+    return true;
+}
+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/esm/utils/copy.js

@@ -0,0 +1,75 @@
+import isPlainObject, {} from '../isPlainObject.js';
+import {} from '../utility-types.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;
+    return clonePlainObject(value, Object.getPrototypeOf(value), resetDates);
+}
+function clonePlainObject(source, proto, resetDates) {
+    const out = proto === null ? Object.create(null) : {};
+    for (const key in source) {
+        if (!hop.call(source, key))
+            continue;
+        out[key] = cloneValue(source[key], resetDates);
+    }
+    return out;
+}
+function cloneValue(value, resetDates) {
+    if (isPlainObject(value)) {
+        return clonePlainObject(value, Object.getPrototypeOf(value), resetDates);
+    }
+    if (Array.isArray(value)) {
+        return cloneArray(value, resetDates);
+    }
+    if (value instanceof Date) {
+        if (resetDates) {
+            return new Date();
+        }
+        return new Date(value.getTime());
+    }
+    if (typeof value === 'object' && value !== null) {
+        return cloneNonPlainShallow(value);
+    }
+    return value;
+}
+function cloneArray(source, resetDates) {
+    const len = source.length;
+    const out = new Array(len);
+    for (let i = 0; i < len; i++) {
+        out[i] = cloneValue(source[i], resetDates);
+    }
+    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);
+    if (ArrayBuffer.isView(value)) {
+        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));
+    }
+    if (value instanceof ArrayBuffer)
+        return value.slice(0);
+    const proto = Object.getPrototypeOf(value);
+    const out = Object.create(proto);
+    for (const key in value) {
+        if (hop.call(value, key))
+            out[key] = value[key];
+    }
+    return out;
+}
+export default copy;

package/dist/esm/utils/iterate.js

@@ -0,0 +1,30 @@
+import isPlainObject, {} from '../isPlainObject.js';
+function iterate(root, cb) {
+    if (!isPlainObject(root))
+        return;
+    iterateHelper(root, [], cb);
+}
+function iterateHelper(node, path, cb) {
+    if (Array.isArray(node)) {
+        let i = 0;
+        for (const [key, value] of node.entries()) {
+            if (isPlainObject(value) || Array.isArray(value)) {
+                iterateHelper(value, [...path, key, i], cb);
+            }
+            else {
+                cb({ parent: node, key, value, path });
+            }
+            i++;
+        }
+        return;
+    }
+    for (const [key, value] of Object.entries(node)) {
+        if (isPlainObject(value) || Array.isArray(value)) {
+            iterateHelper(value, [...path, key], cb);
+        }
+        else {
+            cb({ parent: node, key, value, path });
+        }
+    }
+}
+export default iterate;

package/dist/types/index.d.ts

@@ -0,0 +1,28 @@
+import { type Dict, type PlainObject } from './isPlainObject.js';
+import tspo from './tspo.js';
+import type { KeysParam, KeyUnion, SetToNever } from './utility-types.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 AppendOne = <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>>>;
+type ToDict = (obj: unknown) => Dict;
+/******************************************************************************
+                                  Constants
+******************************************************************************/
+declare const typedTspo: Readonly<typeof tspo> & {
+    readonly append: Append;
+    readonly appendOne: AppendOne;
+    readonly remove: Remove;
+    readonly toDict: ToDict;
+};
+/******************************************************************************
+                                   Export
+******************************************************************************/
+export { type OmitNever } from './utility-types.js';
+export { type Dict } from './isPlainObject.js';
+export default typedTspo;

package/dist/types/isPlainObject.d.ts

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

package/dist/types/tspo.d.ts

@@ -0,0 +1,116 @@
+import isPlainObject, { type Dict, type PlainObject } from './isPlainObject.js';
+import type { DeepWiden, EntriesTuple, KeysParam, KeyTuple, KeyUnion, Mutable, OmitKeys, PickKeys, SetToNever, ValueTuple } from './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 PlainObject, 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 PlainObject, 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 PlainObject, U extends PlainObject>(a: T, b: U): CollapseType<Mutable<Omit<T, keyof U> & U>>;
+/**
+ * Fill the missing entries in a partial, will the values from a 'defaults'
+ * object.
+ */
+declare function fill<const T extends object>(defaults: T, partial?: Partial<DeepWiden<T>>): CollapseType<Mutable<DeepWiden<T>>>;
+/**
+ * Append one object to another, modifying the reference to the original
+ * object.
+ */
+declare function append<T extends PlainObject, U extends PlainObject>(obj: T, addOn: U): asserts obj is CollapseType<T & U>;
+/**
+ * Append a single entry to an object.
+ */
+declare function appendOne<T extends PlainObject, K extends string, V>(obj: T, entry: [K, V]): asserts obj is CollapseType<T & Record<K, V>>;
+/**
+ * Remove keys from an object and set the type to 'never'.
+ */
+declare function remove<T extends PlainObject, 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 object>(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 object>(obj: T, key: string | number): T[keyof T];
+/**
+ * Get a list of keys for which the value matches.
+ */
+declare function reverseIndex<T extends object>(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 object>(obj: T, value: unknown): keyof T;
+/**
+ * Validator function to check
+ */
+declare function isKey<T extends object>(obj: T, arg: PropertyKey): arg is keyof T;
+/**
+ * Validator function to check
+ */
+declare function isValue<T extends object>(obj: T, arg: unknown): arg is T[keyof T];
+/**
+ * Get a type-safe array of the object keys.
+ */
+declare function keys<T extends object>(obj: T): KeyTuple<T>;
+/**
+ * Get a type-safe array of the object values
+ */
+declare function values<T extends object>(obj: T): ValueTuple<T>;
+/**
+ * Get a type-safe array of the object entries
+ */
+declare function entries<T extends object>(obj: T): EntriesTuple<T>;
+/**
+ * Get a type-safe array of the object e
+ */
+declare function firstEntry<T extends object, K extends keyof T>(obj: T): [K, T[K]];
+/**
+ * Check if something is a plain
+ */
+declare function toDict(obj: unknown): Dict;
+/******************************************************************************
+                                       Export
+******************************************************************************/
+declare const _default: {
+    readonly omit: typeof omit;
+    readonly pick: typeof pick;
+    readonly merge: typeof merge;
+    readonly fill: typeof fill;
+    readonly append: typeof append;
+    readonly appendOne: typeof appendOne;
+    readonly index: typeof index;
+    readonly remove: typeof remove;
+    readonly toDict: typeof toDict;
+    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;
+};
+export default _default;

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

@@ -0,0 +1,29 @@
+export type KeysParam<T extends object> = keyof T | (keyof T)[];
+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 Mutable<T> = {
+    -readonly [K in keyof T]: T[K];
+};
+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 UnionToTuple<U, R extends any[] = []> = [U] extends [never] ? R : UnionToTuple<Exclude<U, LastOf<U>>, [LastOf<U>, ...R]>;
+type LastOf<U> = UnionToIntersection<U extends any ? () => U : never> extends () => infer L ? L : never;
+type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
+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 Primitive = string | number | boolean | bigint | symbol | null | undefined;
+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 {};

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

@@ -0,0 +1,18 @@
+import { type PlainObject } from '../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,16 @@
+import { type PlainObject } from '../isPlainObject.js';
+import { type Mutable } from '../utility-types.js';
+type CopyOptions = {
+    resetDates?: boolean;
+};
+/**
+ * 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.
+ */
+declare function copy<T extends PlainObject>(value: T, options?: CopyOptions): Mutable<T>;
+export default copy;

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

@@ -0,0 +1,28 @@
+import { type PlainObject } from '../isPlainObject.js';
+/******************************************************************************
+                                     Types
+******************************************************************************/
+type Path = readonly (string | number)[];
+type IterateParent = PlainObject | unknown[];
+type IterateKey = string | number;
+type IterateCb = (args: {
+    parent: IterateParent;
+    key: IterateKey;
+    value: unknown;
+    path: Path;
+}) => void;
+/******************************************************************************
+                                  Functions
+******************************************************************************/
+/**
+ * Recursively walks plain-objects and arrays, and calls a callback for
+ * every key whose value is neither a plain-object nor an array.
+ *
+ * - Descends into a value if it is a plain-object or array.
+ * - Fires callback for every non-descended value.
+ */
+declare function iterate(root: unknown, cb: IterateCb): void;
+/******************************************************************************
+                                   Export
+******************************************************************************/
+export default iterate;

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "tspo",
+  "version": "1.0.0",
+  "description": "A collection of utilities for handling both runtime and compile-time behavior for plain-objects.",
+  "keywords": [
+    "typescript",
+    "javascript",
+    "tspo",
+    "plain-object",
+    "object-utils",
+    "utility-library",
+    "type-safe",
+    "type-guard",
+    "object-manipulation",
+    "object-merge",
+    "object-omit",
+    "object-pick",
+    "object-iterate",
+    "indexing",
+    "deep-copy",
+    "deep-compare",
+    "runtime-validation",
+    "zero-dependency"
+  ],
+  "homepage": "https://github.com/seanpmaxwell/tspo#readme",
+  "bugs": {
+    "url": "https://github.com/seanpmaxwell/tspo/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/seanpmaxwell/tspo.git"
+  },
+  "license": "MIT",
+  "author": "seanpmaxwell",
+  "type": "module",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "browser": "./dist/esm/index.js",
+  "types": "./dist/types/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "rm -rf ./dist && tsc -p tsconfig.esm.json && tsc -p tsconfig.cjs.json && tsc -p tsconfig.types.json",
+    "clean-install": "rm -rf ./node_modules && rm -r package-lock.json && npm i",
+    "lint": "eslint .",
+    "format": "eslint --fix .",
+    "pre-publish": "mv README.md README-git && mv README-npm README.md",
+    "post-publish": "mv README.md README-npm && mv README-git README.md",
+    "test": "NODE_ENV=test vitest"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.26.0",
+    "@stylistic/eslint-plugin": "^5.6.1",
+    "@trivago/prettier-plugin-sort-imports": "^6.0.1",
+    "@types/node": "^22.8.1",
+    "dts-bundle-generator": "^9.5.1",
+    "eslint": "^9.26.0",
+    "eslint-config-prettier": "^10.1.8",
+    "jiti": "^2.6.1",
+    "prettier": "^3.7.4",
+    "typescript": "~5.9.3",
+    "typescript-eslint": "^8.50.0",
+    "vitest": "^4.0.15"
+  }
+}