@edirect/template 11.0.45 → 11.0.46

package/dist/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@edirect/template",
+  "version": "11.0.46",
+  "main": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/src/index.js",
+      "default": "./dist/src/index.js",
+      "require": "./dist/src/index.js",
+      "types": "./dist/src/index.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "lodash": "^4.17.23",
+    "tslib": "^2.8.1"
+  },
+  "devDependencies": {
+    "@types/lodash": "^4.17.23",
+    "@types/node": "^25.0.10"
+  },
+  "type": "commonjs"
+}

package/dist/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from './templateModule';
+export * from './templateModule/interfaces';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,6BAA6B,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./templateModule"), exports);
+tslib_1.__exportStar(require("./templateModule/interfaces"), exports);

package/dist/src/templateModule/index.d.ts

@@ -0,0 +1,27 @@
+import { ITemplateModule, ITemplateOptions, ITransformer } from './interfaces';
+export declare class TemplateModule implements ITemplateModule {
+    private context;
+    private template;
+    private transformers;
+    private options;
+    setContext(context: Record<string, unknown>): void;
+    setTemplate(template: Record<string, unknown>): void;
+    setTransformers(transformers: ITransformer): void;
+    setOptions(options: ITemplateOptions): void;
+    verifyTransformer(transformer: ITransformer, methodName: string): boolean;
+    runTransformer(transformer: string, value?: unknown): unknown | null;
+    runTransformerWithParams(transformer: string, params: unknown[], value?: unknown): unknown | null;
+    setValueByCondition<U>(object: U, key: string, value: unknown, allowNull?: boolean): U;
+    isTransformer(object: Record<string, unknown>): boolean;
+    isTransformers(object: Record<string, unknown>): boolean;
+    isStaticArrayMapper(object: Record<string, unknown>): boolean;
+    isDynamicArrayMapper(object: Record<string, unknown>): boolean;
+    isValidObject(object: object): boolean;
+    checkValue(value: unknown, allowNull?: boolean): boolean;
+    containsVar(value: string): boolean;
+    getVarOnConst(varName: string, context: object): unknown;
+    simpleValueToObject(value: unknown): Record<string, unknown>;
+    transformPayload<T>(dataSource: object, template?: Record<string, unknown>, rootData?: object): T;
+    private applySequentialTransformers;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/src/templateModule/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/templateModule/index.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,eAAe,EACf,gBAAgB,EAChB,YAAY,EAGb,MAAM,cAAc,CAAC;AAEtB,qBAAa,cAAe,YAAW,eAAe;IACpD,OAAO,CAAC,OAAO,CAA+B;IAC9C,OAAO,CAAC,QAAQ,CAA+B;IAC/C,OAAO,CAAC,YAAY,CAAoB;IACxC,OAAO,CAAC,OAAO,CAAwB;IAEvC,UAAU,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAIlD,WAAW,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAIpD,eAAe,CAAC,YAAY,EAAE,YAAY,GAAG,IAAI;IAIjD,UAAU,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI;IAI3C,iBAAiB,CAAC,WAAW,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO;IAQzE,cAAc,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,IAAI;IAOpE,wBAAwB,CACtB,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,OAAO,EAAE,EACjB,KAAK,CAAC,EAAE,OAAO,GACd,OAAO,GAAG,IAAI;IAUjB,mBAAmB,CAAC,CAAC,EACnB,MAAM,EAAE,CAAC,EACT,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,OAAO,EACd,SAAS,UAAQ,GAChB,CAAC;IASJ,aAAa,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO;IAUvD,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO;IAMxD,mBAAmB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO;IAI7D,oBAAoB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO;IAI9D,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAUtC,UAAU,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,UAAQ,GAAG,OAAO;IActD,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAInC,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO;IAKxD,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAIrD,gBAAgB,CAAC,CAAC,EACvB,UAAU,EAAE,MAAM,EAClB,QAAQ,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAiB,EACjD,QAAQ,CAAC,EAAE,MAAM,GAChB,CAAC;IAwLJ,OAAO,CAAC,2BAA2B;CA4HpC"}

package/dist/src/templateModule/index.js

@@ -0,0 +1,282 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateModule = void 0;
+const lodash_1 = require("lodash");
+class TemplateModule {
+    context = {};
+    template = {};
+    transformers = {};
+    options = {};
+    setContext(context) {
+        this.context = context;
+    }
+    setTemplate(template) {
+        this.template = template;
+    }
+    setTransformers(transformers) {
+        this.transformers = transformers;
+    }
+    setOptions(options) {
+        this.options = options;
+    }
+    verifyTransformer(transformer, methodName) {
+        return !!(transformer &&
+            transformer[methodName] &&
+            typeof transformer[methodName] === 'function');
+    }
+    runTransformer(transformer, value) {
+        if (this.verifyTransformer(this.transformers, transformer)) {
+            return this.transformers[transformer]({ context: this.context, value });
+        }
+        return undefined;
+    }
+    runTransformerWithParams(transformer, params, value) {
+        if (this.verifyTransformer(this.transformers, transformer)) {
+            return this.transformers[transformer]({ context: this.context, value }, ...params);
+        }
+        return null;
+    }
+    setValueByCondition(object, key, value, allowNull = false) {
+        return this.checkValue(value, allowNull)
+            ? {
+                ...object,
+                [key]: value,
+            }
+            : object;
+    }
+    isTransformer(object) {
+        return !!((0, lodash_1.has)(object, 'transformer') ||
+            (0, lodash_1.has)(object, 'fields') ||
+            (0, lodash_1.has)(object, 'defaultValue') ||
+            (0, lodash_1.has)(object, 'transformers') ||
+            ((0, lodash_1.has)(object, 'transformerParams') && (0, lodash_1.has)(object, 'transformer')));
+    }
+    isTransformers(object) {
+        return !!((0, lodash_1.has)(object, 'transformers') && Array.isArray(object.transformers));
+    }
+    isStaticArrayMapper(object) {
+        return Array.isArray(object);
+    }
+    isDynamicArrayMapper(object) {
+        return !!((0, lodash_1.has)(object, 'arraySource') && (0, lodash_1.has)(object, 'arrayTemplate'));
+    }
+    isValidObject(object) {
+        return (!!object &&
+            typeof object === 'object' &&
+            Object.keys(object).length > 0 &&
+            Object.getPrototypeOf(object) !== null &&
+            Object.getPrototypeOf(object) === Object.prototype);
+    }
+    checkValue(value, allowNull = false) {
+        const omitEmptyFields = this.options?.omitEmptyFields ?? false;
+        return !!(value ||
+            allowNull ||
+            typeof value === 'boolean' ||
+            typeof value === 'number' ||
+            (omitEmptyFields
+                ? typeof value === 'string' && value !== ''
+                : typeof value === 'string'));
+    }
+    containsVar(value) {
+        return !!value.match(/^\$\{[a-z_0-9\-.]+\}$/gi);
+    }
+    getVarOnConst(varName, context) {
+        varName = varName.substring(2, varName.length - 1);
+        return (0, lodash_1.get)(context, varName);
+    }
+    simpleValueToObject(value) {
+        return { value };
+    }
+    transformPayload(dataSource, template = this.template, rootData) {
+        if (!template)
+            return {};
+        if (rootData === undefined)
+            rootData = dataSource;
+        return Object.keys(template).reduce((acc, key) => {
+            const target = template[key];
+            let value = (0, lodash_1.get)(dataSource, target);
+            // handle static array mapper
+            if (this.isStaticArrayMapper(target)) {
+                const finalArray = [];
+                const arrayTargets = target;
+                for (const arrayTemplate of arrayTargets) {
+                    if (this.isValidObject(arrayTemplate)) {
+                        value = this.transformPayload(dataSource, arrayTemplate);
+                        if (this.checkValue(value) &&
+                            typeof value === 'object' &&
+                            value !== null &&
+                            this.isValidObject(value))
+                            finalArray.push(value);
+                    }
+                }
+                return this.setValueByCondition(acc, key, finalArray);
+            }
+            // handle dynamic array mapper
+            if (this.isDynamicArrayMapper(target)) {
+                const { arraySource, arrayTemplate, ignoreIndexs } = target;
+                value = (0, lodash_1.get)(dataSource, arraySource);
+                if ((0, lodash_1.isArray)(value)) {
+                    const finalArray = [];
+                    for (const [index, arrayItem] of value.entries()) {
+                        if (ignoreIndexs &&
+                            Array.isArray(ignoreIndexs) &&
+                            ignoreIndexs.includes(index))
+                            continue;
+                        if (target.simpleArray) {
+                            const source = this.simpleValueToObject(arrayItem);
+                            value = this.transformPayload(source, arrayTemplate);
+                        }
+                        else {
+                            value = this.transformPayload(arrayItem, arrayTemplate, rootData);
+                        }
+                        if (this.checkValue(value) &&
+                            typeof value === 'object' &&
+                            value !== null &&
+                            this.isValidObject(value))
+                            finalArray.push(value);
+                    }
+                    return this.setValueByCondition(acc, key, finalArray);
+                }
+                return this.setValueByCondition(acc, key, []);
+            }
+            // handle nested object + transformers
+            if (this.isValidObject(target)) {
+                // identify a nested object
+                if (!this.isTransformer(target)) {
+                    return this.setValueByCondition(acc, key, this.transformPayload(dataSource, target));
+                }
+                // Handle array of transformers
+                if ((0, lodash_1.has)(target, 'transformers') && Array.isArray(target.transformers)) {
+                    value = this.applySequentialTransformers(target, dataSource, rootData);
+                }
+                else {
+                    // Handle single transformer (backward compatibility)
+                    const { fields, transformer, transformerParams, defaultValue, allowNull, } = target;
+                    const transformedTransformParams = [];
+                    if (transformerParams && Array.isArray(transformerParams)) {
+                        transformedTransformParams.push(...transformerParams.map(param => {
+                            if (!(0, lodash_1.isString)(param) || !this.containsVar(param))
+                                return param;
+                            return (this.getVarOnConst(param, dataSource) ||
+                                this.getVarOnConst(param, rootData));
+                        }));
+                    }
+                    if (fields && Array.isArray(fields)) {
+                        for (const field of fields) {
+                            value = (0, lodash_1.get)(dataSource, field);
+                            if (transformer && transformedTransformParams.length)
+                                value = this.runTransformerWithParams(transformer, transformedTransformParams, value);
+                            else if (transformer)
+                                value = this.runTransformer(transformer, value);
+                            if (this.checkValue(value, !!allowNull))
+                                break;
+                        }
+                    }
+                    else {
+                        if (transformer && transformedTransformParams.length)
+                            value = this.runTransformerWithParams(transformer, transformedTransformParams);
+                        else if (transformer)
+                            value = this.runTransformer(transformer);
+                    }
+                    value = this.checkValue(value, !!allowNull) ? value : defaultValue;
+                }
+                // Use the allowNull value from the last transformer or target object
+                const useAllowNull = (0, lodash_1.has)(target, 'transformers') && Array.isArray(target.transformers)
+                    ? // Find the last transformer that's not a DynamicArrayMapper
+                        !!target.transformers
+                            .filter(t => !this.isDynamicArrayMapper(t))
+                            .slice(-1)[0] &&
+                            'allowNull' in
+                                target.transformers
+                                    .filter(t => !this.isDynamicArrayMapper(t))
+                                    .slice(-1)[0]
+                            ? target.transformers
+                                .filter(t => !this.isDynamicArrayMapper(t))
+                                .slice(-1)[0].allowNull
+                            : false
+                    : !!target.allowNull;
+                return this.setValueByCondition(acc, key, value, useAllowNull);
+            }
+            // handle simple mapper
+            return this.setValueByCondition(acc, key, value);
+        }, {});
+    }
+    applySequentialTransformers(target, dataSource, rootData) {
+        let transformedValue = null;
+        const transformers = target.transformers;
+        for (const transformer of transformers) {
+            // Handle DynamicArrayMapper within the transformers array
+            if (this.isDynamicArrayMapper(transformer)) {
+                const dynamicArrayMapper = transformer;
+                const { arraySource, arrayTemplate, ignoreIndexs, simpleArray } = dynamicArrayMapper;
+                const arrayData = (0, lodash_1.get)(dataSource, arraySource);
+                if ((0, lodash_1.isArray)(arrayData)) {
+                    const finalArray = [];
+                    for (const [index, arrayItem] of arrayData.entries()) {
+                        if (ignoreIndexs && ignoreIndexs.includes(index))
+                            continue;
+                        let processedItem;
+                        if (simpleArray) {
+                            const source = this.simpleValueToObject(arrayItem);
+                            processedItem = this.transformPayload(source, arrayTemplate);
+                        }
+                        else {
+                            processedItem = this.transformPayload(arrayItem, arrayTemplate, rootData);
+                        }
+                        if (this.checkValue(processedItem) &&
+                            typeof processedItem === 'object' &&
+                            processedItem !== null &&
+                            this.isValidObject(processedItem)) {
+                            finalArray.push(processedItem);
+                        }
+                    }
+                    transformedValue = finalArray;
+                }
+                else {
+                    transformedValue = [];
+                }
+                continue;
+            }
+            // Handle standard transformer
+            const { fields, transformer: transformerName, transformerParams, defaultValue, allowNull, } = transformer;
+            const transformedTransformParams = [];
+            if (transformerParams && Array.isArray(transformerParams)) {
+                transformedTransformParams.push(...transformerParams.map(param => {
+                    if (!(0, lodash_1.isString)(param) || !this.containsVar(param))
+                        return param;
+                    return (this.getVarOnConst(param, dataSource) ||
+                        this.getVarOnConst(param, rootData));
+                }));
+            }
+            if (fields && Array.isArray(fields)) {
+                for (const field of fields) {
+                    transformedValue =
+                        transformedValue === null
+                            ? (0, lodash_1.get)(dataSource, field)
+                            : transformedValue;
+                    if (transformerName && transformedTransformParams.length) {
+                        transformedValue = this.runTransformerWithParams(transformerName, transformedTransformParams, transformedValue);
+                    }
+                    else if (transformerName) {
+                        transformedValue = this.runTransformer(transformerName, transformedValue);
+                    }
+                    if (this.checkValue(transformedValue, !!allowNull))
+                        break;
+                }
+            }
+            else {
+                if (transformerName && transformedTransformParams.length) {
+                    transformedValue = this.runTransformerWithParams(transformerName, transformedTransformParams, transformedValue);
+                }
+                else if (transformerName) {
+                    transformedValue = this.runTransformer(transformerName, transformedValue);
+                }
+            }
+            if (!this.checkValue(transformedValue, !!allowNull)) {
+                transformedValue = defaultValue;
+            }
+        }
+        return transformedValue;
+    }
+}
+exports.TemplateModule = TemplateModule;

package/dist/src/templateModule/interfaces.d.ts

@@ -0,0 +1,41 @@
+export interface ITransformerParams {
+    context?: Record<string, unknown>;
+    value?: unknown;
+}
+export interface ITransformer {
+    [x: string]: ({ context, value }: ITransformerParams, ...params: unknown[]) => unknown;
+}
+export interface IDynamicArrayMapper {
+    arraySource: string;
+    arrayTemplate: Record<string, unknown>;
+    ignoreIndexs?: number[];
+    simpleArray?: boolean;
+}
+export interface ITransformerDefinition {
+    fields?: string[];
+    transformer: string;
+    transformerParams?: unknown[];
+    defaultValue?: unknown;
+    allowNull?: boolean;
+}
+export interface ITemplateOptions {
+    omitEmptyFields?: boolean;
+}
+export type TransformerElement = ITransformerDefinition | IDynamicArrayMapper;
+export interface ITemplateModule {
+    setContext(context: Record<string, unknown>): void;
+    setTemplate(template: Record<string, unknown>): void;
+    setTransformers(transformers: ITransformer): void;
+    setOptions(settings: ITemplateOptions): void;
+    verifyTransformer(transformer: ITransformer, methodName: string): boolean;
+    runTransformer(transformer: string, value?: unknown): unknown | null;
+    setValueByCondition<U>(object: U, key: string, value: unknown): U;
+    isTransformer(object: Record<string, unknown>): boolean;
+    isTransformers(object: Record<string, unknown>): boolean;
+    isStaticArrayMapper(object: Record<string, unknown>): boolean;
+    isDynamicArrayMapper(object: Record<string, unknown>): boolean;
+    isValidObject(object: object): boolean;
+    checkValue(value: unknown): boolean;
+    transformPayload<T>(obj: object, template?: Record<string, unknown>): T;
+}
+//# sourceMappingURL=interfaces.d.ts.map

package/dist/src/templateModule/interfaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interfaces.d.ts","sourceRoot":"","sources":["../../../src/templateModule/interfaces.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,kBAAkB;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,YAAY;IAC3B,CAAC,CAAC,EAAE,MAAM,GAAG,CACX,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,kBAAkB,EACtC,GAAG,MAAM,EAAE,OAAO,EAAE,KACjB,OAAO,CAAC;CACd;AAED,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACvC,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,sBAAsB;IACrC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,CAAC,EAAE,OAAO,EAAE,CAAC;IAC9B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,gBAAgB;IAC/B,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,MAAM,kBAAkB,GAAG,sBAAsB,GAAG,mBAAmB,CAAC;AAE9E,MAAM,WAAW,eAAe;IAC9B,UAAU,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACnD,WAAW,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACrD,eAAe,CAAC,YAAY,EAAE,YAAY,GAAG,IAAI,CAAC;IAClD,UAAU,CAAC,QAAQ,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAC7C,iBAAiB,CAAC,WAAW,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC;IAC1E,cAAc,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,IAAI,CAAC;IACrE,mBAAmB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,CAAC,CAAC;IAClE,aAAa,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC;IACxD,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC;IACzD,mBAAmB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC;IAC9D,oBAAoB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC;IAC/D,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;IACvC,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC;IACpC,gBAAgB,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC;CACzE"}

package/dist/src/templateModule/interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/tsconfig.lib.tsbuildinfo

@@ -0,0 +1 @@
+{"version":"5.9.3"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@edirect/template",
-  "version": "11.0.45",
+  "version": "11.0.46",
   "packageScope": "@edirect",
   "main": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",