@fgv/ts-utils 1.3.1 → 1.4.0

package/normalize.d.ts

@@ -0,0 +1,43 @@
+import { Result } from './result';
+export declare type Entry<T> = [string | number | symbol, T];
+export declare type ResultEntry<T> = [string | number | symbol, Result<T>];
+/**
+ * Normalizes an arbitrary JSON object
+ * @public
+ */
+export declare class Normalizer {
+    /**
+     * Normalizes the supplied value
+     *
+     * @param from - The value to be normalized
+     * @returns A normalized version of the value
+     */
+    normalize<T>(from: T): Result<T>;
+    /**
+     * Compares two property names from some object being normalized.
+     * @param k1 - First key to be compared.
+     * @param k2 - Second key to be compared.
+     * @returns `1` if `k1` is greater, `-1` if `k2` is greater and
+     * `0` if they are equal.
+     * @internal
+     */
+    protected _compareKeys(k1: unknown, k2: unknown): number;
+    /**
+     * Normalizes an array of object property entries (e.g. as returned by `Object.entries()`).
+     * @remarks
+     * Converts property names (entry key) to string and then sorts as string.
+     * @param entries - The entries to be normalized.
+     * @returns A normalized sorted array of entries.
+     * @internal
+     */
+    protected _normalizeEntries<T = unknown>(entries: Iterable<Entry<T>>): Entry<T>[];
+    protected _normalizeArray(from: unknown[]): Result<unknown[]>;
+    /**
+     * Normalizes the supplied literal value
+     * @param from - The literal value to be normalized.
+     * @returns A normalized value for the literal.
+     * @internal
+     */
+    protected _normalizeLiteral<T>(from: T): Result<T>;
+}
+//# sourceMappingURL=normalize.d.ts.map

package/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../src/normalize.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAE,MAAM,EAA6B,MAAM,UAAU,CAAC;AAE7D,oBAAY,KAAK,CAAC,CAAC,IAAI,CAAC,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC,CAAC;AACrD,oBAAY,WAAW,CAAC,CAAC,IAAI,CAAC,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AAEnE;;;GAGG;AACH,qBAAa,UAAU;IACnB;;;;;OAKG;IACI,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC;IA+BvC;;;;;;;OAOG;IACH,SAAS,CAAC,YAAY,CAAC,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,GAAG,MAAM;IAexD;;;;;;;OAOG;IACH,SAAS,CAAC,iBAAiB,CAAC,CAAC,GAAG,OAAO,EAAE,OAAO,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,EAAE;IAQjF,SAAS,CAAC,eAAe,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,MAAM,CAAC,OAAO,EAAE,CAAC;IAI7D;;;;;OAKG;IACH,SAAS,CAAC,iBAAiB,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC;CAyBrD"}

package/normalize.js

