@ezez/utils 1.0.0

package/src/omit.spec.ts

@@ -0,0 +1,181 @@
+import { omit as _omit } from "lodash";
+
+import { omit } from "./omit.js";
+
+describe("omit", () => {
+    it("returns empty object when source is not given, behaves like lodash", () => {
+        caseundefined: {
+            const value = omit(undefined, ["name", "count"]);
+            value.must.eql({});
+
+            const _value = _omit(undefined, ["name", "count"]);
+            _value.must.eql({});
+        }
+
+        casenull: {
+            const value = omit(null, ["name", "count"]);
+            value.must.eql({});
+
+            const _value = _omit(null, ["name", "count"]);
+            _value.must.eql({});
+        }
+    });
+
+    it("returns cloned object when properties are not given, behaves like lodash", () => {
+        const source = {
+            title: "Master od disaster",
+            count: 1,
+        };
+
+        caseundefined: {
+            const value = omit(source);
+            value.must.eql({
+                title: "Master od disaster",
+                count: 1,
+            });
+
+            const _value = _omit(source);
+            _value.must.eql({
+                title: "Master od disaster",
+                count: 1,
+            });
+        }
+
+        caseempty: {
+            const value = omit(source, []);
+            value.must.eql({
+                title: "Master od disaster",
+                count: 1,
+            });
+
+            const _value = _omit(source, []);
+            _value.must.eql({
+                title: "Master od disaster",
+                count: 1,
+            });
+        }
+    });
+
+    it("returns empty object when source is number, behaves like lodash", () => {
+        const value = omit(2, ["title"]);
+        value.must.eql({});
+
+        const _value = _omit(2, ["title"]);
+        _value.must.eql({});
+    });
+
+    it("returns empty object when source is string, behaves NOT like lodash", () => {
+        const value = omit("two", ["title"]);
+        value.must.eql({});
+
+        const _value = _omit("two", ["title"]);
+        _value.must.eql({ 0: "t", 1: "w", 2: "o" });
+    });
+
+    it("returns new object when source is function, behaves like lodash", () => {
+        const source = () => {};
+        source.title = "ABCD";
+        source.weight = "XXX";
+
+        const value = omit(source, ["title"]);
+        value.must.eql({
+            weight: "XXX",
+        });
+
+        const _value = _omit(source, ["title"]);
+        _value.must.eql({
+            weight: "XXX",
+        });
+    });
+
+    it("returns new object without given properties, behaves like lodash", () => {
+        const source = {
+            a: 5,
+            b: "string",
+            c: undefined,
+            d: 0,
+            e: null,
+            f: false,
+        };
+
+        const value = omit(source, ["a", "d", "g"]);
+        value.must.eql({
+            b: "string",
+            c: undefined,
+            e: null,
+            f: false,
+        });
+        value.must.not.equal(source);
+
+        const _value = _omit(source, ["a", "d", "g"]);
+        _value.must.eql({
+            b: "string",
+            c: undefined,
+            e: null,
+            f: false,
+        });
+        _value.must.not.equal(source);
+    });
+
+    it("returns inherited properties (as own), behaves like lodash", () => {
+        const Test = function() {};
+        Test.prototype.name = "xxx";
+
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const testInstance = new Test();
+        testInstance.length = 100;
+
+        const value = omit(testInstance, ["title"]);
+        value.must.eql({
+            name: "xxx",
+            length: 100,
+        });
+        value.hasOwnProperty("name").must.be.true();
+        value.hasOwnProperty("length").must.be.true();
+
+        const _value = _omit(testInstance, ["title"]);
+        _value.must.eql({
+            name: "xxx",
+            length: 100,
+        });
+        _value.hasOwnProperty("name").must.be.true();
+        _value.hasOwnProperty("length").must.be.true();
+    });
+
+    it("skips non-enumerable properties, behaves like lodash", () => {
+        const source = {
+            aaa: 123,
+            title: 666,
+        };
+        Object.defineProperty(source, "name", {
+            enumerable: false,
+            value: "test",
+        });
+
+        const value = omit(source, ["title"]);
+        value.must.eql({
+            aaa: 123,
+        });
+        ("name" in value).must.be.false();
+
+        const _value = _omit(source, ["title"]);
+        _value.must.eql({
+            aaa: 123,
+        });
+        ("name" in _value).must.be.false();
+    });
+
+    it("returns object when array is given as source, behaves like lodash", () => {
+        const source = ["a", "b", "c"];
+
+        const value = omit(source, [0, "2", 15, "xxx"]);
+        value.must.eql({
+            1: "b",
+        });
+
+        const _value = _omit(source, [0, "2", 15, "xxx"]);
+        _value.must.eql({
+            1: "b",
+        });
+    });
+});

