@ekim088/toolkit 0.1.0

package/README.md

@@ -0,0 +1,3 @@
+# toolkit
+
+A simple utility library.

package/lib/@types/clone.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Creates a deep copy of a value.
+ * @param {*} value The value to clone.
+ * @returns {*} A copy of the value.
+ */
+export default function clone<T = unknown>(value: T): T;

package/lib/@types/index.d.ts

@@ -0,0 +1,20 @@
+import clone from './clone';
+import isBoolean from './isBoolean';
+import isDeepEqual from './isDeepEqual';
+import isNumber from './isNumber';
+import isObject from './isObject';
+import isString from './isString';
+import memoizeOne from './memoizeOne';
+import merge from './merge';
+declare const _default: {
+    clone: typeof clone;
+    isBoolean: typeof isBoolean;
+    isDeepEqual: typeof isDeepEqual;
+    isNumber: typeof isNumber;
+    isObject: typeof isObject;
+    isString: typeof isString;
+    memoizeOne: typeof memoizeOne;
+    merge: typeof merge;
+};
+export default _default;
+export * from './typeUtils';

package/lib/@types/isBoolean.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Tests if a value is a boolean datatype.
+ * @param {*} value The value to test.
+ * @returns {boolean} `true` if the value is a boolean.
+ */
+export default function isBoolean(value: unknown): value is boolean;

package/lib/@types/isDeepEqual.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Tests if two arguments are equal. Object literals and arrays are tested for
+ * deep equality while other objects are tested for strict equality.
+ * @param {*} a An argument to test.
+ * @param {*} b An argument to test.
+ * @returns {boolean} `true` if `a` and `b` are deeply equal.
+ */
+export default function isDeepEqual(a: unknown, b: unknown): boolean;

package/lib/@types/isNumber.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Tests if a value is a number datatype.
+ * @param {*} value The value to test.
+ * @returns {boolean} `true` if the value is a number.
+ */
+export default function isNumber(value: unknown): value is number;

package/lib/@types/isObject.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Tests if a value is an object literal.
+ * @param {*} value The value to test.
+ * @returns {boolean} `true` if the value is an object. Returns `false` for
+ *  arrays and `null`.
+ */
+export default function isObject(value: unknown): value is object;

package/lib/@types/isString.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Tests if a value is a string datatype.
+ * @param {*} value The value to test.
+ * @returns {boolean} `true` if the value is a string.
+ */
+export default function isString(value: unknown): value is string;

package/lib/@types/memoizeOne.d.ts

@@ -0,0 +1,18 @@
+export type MemoizedFn<T extends (...args: any) => unknown> = T & {
+    /**
+     * Clears the cached function result.
+     */
+    clear(): void;
+};
+export type EqualityFn<T extends (...args: any) => unknown> = (newArgs: Parameters<T>, cachedArgs: Parameters<T>) => boolean;
+/**
+ * Returns a memoized function that caches the last result of a function call.
+ * The cached result is returned if the function arguments remain the same. Only
+ * a single result is ever cached.
+ * @param {Function} fn The function to memoize.
+ * @param {Function} equalityFn A custom function to check equality between the
+ *  current arguments and the cached arguments. Arguments are considered equal
+ *  if the equality function returns `true`.
+ * @returns {Function} The memoized function.
+ */
+export default function memoizeOne<T extends (...args: any) => unknown>(fn: T, equalityFn?: EqualityFn<T>): MemoizedFn<T>;

package/lib/@types/merge.d.ts

@@ -0,0 +1,11 @@
+export type Merged<T extends object[]> = T extends [
+    infer FirstObj,
+    ...infer Rest
+] ? FirstObj & Merged<Rest extends object[] ? Rest : []> : {};
+/**
+ * Deeply merges a list of objects into a single object. For duplicate
+ * properties, subsequent occurrences overwrite the previous.
+ * @param {object[]} objects Any number of object literals to merge.
+ * @returns {object} A new object with the properties of its source objects.
+ */
+export default function merge<T extends object[]>(...objects: T): Merged<T>;

