@karmaniverous/jsonmap 1.0.1 → 2.0.1

package/README.md

@@ -39,7 +39,7 @@ The `map` object is a [POJO](https://masteringjs.io/tutorials/fundamentals/pojo)
 
 The transformation output will reflect the structure of your `map` object and include any static values. To add mapping logic, use a structured value that consists of an object with a single `$` key, like this:
 
-```js
+```ts
 const map = {
   foo: 'static value passed directly to output',
   // Structure passed directly to output.
@@ -111,47 +111,7 @@ const output = await jsonMap.transform(input);
 ```
 
 The [unit tests](https://github.com/karmaniverous/jsonmap/blob/main/lib/JsonMap/JsonMap.test.js) demonstrate this example in action.
-
-# API Documentation
-
-<a name="JsonMap"></a>
-
-## JsonMap
-JsonMap class to apply transformations to a JSON object
-
-**Kind**: global class  
-
-* [JsonMap](#JsonMap)
-    * [new JsonMap([map], [lib], [options])](#new_JsonMap_new)
-    * [.transform(input)](#JsonMap+transform) ⇒ <code>object</code>
-
-<a name="new_JsonMap_new"></a>
-
-### new JsonMap([map], [lib], [options])
-Creates an instance of JsonMap.
-
-
-| Param | Type | Description |
-| --- | --- | --- |
-| [map] | <code>object</code> | The data mapping configuration. |
-| [lib] | <code>object</code> | A collection of function libraries. |
-| [options] | <code>object</code> | Options object |
-| [options.ignore] | <code>string</code> | Regex pattern of keys to ignore. Defaults to '^\\$'. |
-| [options.logger] | <code>string</code> | Logger object |
-
-<a name="JsonMap+transform"></a>
-
-### jsonMap.transform(input) ⇒ <code>object</code>
-Transforms the input data according to the map configuration.
-
-**Kind**: instance method of [<code>JsonMap</code>](#JsonMap)  
-**Returns**: <code>object</code> - - The transformed data.  
-
-| Param | Type | Description |
-| --- | --- | --- |
-| input | <code>object</code> | The input data to be transformed. |
-
-
+
 ---
 
 See more great templates and other tools on

package/dist/index.cjs

@@ -0,0 +1,205 @@
+'use strict';
+
+var _ = require('lodash');
+var nanoid = require('nanoid');
+var tslog = require('tslog');
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol */
+
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __classPrivateFieldGet(receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+// Get package scope & name from package.json.
+var _a$1, _b$1, _c;
+const npmPackageRegex = /^(?:(?<packageScope>@[a-z0-9-~][a-z0-9-._~]*)\/)?(?<packageName>[a-z0-9-~][a-z0-9-._~]*)$/;
+const { packageScope, packageName } = ((_c = (_b$1 = (_a$1 = process.env.npm_package_name) === null || _a$1 === void 0 ? void 0 : _a$1.match(npmPackageRegex)) === null || _b$1 === void 0 ? void 0 : _b$1.groups) !== null && _c !== void 0 ? _c : {});
+
+var _a, _b;
+// These are the presefined tslog log levels. You can specify
+// LOG_LEVEL by any of the keys or values defined below.
+const logLevels = {
+    silly: 0,
+    trace: 1,
+    debug: 2,
+    info: 3,
+    warn: 4,
+    error: 5,
+    fatal: 6,
+};
+const integerLogLevel = parseInt((_a = process.env.LOG_LEVEL) !== null && _a !== void 0 ? _a : '');
+const resolvedLogLevel = Number.isNaN(integerLogLevel)
+    ? logLevels[((_b = process.env.LOG_LEVEL) !== null && _b !== void 0 ? _b : '').toLowerCase()]
+    : integerLogLevel;
+// Set your tslog instance options here! By default, logs are suppressed if LOG_LEVEL is invalid or undefined.
+// See https://tslog.js.org for more info.
+const logger = new tslog.Logger({
+    hideLogPositionForProduction: true,
+    minLevel: resolvedLogLevel,
+    name: packageName,
+    type: resolvedLogLevel === undefined ? 'hidden' : 'pretty',
+});
+
+var _JsonMap_instances, _JsonMap_transform, _JsonMap_resolvePath;
+// The transformation process leverages JSON.stringify and JSON.parse to eliminate circular references.
+const getJsonFns = () => {
+    const seen = new WeakSet();
+    const undefinedToken = nanoid.nanoid();
+    const replacer = (key, value) => {
+        if (typeof value === 'object' && value !== null) {
+            if (seen.has(value)) {
+                return 'CIRCULAR REFERENCE';
+            }
+            seen.add(value);
+            if (!_.isArrayLikeObject(value))
+                return Object.getOwnPropertyNames(value).reduce((v, p) => (Object.assign(Object.assign({}, v), { [p]: value[p] })), {});
+        }
+        return _.isUndefined(value) ? undefinedToken : value;
+    };
+    const reviver = (key, value) => value === undefinedToken ? undefined : value;
+    return { replacer, reviver };
+};
+/**
+ * JsonMap class to apply transformations to a JSON object
+ */
+class JsonMap {
+    constructor(map = {}, lib = {}, { ignore = /^\$/ } = {}) {
+        _JsonMap_instances.add(this);
+        this.map = map;
+        this.lib = lib;
+        this.ignore = _.isString(ignore) ? new RegExp(ignore) : ignore;
+    }
+    /**
+     * Transforms the input data according to the map configuration.
+     */
+    transform(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Sets the input data and initializes an empty output object
+            this.input = input;
+            this.output = {};
+            // Perform transformation & eliminate recursion from result.
+            const { replacer, reviver } = getJsonFns();
+            const result = JSON.parse(JSON.stringify(yield __classPrivateFieldGet(this, _JsonMap_instances, "m", _JsonMap_transform).call(this, this.map, this.input, this.output), replacer), reviver);
+            // Recursively eliminate non-string keys & string keys starting with $ and not in ignoreExclusions.
+            const deep = (value) => value instanceof Object && !_.isArray(value)
+                ? _.mapValues(_.pickBy(value, (v, k) => !this.ignore.test(k)), (value) => _.cloneDeepWith(value, deep))
+                : undefined;
+            return _.cloneDeepWith(result, deep);
+        });
+    }
+}
+_JsonMap_instances = new WeakSet(), _JsonMap_transform = function _JsonMap_transform(node_1, input_1, output_1) {
+    return __awaiter(this, arguments, void 0, function* (node, input, output, path = '') {
+        logger.debug('#transform params:\n', { node, input, output, path });
+        // Checks if the current node is an object and has only a '$' key
+        if (node instanceof Object && _.size(node) === 1 && '$' in node) {
+            // Retrieves the transformations to be applied (can be an array or a single object)
+            const transformations = _.castArray(node.$);
+            logger.debug('transformations:\n', transformations);
+            // Array to store the results of the transformations
+            const results = [];
+            // Iterates over each transformation
+            for (const transformation of transformations) {
+                logger.debug('processing transformation:\n', transformation);
+                // Resolves the object path for the transformation
+                const { obj: methodObj, path: methodPath } = __classPrivateFieldGet(this, _JsonMap_instances, "m", _JsonMap_resolvePath).call(this, transformation.method, results);
+                // Resolves the parameter paths for the transformation
+                const params = _.castArray(transformation.params).map((param) => {
+                    const { obj: paramObj, path: paramPath } = __classPrivateFieldGet(this, _JsonMap_instances, "m", _JsonMap_resolvePath).call(this, param, results);
+                    return paramObj
+                        ? paramPath
+                            ? _.get(paramObj, paramPath)
+                            : paramObj
+                        : paramPath;
+                });
+                logger.debug('resolved transformation params:\n', params);
+                // Calls the specified method on the resolved object with the resolved parameters
+                const result = (yield _.invoke(methodObj, methodPath, ...params));
+                logger.debug('transformation result:\n', result);
+                // Stores the result of the transformation
+                results.unshift(result);
+            }
+            // Sets the output at the specified path to the last result of the transformations & returns.
+            _.set(output, path, results[0]);
+            logger.debug('updated output:\n', output);
+            return results[0];
+        }
+        // Checks if the current node is an object
+        if (_.isObject(node)) {
+            // Creates an empty array or object based on whether the current node is an array or not
+            const transformedNode = (Array.isArray(node) ? [] : {});
+            // Iterates over each key-value pair in the current node in ascending order by key
+            for (const [key, value] of _.sortBy(Object.entries(node), ([key]) => key)) {
+                // Constructs the current path by appending the current key to the previous path (if any)
+                const currentPath = path ? `${path}.${key}` : key;
+                // Recursively calls #transform with the current value, input, output, and path
+                // Assigns the transformed value to the corresponding key in the transformedNode
+                transformedNode[key] = yield __classPrivateFieldGet(this, _JsonMap_instances, "m", _JsonMap_transform).call(this, value, input, output, currentPath);
+            }
+            // Sets the output at the specified path to the transformedNode & returnsd.
+            _.set(output, path, transformedNode);
+            return transformedNode;
+        }
+        // Sets the output at the specified path to the current node & returns.
+        _.set(output, path, node);
+        return node;
+    });
+}, _JsonMap_resolvePath = function _JsonMap_resolvePath(path, results) {
+    // If the path is not a string, return it as is
+    if (!_.isString(path)) {
+        return { path };
+    }
+    // Defines special patterns and their corresponding resolution functions
+    const patterns = {
+        '^\\$\\.(?<obj>lib|input|output)\\.?(?<path>.*)': ({ obj, path }) => ({
+            obj: this[obj],
+            path,
+        }),
+        '^\\$(?<path>\\[\\d+\\].*)': ({ path }) => ({
+            obj: results,
+            path,
+        }),
+    };
+    // Iterates over the special patterns
+    for (const [pattern, resolve] of Object.entries(patterns)) {
+        const match = path.match(pattern);
+        if (match === null || match === void 0 ? void 0 : match.groups)
+            return resolve(match.groups);
+    }
+    // Returns the path as is if it does not match any special patterns
+    return { path };
+};
+
+exports.JsonMap = JsonMap;

package/dist/index.d.cts

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+
+interface JsonMapOptions {
+    ignore?: string | RegExp;
+}
+declare const JsonMapDynamic: z.ZodObject<{
+    $: z.ZodUnion<[z.ZodObject<{
+        method: z.ZodString;
+        params: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+    }, "strip", z.ZodTypeAny, {
+        method: string;
+        params: string | string[];
+    }, {
+        method: string;
+        params: string | string[];
+    }>, z.ZodArray<z.ZodObject<{
+        method: z.ZodString;
+        params: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+    }, "strip", z.ZodTypeAny, {
+        method: string;
+        params: string | string[];
+    }, {
+        method: string;
+        params: string | string[];
+    }>, "many">]>;
+}, "strip", z.ZodTypeAny, {
+    $: {
+        method: string;
+        params: string | string[];
+    } | {
+        method: string;
+        params: string | string[];
+    }[];
+}, {
+    $: {
+        method: string;
+        params: string | string[];
+    } | {
+        method: string;
+        params: string | string[];
+    }[];
+}>;
+type JsonMapDynamic = z.infer<typeof JsonMapDynamic>;
+declare const literalSchema: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+type Literal = z.infer<typeof literalSchema>;
+type Json = Literal | {
+    [key: string]: Json;
+} | Json[];
+type JsonMapLib = {
+    [key: string]: JsonMapLib | ((x: any) => any);
+} | JsonMapLib[];
+type JsonMapMap = Literal | {
+    [key: string]: JsonMapMap | JsonMapDynamic;
+} | JsonMapMap[];
+
+/**
+ * JsonMap class to apply transformations to a JSON object
+ */
+declare class JsonMap {
+    #private;
+    private map;
+    private lib;
+    private ignore;
+    private input;
+    private output;
+    constructor(map?: JsonMapMap, lib?: JsonMapLib, { ignore }?: JsonMapOptions);
+    /**
+     * Transforms the input data according to the map configuration.
+     */
+    transform(input: Json): Promise<Json>;
+}
+
+export { JsonMap };

package/dist/index.d.mts

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+
+interface JsonMapOptions {
+    ignore?: string | RegExp;
+}
+declare const JsonMapDynamic: z.ZodObject<{
+    $: z.ZodUnion<[z.ZodObject<{
+        method: z.ZodString;
+        params: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+    }, "strip", z.ZodTypeAny, {
+        method: string;
+        params: string | string[];
+    }, {
+        method: string;
+        params: string | string[];
+    }>, z.ZodArray<z.ZodObject<{
+        method: z.ZodString;
+        params: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+    }, "strip", z.ZodTypeAny, {
+        method: string;
+        params: string | string[];
+    }, {
+        method: string;
+        params: string | string[];
+    }>, "many">]>;
+}, "strip", z.ZodTypeAny, {
+    $: {
+        method: string;
+        params: string | string[];
+    } | {
+        method: string;
+        params: string | string[];
+    }[];
+}, {
+    $: {
+        method: string;
+        params: string | string[];
+    } | {
+        method: string;
+        params: string | string[];
+    }[];
+}>;
+type JsonMapDynamic = z.infer<typeof JsonMapDynamic>;
+declare const literalSchema: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+type Literal = z.infer<typeof literalSchema>;
+type Json = Literal | {
+    [key: string]: Json;
+} | Json[];
+type JsonMapLib = {
+    [key: string]: JsonMapLib | ((x: any) => any);
+} | JsonMapLib[];
+type JsonMapMap = Literal | {
+    [key: string]: JsonMapMap | JsonMapDynamic;
+} | JsonMapMap[];
+
+/**
+ * JsonMap class to apply transformations to a JSON object
+ */
+declare class JsonMap {
+    #private;
+    private map;
+    private lib;
+    private ignore;
+    private input;
+    private output;
+    constructor(map?: JsonMapMap, lib?: JsonMapLib, { ignore }?: JsonMapOptions);
+    /**
+     * Transforms the input data according to the map configuration.
+     */
+    transform(input: Json): Promise<Json>;
+}
+
+export { JsonMap };

package/dist/index.d.ts

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+
+interface JsonMapOptions {
+    ignore?: string | RegExp;
+}
+declare const JsonMapDynamic: z.ZodObject<{
+    $: z.ZodUnion<[z.ZodObject<{
+        method: z.ZodString;
+        params: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+    }, "strip", z.ZodTypeAny, {
+        method: string;
+        params: string | string[];
+    }, {
+        method: string;
+        params: string | string[];
+    }>, z.ZodArray<z.ZodObject<{
+        method: z.ZodString;
+        params: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+    }, "strip", z.ZodTypeAny, {
+        method: string;
+        params: string | string[];
+    }, {
+        method: string;
+        params: string | string[];
+    }>, "many">]>;
+}, "strip", z.ZodTypeAny, {
+    $: {
+        method: string;
+        params: string | string[];
+    } | {
+        method: string;
+        params: string | string[];
+    }[];
+}, {
+    $: {
+        method: string;
+        params: string | string[];
+    } | {
+        method: string;
+        params: string | string[];
+    }[];
+}>;
+type JsonMapDynamic = z.infer<typeof JsonMapDynamic>;
+declare const literalSchema: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+type Literal = z.infer<typeof literalSchema>;
+type Json = Literal | {
+    [key: string]: Json;
+} | Json[];
+type JsonMapLib = {
+    [key: string]: JsonMapLib | ((x: any) => any);
+} | JsonMapLib[];
+type JsonMapMap = Literal | {
+    [key: string]: JsonMapMap | JsonMapDynamic;
+} | JsonMapMap[];
+
+/**
+ * JsonMap class to apply transformations to a JSON object
+ */
+declare class JsonMap {
+    #private;
+    private map;
+    private lib;
+    private ignore;
+    private input;
+    private output;
+    constructor(map?: JsonMapMap, lib?: JsonMapLib, { ignore }?: JsonMapOptions);
+    /**
+     * Transforms the input data according to the map configuration.
+     */
+    transform(input: Json): Promise<Json>;
+}
+
+export { JsonMap };