package/src/omit.ts

@@ -0,0 +1,43 @@
+// TODO verify & maybe fix typings when object is an Array
+
+/**
+ * Returns new object with copied all properties without these specified.
+ *
+ * @param {Object} object - source object
+ * @param {Array.<string>} props - properties to skip
+ * @example
+ * omit({ name: "Jack", age: 69 }, ["age", "title"]);
+ * // { name: "Jack" }
+ * @example
+ * omit(["hello", "world"], [0]);
+ * // { 1: "world" }
+ * @returns {Object} - new object without given properties
+ */
+const omit = <T extends object, K extends keyof T>(
+    object: T | null, props: K[],
+): T extends null ? { [key: string]: never } : Omit<T, K> => {
+    if (!object || (typeof object !== "object" && typeof object !== "function")) {
+        // @ts-expect-error TS can't handle implementation of dynamic return types yet
+        return {};
+    }
+
+    if (!Array.isArray(props) || !props.length) {
+        // @ts-expect-error TS can't handle implementation of dynamic return types yet
+        return {
+            ...object,
+        };
+    }
+
+    const useProps = props.map(String);
+
+    const result = {};
+    for (const key in object) {
+        if (!useProps.includes(key)) {
+            (result as T)[key] = object[key];
+        }
+    }
+    // @ts-expect-error TS can't handle implementation of dynamic return types yet
+    return result;
+};
+
+export { omit };

package/src/pick.spec.ts

@@ -0,0 +1,168 @@
+import { pick as _pick } from "lodash";
+
+import { pick } from "./pick.js";
+
+describe("pick", () => {
+    it("returns empty object when source is not given, behaves like lodash", () => {
+        caseundefined: {
+            const value = pick(undefined, ["name", "count"]);
+            value.must.eql({});
+
+            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
+            const _value = _pick(undefined, ["name", "count"]);
+            _value.must.eql({});
+        }
+
+        casenull: {
+            const value = pick(null, ["name", "count"]);
+            value.must.eql({});
+
+            const _value = _pick(null, ["name", "count"]);
+            _value.must.eql({});
+        }
+    });
+
+    it("returns empty object when properties to copy are not given, behaves like lodash", () => {
+        const source = {
+            title: "Master od disaster",
+            count: 1,
+        };
+
+        caseundefined: {
+            const value = pick(source);
+            value.must.eql({});
+
+            const _value = _pick(source);
+            _value.must.eql({});
+        }
+
+        caseempty: {
+            const value = pick(source, []);
+            value.must.eql({});
+
+            const _value = _pick(source, []);
+            _value.must.eql({});
+        }
+    });
+
+    it("returns empty object when source is primitive, behaves like lodash", () => {
+        number: {
+            const value = pick(2, ["title"]);
+            value.must.eql({});
+
+            const _value = _pick(2, ["title"]);
+            _value.must.eql({});
+        }
+
+        string: {
+            const value = pick("two", ["title"]);
+            value.must.eql({});
+
+            const _value = _pick("two", ["title"]);
+            _value.must.eql({});
+        }
+    });
+
+    it("returns new object with expected properties, ignores not defined properties, behaves like lodash", () => {
+        const source = {
+            a: 5,
+            b: "string",
+            c: undefined,
+            d: 0,
+            e: null,
+            f: false,
+        };
+
+        const value = pick(source, ["a", "b", "c", "d", "e", "f", "g"]);
+        value.must.eql({
+            a: 5,
+            b: "string",
+            c: undefined,
+            d: 0,
+            e: null,
+            f: false,
+        });
+        value.must.not.equal(source);
+
+        const _value = _pick(source, ["a", "b", "c", "d", "e", "f", "g"]);
+        _value.must.eql({
+            a: 5,
+            b: "string",
+            c: undefined,
+            d: 0,
+            e: null,
+            f: false,
+        });
+        _value.must.not.equal(source);
+    });
+
+    it("returns new object when source is function, behaves like lodash", () => {
+        const source = () => {};
+        source.title = "ABCD";
+
+        const value = pick(source, ["title"]);
+        value.must.eql({
+            title: "ABCD",
+        });
+
+        const _value = _pick(source, ["title"]);
+        _value.must.eql({
+            title: "ABCD",
+        });
+    });
+
+    it("returns inherited properties, behaves like lodash", () => {
+        const Test = function() {};
+        Test.prototype.count = 1;
+
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const testInstance = new Test();
+        testInstance.length = 2;
+
+        const value = pick(testInstance, ["count", "length"]);
+        value.must.eql({
+            count: 1,
+            length: 2,
+        });
+
+        const _value = _pick(testInstance, ["count", "length"]);
+        _value.must.eql({
+            count: 1,
+            length: 2,
+        });
+    });
+
+    it("returns non-enumerable properties, behaves like lodash", () => {
+        const source = {};
+        Object.defineProperty(source, "count", {
+            enumerable: false,
+            value: 23,
+        });
+
+        const value = pick(source, ["count"]);
+        value.must.eql({
+            count: 23,
+        });
+
+        const _value = _pick(source, ["count"]);
+        _value.must.eql({
+            count: 23,
+        });
+    });
+
+    it("returns object when array is given as source, behaves like lodash", () => {
+        const source = ["a", "b", "c"];
+
+        const value = pick(source, [0, "2", 15, "xxx"]);
+        value.must.eql({
+            0: "a",
+            2: "c",
+        });
+
+        const _value = _pick(source, [0, "2", 15, "xxx"]);
+        _value.must.eql({
+            0: "a",
+            2: "c",
+        });
+    });
+});