package/lib/@types/typeUtils.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Derives the item type from an array.
+ */
+export type ItemType<T> = T extends (infer U)[] ? U : never;
+/**
+ * Declares an object and its nested objects as partials.
+ */
+export type RecursivePartial<T> = {
+    [P in keyof T]?: T[P] extends Record<keyof any, unknown> ? RecursivePartial<T[P]> : T[P];
+};
+/**
+ * Makes a readonly object mutable.
+ */
+export type Writeable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+/**
+ * Makes a readonly object and all nested objects mutable.
+ */
+export type DeepWriteable<T> = {
+    -readonly [P in keyof T]: DeepWriteable<T[P]>;
+};

package/lib/clone.js

@@ -0,0 +1,31 @@
+import isObject from './isObject';
+function cloneObject(obj) {
+    const clonedObj = {};
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            clonedObj[key] = clone(obj[key]);
+        }
+    }
+    return clonedObj;
+}
+/**
+ * Creates a deep copy of a value.
+ * @param {*} value The value to clone.
+ * @returns {*} A copy of the value.
+ */
+export default function clone(value) {
+    if (Array.isArray(value)) {
+        return value.map(item => clone(item));
+    }
+    if (isObject(value)) {
+        return cloneObject(value);
+    }
+    if (typeof value === 'function') {
+        return Object.assign((...args) => value(...args), cloneObject(value) // transfer custom function properties
+        );
+    }
+    if (value instanceof Date) {
+        return new Date(value);
+    }
+    return value;
+}

package/lib/index.js

@@ -0,0 +1,19 @@
+import clone from './clone';
+import isBoolean from './isBoolean';
+import isDeepEqual from './isDeepEqual';
+import isNumber from './isNumber';
+import isObject from './isObject';
+import isString from './isString';
+import memoizeOne from './memoizeOne';
+import merge from './merge';
+export default {
+    clone,
+    isBoolean,
+    isDeepEqual,
+    isNumber,
+    isObject,
+    isString,
+    memoizeOne,
+    merge,
+};
+export * from './typeUtils';

package/lib/isBoolean.js

@@ -0,0 +1,8 @@
+/**
+ * Tests if a value is a boolean datatype.
+ * @param {*} value The value to test.
+ * @returns {boolean} `true` if the value is a boolean.
+ */
+export default function isBoolean(value) {
+    return typeof value === 'boolean';
+}

package/lib/isDeepEqual.js

@@ -0,0 +1,21 @@
+import isObject from './isObject';
+/**
+ * Tests if two arguments are equal. Object literals and arrays are tested for
+ * deep equality while other objects are tested for strict equality.
+ * @param {*} a An argument to test.
+ * @param {*} b An argument to test.
+ * @returns {boolean} `true` if `a` and `b` are deeply equal.
+ */
+export default function isDeepEqual(a, b) {
+    if (typeof a !== typeof b) {
+        return false;
+    }
+    if (Array.isArray(a) && Array.isArray(b)) {
+        return (a.length === b.length &&
+            a.every((item, i) => isDeepEqual(item, b[i])));
+    }
+    if (isObject(a) && isObject(b)) {
+        return isDeepEqual(Object.entries(a), Object.entries(b));
+    }
+    return a === b;
+}

package/lib/isNumber.js

@@ -0,0 +1,8 @@
+/**
+ * Tests if a value is a number datatype.
+ * @param {*} value The value to test.
+ * @returns {boolean} `true` if the value is a number.
+ */
+export default function isNumber(value) {
+    return typeof value === 'number';
+}

package/lib/isObject.js

@@ -0,0 +1,9 @@
+/**
+ * Tests if a value is an object literal.
+ * @param {*} value The value to test.
+ * @returns {boolean} `true` if the value is an object. Returns `false` for
+ *  arrays and `null`.
+ */
+export default function isObject(value) {
+    return !!value && value.constructor === Object;
+}

package/lib/isString.js