@@ -0,0 +1,139 @@
+"use strict";
+/*
+ * Copyright (c) 2021 Erik Fortune
+ *
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Normalizer = void 0;
+const result_1 = require("./result");
+/**
+ * Normalizes an arbitrary JSON object
+ * @public
+ */
+class Normalizer {
+    /**
+     * Normalizes the supplied value
+     *
+     * @param from - The value to be normalized
+     * @returns A normalized version of the value
+     */
+    normalize(from) {
+        switch (typeof from) {
+            case 'string':
+            case 'bigint':
+            case 'boolean':
+            case 'number':
+            case 'symbol':
+            case 'undefined':
+                return this._normalizeLiteral(from);
+            case 'object':
+                if ((from === null) || (from instanceof Date) || (from instanceof RegExp)) {
+                    return this._normalizeLiteral(from);
+                }
+                else if (Array.isArray(from)) {
+                    return this._normalizeArray(from);
+                }
+                else if (from instanceof Map) {
+                    return (0, result_1.succeed)(new Map(this._normalizeEntries(from.entries())));
+                }
+                else if (from instanceof Set) {
+                    return (0, result_1.succeed)(new Set(this._normalizeEntries(from.entries())));
+                }
+                const obj = {};
+                for (const e of this._normalizeEntries(Object.entries(from))) {
+                    obj[e[0]] = e[1];
+                }
+                return (0, result_1.succeed)(obj);
+        }
+        return (0, result_1.fail)(`normalize: Unexpected type - cannot normalize '${typeof from}'`);
+    }
+    /**
+     * Compares two property names from some object being normalized.
+     * @param k1 - First key to be compared.
+     * @param k2 - Second key to be compared.
+     * @returns `1` if `k1` is greater, `-1` if `k2` is greater and
+     * `0` if they are equal.
+     * @internal
+     */
+    _compareKeys(k1, k2) {
+        const cs1 = String(k1);
+        const cs2 = String(k2);
+        if (cs1 > cs2) {
+            return 1;
+        }
+        // istanbul ignore else
+        if (cs2 > cs1) {
+            return -1;
+        }
+        // istanbul ignore next
+        return 0;
+    }
+    /**
+     * Normalizes an array of object property entries (e.g. as returned by `Object.entries()`).
+     * @remarks
+     * Converts property names (entry key) to string and then sorts as string.
+     * @param entries - The entries to be normalized.
+     * @returns A normalized sorted array of entries.
+     * @internal
+     */
+    _normalizeEntries(entries) {
+        return Array.from(entries)
+            .sort((e1, e2) => this._compareKeys(e1[0], e2[0]))
+            .map((e) => [e[0], this.normalize(e[1])])
+            .filter((e) => e[1].isSuccess())
+            .map((e) => [e[0], e[1].getValueOrThrow()]);
+    }
+    _normalizeArray(from) {
+        return (0, result_1.mapResults)(from.map((v) => this.normalize(v)));
+    }
+    /**
+     * Normalizes the supplied literal value
+     * @param from - The literal value to be normalized.
+     * @returns A normalized value for the literal.
+     * @internal
+     */
+    _normalizeLiteral(from) {
+        // TODO: Apply configurable normalization rules
+        switch (typeof from) {
+            case 'string':
+                return (0, result_1.succeed)(from);
+            case 'bigint':
+            case 'boolean':
+            case 'number':
+            case 'symbol':
+            case 'undefined':
+                return (0, result_1.succeed)(from);
+        }
+        if (from === null) {
+            return (0, result_1.succeed)(from);
+        }
+        if (from instanceof Date) {
+            return (0, result_1.succeed)(from);
+        }
+        // istanbul ignore else
+        if (from instanceof RegExp) {
+            return (0, result_1.succeed)(from);
+        }
+        // istanbul ignore next
+        return (0, result_1.fail)(`cannot normalize ${JSON.stringify(from)}`);
+    }
+}
+exports.Normalizer = Normalizer;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"normalize.js","sourceRoot":"","sources":["../src/normalize.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2021 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nimport { Result, fail, mapResults, succeed } from './result';\n\nexport type Entry<T> = [string | number | symbol, T];\nexport type ResultEntry<T> = [string | number | symbol, Result<T>];\n\n/**\n * Normalizes an arbitrary JSON object\n * @public\n */\nexport class Normalizer {\n    /**\n     * Normalizes the supplied value\n     *\n     * @param from - The value to be normalized\n     * @returns A normalized version of the value\n     */\n    public normalize<T>(from: T): Result<T> {\n        switch (typeof from) {\n            case 'string':\n            case 'bigint':\n            case 'boolean':\n            case 'number':\n            case 'symbol':\n            case 'undefined':\n                return this._normalizeLiteral(from);\n            case 'object':\n                if ((from === null) || (from instanceof Date) || (from instanceof RegExp)) {\n                    return this._normalizeLiteral(from);\n                }\n                else if (Array.isArray(from)) {\n                    return this._normalizeArray(from) as unknown as Result<T>;\n                }\n                else if (from instanceof Map) {\n                    return succeed(new Map(this._normalizeEntries(from.entries())) as unknown as T);\n                }\n                else if (from instanceof Set) {\n                    return succeed(new Set(this._normalizeEntries(from.entries())) as unknown as T);\n                }\n                const obj: { [key in number | string | symbol]: unknown } = {};\n                for (const e of this._normalizeEntries(Object.entries(from as unknown as object))) {\n                    obj[e[0]] = e[1];\n                }\n                return succeed(obj as T);\n        }\n        return fail(`normalize: Unexpected type - cannot normalize '${typeof from}'`);\n    }\n\n    /**\n     * Compares two property names from some object being normalized.\n     * @param k1 - First key to be compared.\n     * @param k2 - Second key to be compared.\n     * @returns `1` if `k1` is greater, `-1` if `k2` is greater and\n     * `0` if they are equal.\n     * @internal\n     */\n    protected _compareKeys(k1: unknown, k2: unknown): number {\n        const cs1 = String(k1);\n        const cs2 = String(k2);\n        if (cs1 > cs2) {\n            return 1;\n        }\n        // istanbul ignore else\n        if (cs2 > cs1) {\n            return -1;\n        }\n\n        // istanbul ignore next\n        return 0;\n    }\n\n    /**\n     * Normalizes an array of object property entries (e.g. as returned by `Object.entries()`).\n     * @remarks\n     * Converts property names (entry key) to string and then sorts as string.\n     * @param entries - The entries to be normalized.\n     * @returns A normalized sorted array of entries.\n     * @internal\n     */\n    protected _normalizeEntries<T = unknown>(entries: Iterable<Entry<T>>): Entry<T>[] {\n        return Array.from(entries)\n            .sort((e1, e2) => this._compareKeys(e1[0], e2[0]))\n            .map((e) => [e[0], this.normalize(e[1])] as ResultEntry<T>)\n            .filter((e) => e[1].isSuccess())\n            .map((e) => [e[0], e[1].getValueOrThrow()]);\n    }\n\n    protected _normalizeArray(from: unknown[]): Result<unknown[]> {\n        return mapResults(from.map((v) => this.normalize(v)));\n    }\n\n    /**\n     * Normalizes the supplied literal value\n     * @param from - The literal value to be normalized.\n     * @returns A normalized value for the literal.\n     * @internal\n     */\n    protected _normalizeLiteral<T>(from: T): Result<T> {\n        // TODO: Apply configurable normalization rules\n        switch (typeof from) {\n            case 'string':\n                return succeed(from);\n            case 'bigint':\n            case 'boolean':\n            case 'number':\n            case 'symbol':\n            case 'undefined':\n                return succeed(from);\n        }\n        if (from === null) {\n            return succeed(from);\n        }\n        if (from instanceof Date) {\n            return succeed(from);\n        }\n        // istanbul ignore else\n        if (from instanceof RegExp) {\n            return succeed(from);\n        }\n        // istanbul ignore next\n        return fail(`cannot normalize ${JSON.stringify(from)}`);\n    }\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fgv/ts-utils",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "description": "Assorted Typescript Utilities",
   "main": "index.js",
   "scripts": {