package/src/pick.ts

@@ -0,0 +1,39 @@
+// TODO verify & maybe fix typings when object is an Array
+
+/**
+ * Returns new object with copied given properties from source object.
+ *
+ * @param {Object} object - source object
+ * @param {Array.<string>} props - properties to copy
+ * @example
+ * pick({ name: "Jack", age: 69 }, ["age", "title"]);
+ * // { age: 69 }
+ * @example
+ * pick(["hello", "world"], [0]);
+ * // { 0: hello }
+ * @returns {Object} - new object with given properties
+ */
+const pick = <T extends object, K extends keyof T>(
+    object: T | null, props: K[],
+): T extends null ? { [ key: string]: never } : Pick<T, K> => {
+    if (
+        !object
+        || (typeof object !== "object" && typeof object !== "function")
+        || !Array.isArray(props)
+        || !props.length
+    ) {
+        // @ts-expect-error TS can't handle implementation of dynamic return types yet
+        return {};
+    }
+    const result = {};
+    props.forEach(property => {
+        if (property in object) {
+            (result as T)[property] = object[property];
+        }
+    });
+
+    // @ts-expect-error TS can't handle implementation of dynamic return types yet
+    return result;
+};
+
+export { pick };

package/src/pull.spec.ts

@@ -0,0 +1,54 @@
+import { pull } from "./pull.js";
+
+describe("pull", function() {
+    it("should remove all given values", function() {
+        const source = [1, 2, 1, 2, 1, 2, 1, 1, 2, 2, 1, 1, 2, 1, 2, 2];
+        const result = pull(source, 1);
+        (source === result).must.be.true();
+
+        result.includes(1).must.be.false();
+        result.must.eql([2, 2, 2, 2, 2, 2, 2, 2]);
+    });
+
+    it("should be able to clear the array", function() {
+        const source = [1, 2, 1, 2, 1, 2, 1, 1, 2, 2, 1, 1, 2, 1, 2, 2];
+        const result = pull(source, 1, 2);
+        (source === result).must.be.true();
+        result.must.have.length(0);
+    });
+
+    it("should remove NaNs", function() {
+        const source = [1, NaN, 3];
+        pull(source, NaN);
+        source.must.eql([1, 3]);
+    });
+
+    it("should remove nothing", function() {
+        const source = [1, NaN, 3, undefined];
+        pull(source);
+        source.must.eql([1, NaN, 3, undefined]);
+    });
+
+    it("should remove null or undefined or referenced objects", function() {
+        const obj = {};
+        const source = [1, undefined, 2, null, 3, obj, 4, {}];
+        pull(source, obj, null, undefined);
+        source.must.eql([1, 2, 3, 4, {}]);
+    });
+
+    it("should work with sparse arrays, removing holes when requested to remove undefined", function() {
+        // eslint-disable-next-line no-sparse-arrays
+        const source = [1, , 3, , 5];
+        pull(source, undefined);
+        source.must.eql([1, 3, 5]);
+    });
+
+    it("should work with sparse arrays, keeping holes when requested", function() {
+        // eslint-disable-next-line no-sparse-arrays
+        const source = [1, , 3, , 5];
+        pull(source, null);
+        // eslint-disable-next-line no-sparse-arrays
+        source.must.eql([1, ,3, , 5]);
+        ("1" in source).must.be.false();
+    });
+});

package/src/pull.ts

@@ -0,0 +1,18 @@
+/**
+ * Modifies the array, removing all occurrences of specified values
+ * @param {Array} array
+ * @param {...*}valuesToPull
+ */
+const pull = <T>(array: T[], ...valuesToPull: T[]): T[] => {
+    const len = array.length;
+    for (let i = len - 1; i >= 0; i--) {
+        if (valuesToPull.includes(array[i])) {
+            array.splice(i, 1);
+        }
+    }
+    return array;
+};
+
+export {
+    pull,
+};