@@ -0,0 +1,8 @@
+/**
+ * Tests if a value is a string datatype.
+ * @param {*} value The value to test.
+ * @returns {boolean} `true` if the value is a string.
+ */
+export default function isString(value) {
+    return typeof value === 'string';
+}

package/lib/memoizeOne.js

@@ -0,0 +1,33 @@
+import isDeepEqual from './isDeepEqual';
+/**
+ * Returns a memoized function that caches the last result of a function call.
+ * The cached result is returned if the function arguments remain the same. Only
+ * a single result is ever cached.
+ * @param {Function} fn The function to memoize.
+ * @param {Function} equalityFn A custom function to check equality between the
+ *  current arguments and the cached arguments. Arguments are considered equal
+ *  if the equality function returns `true`.
+ * @returns {Function} The memoized function.
+ */
+export default function memoizeOne(fn, equalityFn) {
+    let cache = null;
+    function memoizedFn(...args) {
+        if (cache &&
+            cache.cachedThis === this &&
+            (equalityFn
+                ? equalityFn(args, cache.cachedArgs)
+                : isDeepEqual(args, cache.cachedArgs))) {
+            return cache.cachedResult;
+        }
+        cache = {
+            cachedThis: this,
+            cachedArgs: args,
+            cachedResult: fn.apply(this, args),
+        };
+        return cache.cachedResult;
+    }
+    memoizedFn.clear = () => {
+        cache = null;
+    };
+    return memoizedFn;
+}

package/lib/merge.js

@@ -0,0 +1,26 @@
+import isObject from './isObject';
+/**
+ * Deeply merges a list of objects into a single object. For duplicate
+ * properties, subsequent occurrences overwrite the previous.
+ * @param {object[]} objects Any number of object literals to merge.
+ * @returns {object} A new object with the properties of its source objects.
+ */
+export default function merge(...objects) {
+    const mergedObj = {};
+    objects.forEach(obj => {
+        Object.keys(obj).forEach(key => {
+            const currentVal = mergedObj[key];
+            const valToMerge = obj[key];
+            if (isObject(currentVal) && isObject(valToMerge)) {
+                mergedObj[key] = merge(currentVal, valToMerge);
+            }
+            else if (Array.isArray(currentVal) && Array.isArray(valToMerge)) {
+                mergedObj[key] = currentVal.concat(valToMerge);
+            }
+            else {
+                mergedObj[key] = valToMerge;
+            }
+        });
+    });
+    return mergedObj;
+}

package/lib/typeUtils.js

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

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@ekim088/toolkit",
+  "description": "A simple utility library.",
+  "version": "0.1.0",
+  "author": "ekim088 <edward@cyberbird.co>",
+  "type": "module",
+  "license": "MIT",
+  "main": "./lib/index.js",
+  "types": "./lib/@types/index.d.ts",
+  "scripts": {
+    "build": "rm -rf ./lib && tsc",
+    "format": "yarn exec prettier . --write",
+    "lint": "yarn lint:js && yarn lint:types",
+    "lint:js": "eslint . --fix",
+    "lint:types": "tsc --noEmit",
+    "test": "vitest",
+    "test:ci": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:pre-commit": "vitest related --run",
+    "_postinstall": "husky",
+    "prepack": "pinst --disable",
+    "postpack": "pinst --enable"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^19.8.1",
+    "@commitlint/config-conventional": "^19.8.1",
+    "@eslint/js": "^9.27.0",
+    "@vitest/coverage-v8": "3.1.4",
+    "@vitest/eslint-plugin": "^1.2.1",
+    "eslint": "^9.27.0",
+    "eslint-plugin-jsdoc": "^50.6.17",
+    "global-jsdom": "^26.0.0",
+    "globals": "^16.2.0",
+    "husky": "^9.1.7",
+    "jsdom": "^26.1.0",
+    "lint-staged": "^16.0.0",
+    "pinst": "^3.0.0",
+    "prettier": "3.5.3",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.32.1",
+    "vitest": "^3.1.4"
+  },
+  "volta": {
+    "node": "22.16.0",
+    "yarn": "4.9.1"
+  }
+}