package/src/remove.spec.ts

@@ -0,0 +1,63 @@
+import { remove as _remove } from "lodash";
+
+import createSpy from "../test/createSpy.js";
+
+import { remove } from "./remove.js";
+
+describe("remove", () => {
+    it("removes values", () => {
+        const fn = x => x % 2 === 0;
+
+        const src = [1, 2, 3, 4, 5, 6, 7];
+        const _src = [...src];
+
+        remove(src, fn);
+        src.must.eql([1, 3, 5, 7]);
+
+        _remove(_src, fn);
+        _src.must.eql([1, 3, 5, 7]);
+    });
+
+    it("returns removed values", () => {
+        const fn = x => x % 2 === 0;
+
+        const src = [1, 2, 3, 4, 5, 6, 7];
+        const _src = [...src];
+
+        const removed = remove(src, fn);
+        removed.must.eql([2, 4, 6]);
+
+        const _removed = _remove(_src, fn);
+        _removed.must.eql([2, 4, 6]);
+    });
+
+    it("calls test function with correct arguments", () => {
+        const fn = x => x % 2 === 0;
+        const spy = createSpy(fn);
+        const _spy = createSpy(fn);
+
+        const src = [1, 2, 3, 4, 5, 6, 7];
+        const _src = [...src];
+        const srcCopy = [...src];
+
+        remove(src, spy);
+        spy.__spy.calls.must.have.length(7);
+        spy.__spy.calls[0].must.eql([1, 0, srcCopy]);
+        spy.__spy.calls[1].must.eql([2, 1, srcCopy]);
+        spy.__spy.calls[2].must.eql([3, 2, srcCopy]);
+        spy.__spy.calls[3].must.eql([4, 3, srcCopy]);
+        spy.__spy.calls[4].must.eql([5, 4, srcCopy]);
+        spy.__spy.calls[5].must.eql([6, 5, srcCopy]);
+        spy.__spy.calls[6].must.eql([7, 6, srcCopy]);
+
+        remove(_src, _spy);
+        _spy.__spy.calls.must.have.length(7);
+        _spy.__spy.calls[0].must.eql([1, 0, srcCopy]);
+        _spy.__spy.calls[1].must.eql([2, 1, srcCopy]);
+        _spy.__spy.calls[2].must.eql([3, 2, srcCopy]);
+        _spy.__spy.calls[3].must.eql([4, 3, srcCopy]);
+        _spy.__spy.calls[4].must.eql([5, 4, srcCopy]);
+        _spy.__spy.calls[5].must.eql([6, 5, srcCopy]);
+        _spy.__spy.calls[6].must.eql([7, 6, srcCopy]);
+    });
+});

package/src/remove.ts

@@ -0,0 +1,26 @@
+/**
+ * Removes values from array using function as predicate. Returns removed values.
+ *
+ * @param {Array} array
+ * @param {function} fn
+ * @returns {Array}
+ */
+const remove = <T>(array: T[], fn: (elem: T, num: number, list: T[]) => boolean): T[] => {
+    const len = array.length;
+
+    const idsToRemove = []; // not removing instantly to feed `fn` untouched array for each iteration, lodash does that
+    const removedValues = [];
+
+    for (let counter = 0; counter < len; counter++) {
+        if (fn(array[counter], counter, array)) {
+            idsToRemove.push(counter - idsToRemove.length);
+            removedValues.push(array[counter]);
+        }
+    }
+
+    idsToRemove.forEach(id => array.splice(id, 1));
+
+    return removedValues;
+};
+
+export { remove };

package/src/rethrow.ts

@@ -0,0 +1,12 @@
+/**
+ * Throws given value.
+ * @param {*} e
+ */
+const rethrow = (e: unknown) => {
+    // eslint-disable-next-line @typescript-eslint/no-throw-literal
+    throw e;
+};
+
+export {
+    rethrow,
+};

package/src/scale.ts

@@ -0,0 +1,18 @@
+/**
+ * Changes the scale of given value, i.e.: replaces values from 2.9 to 3.3 into values from 0 to 100. Useful for i.e.:
+ * displaying measured battery voltage as a percent value.
+ * Pro-tip: use `Function.prototype.bind` to create yourself a function with bound 4 first arguments to re-use without
+ * repeating the from-to scale.
+ * @param {number} fromMin
+ * @param {number} fromMax
+ * @param {number} toMin
+ * @param {number} toMax
+ * @param {number} number
+ */
+const scale = (fromMin: number, fromMax: number, toMin: number, toMax: number, number: number) => {
+    return toMin + ((number - fromMin) / (fromMax - fromMin) * (toMax - toMin));
+};
+
+export {
+    scale,
+};