taon 0.0.0 → 18.0.12

package/client/esm2022/lib/entity-process.mjs

@@ -0,0 +1,207 @@
+import { _ } from 'tnp-core/browser';
+import { Symbols } from './symbols';
+import { walk } from 'lodash-walk-object/browser';
+import { config } from 'tnp-config/browser';
+import { JSON10 } from 'json10/browser';
+import { ClassHelpers } from './helpers/class-helpers';
+import { Mapping } from 'ng2-rest/browser';
+/**
+ * @deprecated
+ */
+export const getTransformFunction = (target) => {
+    if (!target) {
+        return;
+    }
+    if (!target) {
+        return void 0;
+    }
+    const configs = ClassHelpers.getControllerConfigs(target);
+    const functions = configs
+        .map(c => {
+        if (_.isFunction(c.browserTransformFn)) {
+            return c.browserTransformFn;
+        }
+    })
+        .filter(f => _.isFunction(f));
+    return functions.length === 0
+        ? void 0
+        : function (entity) {
+            for (let index = functions.length - 1; index >= 0; index--) {
+                const transformFun = functions[index];
+                transformFun(entity);
+            }
+            return entity;
+        };
+};
+/**
+ * @deprecated
+ */
+export const singleTransform = (json) => {
+    let ptarget = ClassHelpers.getClassFnFromObject(json);
+    let pbrowserTransformFn = getTransformFunction(ptarget);
+    if (pbrowserTransformFn) {
+        const newValue = pbrowserTransformFn(json);
+        if (!_.isObject(newValue)) {
+            console.error(`Please return object in transform function for class: ` +
+                `${ClassHelpers.getName(json)}`);
+        }
+        else {
+            json = newValue;
+        }
+    }
+    return json;
+};
+export class EntityProcess {
+    static async init(result, response) {
+        return await new EntityProcess(result, response).run();
+    }
+    constructor(
+    /**
+     * Data from backend
+     */
+    result, response) {
+        this.result = result;
+        this.response = response;
+        /**
+         * Say yes to:
+         * - circural object
+         * - transform browser fn in decorator
+         */
+        this.advancedManipulation = false;
+        this.circural = [];
+    }
+    checkAdvancedManiupulation() {
+        if (_.isFunction(this.result)) {
+            this.advancedManipulation = true;
+            this.result = this.result();
+        }
+    }
+    async run() {
+        this.checkAdvancedManiupulation();
+        this.data = this.result;
+        if (_.isObject(this.result)) {
+            if (this.advancedManipulation) {
+                this.applayTransformFn();
+            }
+            this.setHeaders();
+        }
+        this.send();
+    }
+    applayTransformFn() {
+        if (_.isObject(this.data) && !_.isArray(this.data)) {
+            this.data = singleTransform(this.data);
+        }
+        const { include } = { include: [] };
+        walk.Object(this.data, (value, lodashPath, changeValue, { skipObject, isCircural }) => {
+            if (!isCircural) {
+                if (!_.isArray(value) && _.isObject(value)) {
+                    changeValue(singleTransform(value));
+                }
+            }
+        }, { checkCircural: true, breadthWalk: true, include });
+        const { circs } = walk.Object(this.data, void 0, {
+            checkCircural: true,
+            breadthWalk: true,
+            include,
+        });
+        this.circural = circs;
+    }
+    setHeaders() {
+        const { include } = { include: [] };
+        const className = ClassHelpers.getName(this.data);
+        const doNothing = _.isNil(this.data) ||
+            [
+                'Object',
+                '',
+            ].includes(className);
+        if (!doNothing) {
+            const cleaned = JSON10.cleaned(this.data, void 0, {
+                breadthWalk: true,
+                include,
+            });
+            this.entityMapping = Mapping.decode(cleaned, !this.advancedManipulation);
+            this.response.set(Symbols.old.MAPPING_CONFIG_HEADER, JSON.stringify(this.entityMapping));
+            if (this.advancedManipulation) {
+                this.response.set(Symbols.old.CIRCURAL_OBJECTS_MAP_BODY, JSON.stringify(this.circural));
+            }
+        }
+    }
+    send() {
+        if (!_.isObject(this.data)) {
+            if (_.isNumber(this.data)) {
+                this.response.send(this.data.toString());
+            }
+            else {
+                this.response.send(this.data);
+            }
+            return;
+        }
+        if (this.advancedManipulation) {
+            const browserKey = config.folder.browser;
+            let toSend = _.isArray(this.data) ? [] : {};
+            const { include = [], exclude = [] } = { include: [], exclude: [] };
+            walk.Object(this.data, (value, lodashPath, changeVAlue, { isCircural, skipObject }) => {
+                if (isCircural) {
+                    _.set(toSend, lodashPath, null);
+                }
+                else {
+                    const fun = getTransformFunction(ClassHelpers.getClassFnFromObject(value));
+                    if (_.isFunction(fun)) {
+                        _.set(toSend, `${lodashPath}.${browserKey}`, value[browserKey]);
+                        const indexProp = ClassHelpers.getUniquKey(value);
+                        _.set(toSend, `${lodashPath}.${indexProp}`, value[indexProp]);
+                    }
+                    else {
+                        _.set(toSend, lodashPath, value);
+                    }
+                }
+            }, { checkCircural: true, breadthWalk: true, include });
+            if (!_.isArray(this.data)) {
+                let funParent = getTransformFunction(ClassHelpers.getClassFnFromObject(this.data));
+                if (_.isFunction(funParent)) {
+                    toSend = {
+                        [browserKey]: toSend[browserKey],
+                    };
+                }
+                Object.keys(this.data).forEach(prop => {
+                    if (prop !== browserKey) {
+                        const v = this.data[prop];
+                        if (!((include.length > 0 && !include.includes(prop)) ||
+                            (exclude.length > 0 && exclude.includes(prop)))) {
+                            if (ClassHelpers.isContextClassObject(v) &&
+                                _.isFunction(getTransformFunction(ClassHelpers.getClassFnFromObject(v)))) {
+                                toSend[prop] = {
+                                    [browserKey]: v[browserKey],
+                                };
+                                const indexProp = ClassHelpers.getUniquKey(v);
+                                toSend[prop][indexProp] = this.data[prop][indexProp];
+                                for (const key in v) {
+                                    if (_.isObject(v) &&
+                                        v.hasOwnProperty(key) &&
+                                        ![indexProp, config.folder.browser].includes(key) &&
+                                        (_.isString(v[key]) ||
+                                            _.isNumber(v[key]) ||
+                                            _.isDate(v[key]) ||
+                                            _.isNull(v[key]) ||
+                                            _.isBoolean(v[key]))) {
+                                        toSend[prop][key] = v[key];
+                                    }
+                                }
+                            }
+                            else {
+                                toSend[prop] = v;
+                            }
+                        }
+                    }
+                });
+            }
+            this.response.json(toSend);
+        }
+        else {
+            this.response.json(this.data);
+        }
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon lib/entity-process.ts
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entity-process.js","sourceRoot":"","sources":["../../../../tmp-libs-for-dist/taon/projects/taon/src/lib/entity-process.ts"],"names":[],"mappings":"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","sourcesContent":["\n\n\nimport { _ } from 'tnp-core/browser';\nimport { Symbols } from './symbols';\nimport { walk } from 'lodash-walk-object/browser';\nimport { config } from 'tnp-config/browser';\nimport { JSON10 } from 'json10/browser';\nimport { ClassHelpers } from './helpers/class-helpers';\nimport { Mapping } from 'ng2-rest/browser';\nimport { Response } from 'express';\n\n\n\n/**\n * @deprecated\n */\nexport const getTransformFunction = (target: Function) => {\n  if (!target) {\n    return;\n  }\n\n\n\n\n  if (!target) {\n    return void 0;\n  }\n  const configs = ClassHelpers.getControllerConfigs(target);\n\n  const functions = configs\n    .map(c => {\n      if (_.isFunction(c.browserTransformFn)) {\n        return c.browserTransformFn;\n      }\n    })\n    .filter(f => _.isFunction(f));\n  return functions.length === 0\n    ? void 0\n    : function (entity) {\n        for (let index = functions.length - 1; index >= 0; index--) {\n          const transformFun = functions[index];\n          transformFun(entity);\n        }\n        return entity;\n      };\n};\n\n\n\n/**\n * @deprecated\n */\nexport const singleTransform = (json: any) => {\n  let ptarget = ClassHelpers.getClassFnFromObject(json);\n  let pbrowserTransformFn = getTransformFunction(ptarget);\n  if (pbrowserTransformFn) {\n    const newValue = pbrowserTransformFn(json);\n    if (!_.isObject(newValue)) {\n      console.error(\n        `Please return object in transform function for class: ` +\n          `${ClassHelpers.getName(json)}`,\n      );\n    } else {\n      json = newValue;\n    }\n  }\n  return json;\n};\n\n\nexport class EntityProcess {\n\n  static async init(result: any, response: Response) {\n    return await new EntityProcess(result, response).run();\n  }\n\n\n\n  /**\n   * Data to send\n   */\n  data: any;\n\n  /**\n   * Say yes to:\n   * - circural object\n   * - transform browser fn in decorator\n   */\n  private advancedManipulation: boolean = false;\n  private entityMapping: any;\n  private circural = [];\n\n\n\n  constructor(\n    /**\n     * Data from backend\n     */\n    private result: any,\n    private response: Response,\n  ) {}\n\n\n\n  private checkAdvancedManiupulation() {\n    if (_.isFunction(this.result)) {\n      this.advancedManipulation = true;\n      this.result = this.result();\n    }\n  }\n\n\n\n  public async run() {\n    this.checkAdvancedManiupulation();\n    this.data = this.result;\n\n    if (_.isObject(this.result)) {\n      if (this.advancedManipulation) {\n        this.applayTransformFn();\n      }\n\n      this.setHeaders();\n    }\n    this.send();\n  }\n\n\n\n  applayTransformFn() {\n    if (_.isObject(this.data) && !_.isArray(this.data)) {\n      this.data = singleTransform(this.data);\n    }\n    const { include } = { include: [] };\n    walk.Object(\n      this.data,\n      (value, lodashPath, changeValue, { skipObject, isCircural }) => {\n\n        if (!isCircural) {\n          if (!_.isArray(value) && _.isObject(value)) {\n            changeValue(singleTransform(value));\n          }\n        }\n      },\n      { checkCircural: true, breadthWalk: true, include },\n    );\n\n    const { circs } = walk.Object(this.data, void 0, {\n      checkCircural: true,\n      breadthWalk: true,\n      include,\n    });\n    this.circural = circs;\n  }\n\n\n\n  setHeaders(): void {\n    const { include } = { include: [] };\n\n    const className = ClassHelpers.getName(this.data);\n    const doNothing =\n      _.isNil(this.data) ||\n      [\n        'Object',\n        '',\n\n      ].includes(className);\n\n    if (!doNothing) {\n      const cleaned = JSON10.cleaned(this.data, void 0, {\n        breadthWalk: true,\n        include,\n      });\n      this.entityMapping = Mapping.decode(cleaned, !this.advancedManipulation);\n\n      this.response.set(\n        Symbols.old.MAPPING_CONFIG_HEADER,\n        JSON.stringify(this.entityMapping),\n      );\n      if (this.advancedManipulation) {\n        this.response.set(\n          Symbols.old.CIRCURAL_OBJECTS_MAP_BODY,\n          JSON.stringify(this.circural),\n        );\n      }\n    }\n  }\n\n\n\n  send() {\n    if (!_.isObject(this.data)) {\n      if (_.isNumber(this.data)) {\n        this.response.send(this.data.toString());\n      } else {\n        this.response.send(this.data);\n      }\n      return;\n    }\n    if (this.advancedManipulation) {\n      const browserKey = config.folder.browser;\n      let toSend = _.isArray(this.data) ? [] : {};\n\n      const { include = [], exclude = [] } = { include: [], exclude: [] };\n\n      walk.Object(\n        this.data,\n        (value, lodashPath, changeVAlue, { isCircural, skipObject }) => {\n\n          if (isCircural) {\n            _.set(toSend, lodashPath, null);\n          } else {\n            const fun = getTransformFunction(\n              ClassHelpers.getClassFnFromObject(value),\n            );\n\n            if (_.isFunction(fun)) {\n              _.set(toSend, `${lodashPath}.${browserKey}`, value[browserKey]);\n              const indexProp = ClassHelpers.getUniquKey(value);\n              _.set(toSend, `${lodashPath}.${indexProp}`, value[indexProp]);\n\n            } else {\n              _.set(toSend, lodashPath, value);\n            }\n          }\n        },\n        { checkCircural: true, breadthWalk: true, include },\n      );\n\n      if (!_.isArray(this.data)) {\n        let funParent = getTransformFunction(\n          ClassHelpers.getClassFnFromObject(this.data),\n        );\n\n\n\n        if (_.isFunction(funParent)) {\n          toSend = {\n            [browserKey]: toSend[browserKey],\n          };\n        }\n        Object.keys(this.data).forEach(prop => {\n          if (prop !== browserKey) {\n            const v = this.data[prop];\n            if (\n              !(\n                (include.length > 0 && !include.includes(prop)) ||\n                (exclude.length > 0 && exclude.includes(prop))\n              )\n            ) {\n              if (\n                ClassHelpers.isContextClassObject(v) &&\n                _.isFunction(\n                  getTransformFunction(ClassHelpers.getClassFnFromObject(v)),\n                )\n              ) {\n                toSend[prop] = {\n                  [browserKey]: v[browserKey],\n                };\n                const indexProp = ClassHelpers.getUniquKey(v);\n                toSend[prop][indexProp] = this.data[prop][indexProp];\n                for (const key in v) {\n                  if (\n                    _.isObject(v) &&\n                    v.hasOwnProperty(key) &&\n                    ![indexProp, config.folder.browser].includes(key) &&\n                    (_.isString(v[key]) ||\n                      _.isNumber(v[key]) ||\n                      _.isDate(v[key]) ||\n                      _.isNull(v[key]) ||\n                      _.isBoolean(v[key]))\n                  ) {\n                    toSend[prop][key] = v[key];\n                  }\n                }\n              } else {\n                toSend[prop] = v;\n              }\n            }\n          }\n        });\n      }\n\n\n      this.response.json(toSend);\n    } else {\n      this.response.json(this.data);\n    }\n  }\n\n}\n\n ;({}); // @--end-of-file-for-module=taon lib/entity-process.ts"]}

package/client/esm2022/lib/env.mjs

@@ -0,0 +1,6 @@
+import { Helpers } from 'tnp-core/browser';
+const ENV = Helpers.isBrowser ? window['ENV'] : global['ENV'];
+export { ENV };
+;
+({}); // @--end-of-file-for-module=taon lib/env.ts
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW52LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vdG1wLWxpYnMtZm9yLWRpc3QvdGFvbi9wcm9qZWN0cy90YW9uL3NyYy9saWIvZW52LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUUzQyxNQUFNLEdBQUcsR0FBRyxPQUFPLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQztBQUU5RCxPQUFPLEVBQUUsR0FBRyxFQUFFLENBQUM7QUFFZCxDQUFDO0FBQUEsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLDRDQUE0QyIsInNvdXJjZXNDb250ZW50IjpbIlxuXG5pbXBvcnQgeyBIZWxwZXJzIH0gZnJvbSAndG5wLWNvcmUvYnJvd3Nlcic7XG5cbmNvbnN0IEVOViA9IEhlbHBlcnMuaXNCcm93c2VyID8gd2luZG93WydFTlYnXSA6IGdsb2JhbFsnRU5WJ107XG5cbmV4cG9ydCB7IEVOViB9O1xuXG4gOyh7fSk7IC8vIEAtLWVuZC1vZi1maWxlLWZvci1tb2R1bGU9dGFvbiBsaWIvZW52LnRzIl19

package/client/esm2022/lib/get-response-value.mjs

@@ -0,0 +1,41 @@
+export const getResponseValue = (response, options) => {
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    return (void 0);
+};
+;
+({}); // @--end-of-file-for-module=taon lib/get-response-value.ts
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LXJlc3BvbnNlLXZhbHVlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vdG1wLWxpYnMtZm9yLWRpc3QvdGFvbi9wcm9qZWN0cy90YW9uL3NyYy9saWIvZ2V0LXJlc3BvbnNlLXZhbHVlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQVVBLE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFHLENBQzlCLFFBQWlDLEVBQ2pDLE9BQXVELEVBQzNDLEVBQUU7SUFDaEIsS0FBSztJQUNMLEtBQUs7SUFDTCxLQUFLO0lBQ0wsS0FBSztJQUNMLEtBQUs7SUFDTCxLQUFLO0lBQ0wsS0FBSztJQUNMLEtBQUs7SUFDTCxLQUFLO0lBQ0wsS0FBSztJQUNMLEtBQUs7SUFDTCxLQUFLO0lBQ0wsS0FBSztJQUNMLEtBQUs7SUFDTCxLQUFLO0lBQ0wsS0FBSztJQUNMLEtBQUs7SUFDTCxLQUFLO0lBQ0wsS0FBSztJQUNMLEtBQUs7SUFDTCxLQUFLO0lBQ0wsS0FBSztJQUNMLEtBQUs7SUFDTCxLQUFLO0lBQ0wsS0FBSztJQUNMLEtBQUs7SUFDTCxLQUFLO0lBQ0wsS0FBSztJQUNMLEtBQUs7SUFDTCxLQUFLO0lBQ0wsS0FBSztJQUNMLEtBQUs7SUFDTCxLQUFLO0lBQ0wsS0FBSztJQUNMLEtBQUs7SUFDSCxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQztBQUNsQixDQUFDLENBQUM7QUFFRCxDQUFDO0FBQUEsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLDJEQUEyRCIsInNvdXJjZXNDb250ZW50IjpbIlxuXG5pbXBvcnQgeyBNb2RlbHMgfSBmcm9tICcuL21vZGVscyc7XG5pbXBvcnQgeyAgIFJlc3BvbnNlIGFzIEV4cHJlc3NSZXNwb25zZSwgICBSZXF1ZXN0IGFzIEV4cHJlc3NSZXF1ZXN0LCB9IGZyb20gJ2V4cHJlc3MnOy8qICovXG4vKiAqL1xuLyogKi9cblxuaW1wb3J0IHsgVGFvbkhlbHBlcnMgfSBmcm9tICcuL2hlbHBlcnMvdGFvbi1oZWxwZXJzJztcbmltcG9ydCB7IEhlbHBlcnMgfSBmcm9tICd0bnAtY29yZS9icm93c2VyJztcblxuZXhwb3J0IGNvbnN0IGdldFJlc3BvbnNlVmFsdWUgPSA8VD4oXG4gIHJlc3BvbnNlOiBNb2RlbHMuSHR0cC5SZXNwb25zZTxUPixcbiAgb3B0aW9ucz86IHsgcmVxOiBFeHByZXNzUmVxdWVzdDsgcmVzOiBFeHByZXNzUmVzcG9uc2UgfSxcbik6IFByb21pc2U8VD4gPT4ge1xuLyogKi9cbi8qICovXG4vKiAqL1xuLyogKi9cbi8qICovXG4vKiAqL1xuLyogKi9cbi8qICovXG4vKiAqL1xuLyogKi9cbi8qICovXG4vKiAqL1xuLyogKi9cbi8qICovXG4vKiAqL1xuLyogKi9cbi8qICovXG4vKiAqL1xuLyogKi9cbi8qICovXG4vKiAqL1xuLyogKi9cbi8qICovXG4vKiAqL1xuLyogKi9cbi8qICovXG4vKiAqL1xuLyogKi9cbi8qICovXG4vKiAqL1xuLyogKi9cbi8qICovXG4vKiAqL1xuLyogKi9cbi8qICovXG4gIHJldHVybiAodm9pZCAwKTtcbn07XG5cbiA7KHt9KTsgLy8gQC0tZW5kLW9mLWZpbGUtZm9yLW1vZHVsZT10YW9uIGxpYi9nZXQtcmVzcG9uc2UtdmFsdWUudHMiXX0=

package/client/esm2022/lib/helpers/class-helpers.mjs

@@ -0,0 +1,183 @@
+import { Symbols } from '../symbols';
+import { Validators } from '../validators';
+import { _ } from 'tnp-core/browser';
+import { Models } from '../models';
+import { TaonHelpers } from './taon-helpers';
+import { CLASS } from 'typescript-class-helpers/browser';
+/* */
+/* */
+export var ClassHelpers;
+(function (ClassHelpers) {
+    /**
+     * TODO - repalce in every place when getting class fn from object
+     */
+    ClassHelpers.getClassFnFromObject = (json) => {
+        if (_.isUndefined(json) || _.isNull(json)) {
+            return;
+        }
+        if (json.constructor) {
+            return json.constructor;
+        }
+        const p = Object.getPrototypeOf(json);
+        return p && p.constructor && p.constructor.name !== 'Object'
+            ? p.constructor
+            : void 0;
+    };
+    ClassHelpers.getName = (classFnOrObject) => {
+        if (classFnOrObject instanceof FormData) {
+            return 'FormData';
+        }
+        if (!classFnOrObject) {
+            console.error('OBJECT OR CLASS', classFnOrObject);
+            throw new Error(`Cannot get name from this object or class.`);
+        }
+        return ((classFnOrObject[Symbols.classNameStaticProperty]
+            ? classFnOrObject[Symbols.classNameStaticProperty]
+            : classFnOrObject?.constructor[Symbols.classNameStaticProperty]) ||
+            CLASS.getName(classFnOrObject));
+    };
+    ClassHelpers.getOrginalClass = (classFnOrObject) => {
+        const org = classFnOrObject[Symbols.orignalClass];
+        if (!org) {
+            return classFnOrObject;
+        }
+        return ClassHelpers.getOrginalClass(org);
+    };
+    ClassHelpers.getFullInternalName = (classFnOrObject) => {
+        if (!classFnOrObject) {
+            throw new Error(`Cannot get name from: ${classFnOrObject}`);
+        }
+        return ((classFnOrObject[Symbols.fullClassNameStaticProperty]
+            ? classFnOrObject[Symbols.fullClassNameStaticProperty]
+            : classFnOrObject?.constructor[Symbols.fullClassNameStaticProperty]) ||
+            void 0);
+    };
+    ClassHelpers.getUniquKey = (classFnOrObject) => {
+        const classFn = _.isFunction(classFnOrObject)
+            ? classFnOrObject
+            : classFnOrObject.constructor;
+        const config = Reflect.getMetadata(Symbols.metadata.options.controller, classFn);
+        return config.uniqueKeyProp;
+    };
+    ClassHelpers.isContextClassObject = (obj) => {
+        if (!_.isObject(obj) ||
+            _.isArray(obj) ||
+            _.isRegExp(obj) ||
+            _.isBuffer(obj) ||
+            _.isArrayBuffer(obj)) {
+            return false;
+        }
+        if (_.isDate(obj)) {
+            return true;
+        }
+        const className = ClassHelpers.getName(obj);
+        return _.isString(className) && className !== 'Object';
+    };
+    ClassHelpers.setName = (target, className) => {
+        Validators.classNameVlidation(className, target);
+        target[Symbols.classNameStaticProperty] = className;
+    };
+    ClassHelpers.hasParentClassWithName = (target, className, targets = []) => {
+        if (!target) {
+            return false;
+        }
+        targets.push(target);
+        let targetProto = Object.getPrototypeOf(target);
+        if (_.isFunction(targetProto) &&
+            ClassHelpers.getName(targetProto) === className) {
+            return true;
+        }
+        return ClassHelpers.hasParentClassWithName(targetProto, className, targets);
+    };
+    ClassHelpers.getControllerConfig = (target) => {
+        const classMetadataOptions = Reflect.getMetadata(Symbols.metadata.options.controller, target);
+        const classMetadata = _.merge(new Models.ControllerConfig(), classMetadataOptions);
+        const methodNames = ClassHelpers.getMethodsNames(target); //  Object.getOwnPropertyNames(target.prototype);
+        for (const methodName of methodNames) {
+            const methodMetadata = Reflect.getMetadata(Symbols.metadata.options.controllerMethod, target, methodName);
+            if (methodMetadata) {
+                classMetadata.methods[methodName] = methodMetadata;
+            }
+        }
+        return classMetadata;
+    };
+    const notAllowedAsMethodName = [
+        'length',
+        'name',
+        'arguments',
+        'caller',
+        'constructor',
+        'apply',
+        'bind',
+        'call',
+        'toString',
+        '__defineGetter__',
+        '__defineSetter__',
+        'hasOwnProperty',
+        '__lookupGetter__',
+        '__lookupSetter__',
+        'isPrototypeOf',
+        'propertyIsEnumerable',
+        'valueOf',
+        '__proto__',
+        'toLocaleString',
+    ];
+    ClassHelpers.getMethodsNames = (classOrClassInstance, allMethodsNames = []) => {
+        if (!classOrClassInstance) {
+            return allMethodsNames;
+        }
+        const isClassFunction = _.isFunction(classOrClassInstance);
+        const classFun = isClassFunction
+            ? classOrClassInstance
+            : Object.getPrototypeOf(classOrClassInstance);
+        const objectToCheck = isClassFunction
+            ? classOrClassInstance?.prototype
+            : classOrClassInstance;
+        const prototypeObj = Object.getPrototypeOf(objectToCheck || {});
+        const properties = _.uniq([
+            ...Object.getOwnPropertyNames(objectToCheck || {}),
+            ...Object.getOwnPropertyNames(prototypeObj || {}),
+            ...Object.keys(objectToCheck || {}),
+            ...Object.keys(prototypeObj || {}),
+        ]).filter(f => !!f && !notAllowedAsMethodName.includes(f));
+        properties
+            .filter(methodName => typeof objectToCheck[methodName] === 'function')
+            .forEach(p => allMethodsNames.push(p));
+        if (!classFun ||
+            !classFun.constructor ||
+            classFun?.constructor?.name === 'Object') {
+            return allMethodsNames;
+        }
+        return ClassHelpers.getMethodsNames(Object.getPrototypeOf(classFun), allMethodsNames);
+    };
+    ClassHelpers.getControllerConfigs = (target, configs = [], callerTarget) => {
+        if (!_.isFunction(target)) {
+            throw `[typescript-class-helper][getClassConfig] Cannot get class config from: ${target}`;
+        }
+        let config;
+        const parentClass = Object.getPrototypeOf(target);
+        const parentName = parentClass ? ClassHelpers.getName(parentClass) : void 0;
+        const isValidParent = _.isFunction(parentClass) && parentName !== '';
+        config = ClassHelpers.getControllerConfig(target);
+        configs.push(config);
+        return isValidParent
+            ? ClassHelpers.getControllerConfigs(parentClass, configs, target)
+            : configs;
+    };
+    ClassHelpers.getCalculatedPathFor = (target) => {
+        const configs = ClassHelpers.getControllerConfigs(target);
+        const parentscalculatedPath = _.slice(configs, 1)
+            .reverse()
+            .map(bc => {
+            if (TaonHelpers.isGoodPath(bc.path)) {
+                return bc.path;
+            }
+            return bc.className;
+        })
+            .join('/');
+        return `/${parentscalculatedPath}/${ClassHelpers.getName(target)}`;
+    };
+})(ClassHelpers || (ClassHelpers = {}));
+;
+({}); // @--end-of-file-for-module=taon lib/helpers/class-helpers.ts
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"class-helpers.js","sourceRoot":"","sources":["../../../../../tmp-libs-for-dist/taon/projects/taon/src/lib/helpers/class-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["\n\nimport { Symbols } from '../symbols';\nimport { Validators } from '../validators';\nimport { _ } from 'tnp-core/browser';\nimport { Models } from '../models';\nimport { TaonControllerOptions } from '../decorators/classes/controller-decorator';\nimport { TaonHelpers } from './taon-helpers';\nimport { TaonEntityOptions } from '../decorators/classes/entity-decorator';\nimport { CLASS } from 'typescript-class-helpers/browser';\n/* */\n/* */\n  \n\nexport namespace ClassHelpers {\n\n  /**\n   * TODO - repalce in every place when getting class fn from object\n   */\n  export const getClassFnFromObject = (json: Object) => {\n    if (_.isUndefined(json) || _.isNull(json)) {\n      return;\n    }\n    if (json.constructor) {\n      return json.constructor;\n    }\n    const p = Object.getPrototypeOf(json);\n    return p && p.constructor && p.constructor.name !== 'Object'\n      ? p.constructor\n      : void 0;\n  };\n\n\n\n  export const getName = (classFnOrObject: any): string => {\n\n    if (classFnOrObject instanceof FormData) {\n      return 'FormData';\n    }\n    if (!classFnOrObject) {\n      console.error('OBJECT OR CLASS', classFnOrObject);\n      throw new Error(`Cannot get name from this object or class.`);\n    }\n    return (\n      (classFnOrObject[Symbols.classNameStaticProperty]\n        ? classFnOrObject[Symbols.classNameStaticProperty]\n        : classFnOrObject?.constructor[Symbols.classNameStaticProperty]) ||\n      CLASS.getName(classFnOrObject)\n    );\n  };\n\n\n  export const getOrginalClass = (classFnOrObject: any): any => {\n    const org = classFnOrObject[Symbols.orignalClass];\n    if (!org) {\n      return classFnOrObject;\n    }\n    return getOrginalClass(org);\n  };\n\n\n  export const getFullInternalName = (classFnOrObject: any): string => {\n\n\n    if (!classFnOrObject) {\n      throw new Error(`Cannot get name from: ${classFnOrObject}`);\n    }\n    return (\n      (classFnOrObject[Symbols.fullClassNameStaticProperty]\n        ? classFnOrObject[Symbols.fullClassNameStaticProperty]\n        : classFnOrObject?.constructor[Symbols.fullClassNameStaticProperty]) ||\n      void 0\n    );\n  };\n\n\n\n  export const getUniquKey = (classFnOrObject: any): string => {\n    const classFn = _.isFunction(classFnOrObject)\n      ? classFnOrObject\n      : classFnOrObject.constructor;\n    const config = Reflect.getMetadata(\n      Symbols.metadata.options.controller,\n      classFn,\n    ) as TaonEntityOptions;\n    return config.uniqueKeyProp;\n  };\n\n\n\n  export const isContextClassObject = (obj: any): boolean => {\n    if (\n      !_.isObject(obj) ||\n      _.isArray(obj) ||\n      _.isRegExp(obj) ||\n      _.isBuffer(obj) ||\n      _.isArrayBuffer(obj)\n    ) {\n      return false;\n    }\n    if (_.isDate(obj)) {\n      return true;\n    }\n    const className = getName(obj);\n    return _.isString(className) && className !== 'Object';\n  };\n\n\n\n\n  export const setName = (target: Function, className: string): void => {\n\n    Validators.classNameVlidation(className, target);\n    target[Symbols.classNameStaticProperty] = className;\n  };\n\n\n\n  export const hasParentClassWithName = (\n    target: Function,\n    className: string,\n    targets = [],\n  ): boolean => {\n    if (!target) {\n      return false;\n    }\n    targets.push(target);\n    let targetProto = Object.getPrototypeOf(target);\n\n    if (\n      _.isFunction(targetProto) &&\n      ClassHelpers.getName(targetProto) === className\n    ) {\n\n      return true;\n    }\n    return hasParentClassWithName(targetProto, className, targets);\n  };\n\n\n\n  export const getControllerConfig = (\n    target: Function,\n  ): Models.ControllerConfig | undefined => {\n    const classMetadataOptions: TaonControllerOptions = Reflect.getMetadata(\n      Symbols.metadata.options.controller,\n      target,\n    );\n    const classMetadata: Models.ControllerConfig = _.merge(\n      new Models.ControllerConfig(),\n      classMetadataOptions,\n    );\n\n\n    const methodNames = ClassHelpers.getMethodsNames(target); //  Object.getOwnPropertyNames(target.prototype);\n\n    for (const methodName of methodNames) {\n      const methodMetadata: Models.MethodConfig = Reflect.getMetadata(\n        Symbols.metadata.options.controllerMethod,\n        target,\n        methodName,\n      );\n\n      if (methodMetadata) {\n        classMetadata.methods[methodName] = methodMetadata;\n      }\n    }\n    return classMetadata;\n  };\n\n\n\n\n\n  const notAllowedAsMethodName = [\n    'length',\n    'name',\n    'arguments',\n    'caller',\n    'constructor',\n    'apply',\n    'bind',\n    'call',\n    'toString',\n    '__defineGetter__',\n    '__defineSetter__',\n    'hasOwnProperty',\n    '__lookupGetter__',\n    '__lookupSetter__',\n    'isPrototypeOf',\n    'propertyIsEnumerable',\n    'valueOf',\n    '__proto__',\n    'toLocaleString',\n  ];\n\n\n  export const getMethodsNames = (\n    classOrClassInstance: any,\n    allMethodsNames = [],\n  ): string[] => {\n    if (!classOrClassInstance) {\n      return allMethodsNames;\n    }\n\n    const isClassFunction = _.isFunction(classOrClassInstance);\n    const classFun = isClassFunction\n      ? classOrClassInstance\n      : Object.getPrototypeOf(classOrClassInstance);\n    const objectToCheck = isClassFunction\n      ? (classOrClassInstance as Function)?.prototype\n      : classOrClassInstance;\n    const prototypeObj = Object.getPrototypeOf(objectToCheck || {});\n\n    const properties = _.uniq([\n      ...Object.getOwnPropertyNames(objectToCheck || {}),\n      ...Object.getOwnPropertyNames(prototypeObj || {}),\n      ...Object.keys(objectToCheck || {}),\n      ...Object.keys(prototypeObj || {}),\n    ]).filter(f => !!f && !notAllowedAsMethodName.includes(f));\n\n    properties\n      .filter(methodName => typeof objectToCheck[methodName] === 'function')\n      .forEach(p => allMethodsNames.push(p));\n\n    if (\n      !classFun ||\n      !classFun.constructor ||\n      classFun?.constructor?.name === 'Object'\n    ) {\n      return allMethodsNames;\n    }\n    return getMethodsNames(Object.getPrototypeOf(classFun), allMethodsNames);\n  };\n\n\n\n  export const getControllerConfigs = (\n    target: Function,\n    configs: Models.ControllerConfig[] = [],\n    callerTarget?: Function,\n  ): Models.RuntimeControllerConfig[] => {\n    if (!_.isFunction(target)) {\n      throw `[typescript-class-helper][getClassConfig] Cannot get class config from: ${target}`;\n    }\n\n    let config: Models.RuntimeControllerConfig;\n    const parentClass = Object.getPrototypeOf(target);\n    const parentName = parentClass ? ClassHelpers.getName(parentClass) : void 0;\n    const isValidParent = _.isFunction(parentClass) && parentName !== '';\n\n    config = getControllerConfig(target);\n\n    configs.push(config);\n\n    return isValidParent\n      ? getControllerConfigs(parentClass, configs, target)\n      : configs;\n  };\n\n\n\n  export const getCalculatedPathFor = (target: Function) => {\n    const configs = getControllerConfigs(target);\n\n    const parentscalculatedPath = _.slice(configs, 1)\n      .reverse()\n      .map(bc => {\n        if (TaonHelpers.isGoodPath(bc.path)) {\n          return bc.path;\n        }\n        return bc.className;\n      })\n      .join('/');\n\n    return `/${parentscalculatedPath}/${ClassHelpers.getName(target)}`;\n  };\n\n}\n\n ;({}); // @--end-of-file-for-module=taon lib/helpers/class-helpers.ts"]}

package/client/esm2022/lib/helpers/taon-helpers.mjs

@@ -0,0 +1,120 @@
+import { _ } from 'tnp-core/browser';
+import * as JSON5 from 'json5';
+import { ClassHelpers } from './class-helpers';
+export var TaonHelpers;
+(function (TaonHelpers) {
+    TaonHelpers.fillUpTo = (s, nCharacters) => {
+        return _.times(nCharacters, n => {
+            if (s.charAt(n)) {
+                return s.charAt(n);
+            }
+            return ' ';
+        }).join('');
+    };
+    TaonHelpers.isGoodPath = (p) => {
+        return p && typeof p === 'string' && p.trim() !== '';
+    };
+    TaonHelpers.tryTransformParam = param => {
+        if (typeof param === 'string') {
+            let n = Number(param);
+            if (!isNaN(n))
+                return n;
+            const bool = param.trim().toLowerCase();
+            if (bool === 'true') {
+                return true;
+            }
+            if (bool === 'false') {
+                return false;
+            }
+            try {
+                const t = JSON5.parse(param);
+                return t;
+            }
+            catch (e) {
+                return param;
+            }
+        }
+        return param;
+    };
+    TaonHelpers.getExpressPath = (c, pathOrClassConfig) => {
+        if (typeof pathOrClassConfig === 'string')
+            return `${c.calculatedPath}${pathOrClassConfig}`.replace(/\/$/, '');
+        return `${c.calculatedPath}${pathOrClassConfig.path}`.replace(/\/$/, '');
+    };
+    TaonHelpers.defaultType = value => {
+        if (typeof value === 'string')
+            return '';
+        if (typeof value === 'boolean')
+            return false;
+        if (Array.isArray(value))
+            return {};
+        if (typeof value === 'object')
+            return {};
+    };
+    TaonHelpers.parseJSONwithStringJSONs = (object, waring = false) => {
+        if (!_.isObject(object)) {
+            if (waring) {
+                console.error(`
+        parseJSONwithStringJSONs(...)
+        Parameter should be a object, but is ${typeof object}
+        `, object);
+            }
+            return object;
+        }
+        let res = _.cloneDeep(object);
+        Object.keys(res).forEach(key => {
+            let isJson = false;
+            try {
+                const possibleJSON = JSON.parse(res[key]);
+                res[key] = possibleJSON;
+                isJson = true;
+            }
+            catch (e) {
+                isJson = false;
+            }
+            if (isJson) {
+                res[key] = TaonHelpers.parseJSONwithStringJSONs(res[key], false);
+            }
+        });
+        return res;
+    };
+    TaonHelpers.isPlainFileOrFolder = filePath => {
+        return /^([a-zA-Z]|\-|\_|\@|\#|\$|\!|\^|\&|\*|\(|\))+$/.test(filePath);
+    };
+    TaonHelpers.ipcKeyNameResponse = (target, methodConfig, expressPath) => {
+        return [
+            'response',
+            ClassHelpers.getName(target),
+            methodConfig.methodName,
+            methodConfig.type,
+            expressPath,
+        ].join('--');
+    };
+    TaonHelpers.ipcKeyNameRequest = (target, methodConfig, expressPath) => {
+        return [
+            'request',
+            ClassHelpers.getName(target),
+            methodConfig.methodName,
+            methodConfig.type,
+            expressPath,
+        ].join('--');
+    };
+    TaonHelpers.websqlMocks = headers => {
+        const response = {
+            status(status) {
+                return {
+                    send(send) {
+                    },
+                };
+            },
+            setHeader(key, value) {
+                headers[key] = value;
+            },
+        };
+        const request = {};
+        return { request, response };
+    };
+})(TaonHelpers || (TaonHelpers = {}));
+;
+({}); // @--end-of-file-for-module=taon lib/helpers/taon-helpers.ts
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"taon-helpers.js","sourceRoot":"","sources":["../../../../../tmp-libs-for-dist/taon/projects/taon/src/lib/helpers/taon-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["\n\nimport { _ } from 'tnp-core/browser';\nimport * as JSON5 from 'json5';\nimport { Models } from '../models';\nimport { ClassHelpers } from './class-helpers';\n\nexport namespace TaonHelpers {\n\n  export const fillUpTo = (s: string, nCharacters: number) => {\n    return _.times(nCharacters, n => {\n      if (s.charAt(n)) {\n        return s.charAt(n);\n      }\n      return ' ';\n    }).join('');\n  };\n\n\n\n  export const isGoodPath = (p: string) => {\n    return p && typeof p === 'string' && p.trim() !== '';\n  };\n\n\n\n  export const tryTransformParam = param => {\n    if (typeof param === 'string') {\n      let n = Number(param);\n      if (!isNaN(n)) return n;\n      const bool = param.trim().toLowerCase();\n      if (bool === 'true') {\n        return true;\n      }\n      if (bool === 'false') {\n        return false;\n      }\n      try {\n        const t = JSON5.parse(param);\n        return t;\n      } catch (e) {\n        return param;\n      }\n    }\n    return param;\n  };\n\n\n\n  export const getExpressPath = (\n    c: Models.RuntimeControllerConfig,\n    pathOrClassConfig: Models.MethodConfig,\n  ) => {\n    if (typeof pathOrClassConfig === 'string')\n      return `${c.calculatedPath}${pathOrClassConfig}`.replace(/\\/$/, '');\n    return `${c.calculatedPath}${pathOrClassConfig.path}`.replace(/\\/$/, '');\n  };\n\n\n\n  export const defaultType = value => {\n    if (typeof value === 'string') return '';\n    if (typeof value === 'boolean') return false;\n    if (Array.isArray(value)) return {};\n    if (typeof value === 'object') return {};\n  };\n\n\n\n  export const parseJSONwithStringJSONs = (\n    object: Object,\n    waring = false,\n  ): Object => {\n\n    if (!_.isObject(object)) {\n      if (waring) {\n        console.error(\n          `\n        parseJSONwithStringJSONs(...)\n        Parameter should be a object, but is ${typeof object}\n        `,\n          object,\n        );\n      }\n\n      return object;\n    }\n\n    let res = _.cloneDeep(object);\n\n    Object.keys(res).forEach(key => {\n      let isJson = false;\n      try {\n        const possibleJSON = JSON.parse(res[key]);\n        res[key] = possibleJSON;\n        isJson = true;\n      } catch (e) {\n        isJson = false;\n      }\n\n      if (isJson) {\n        res[key] = parseJSONwithStringJSONs(res[key], false);\n      }\n    });\n\n    return res;\n  };\n\n\n\n  export const isPlainFileOrFolder = filePath => {\n    return /^([a-zA-Z]|\\-|\\_|\\@|\\#|\\$|\\!|\\^|\\&|\\*|\\(|\\))+$/.test(filePath);\n  };\n\n\n\n  export const ipcKeyNameResponse = (\n    target: Function,\n    methodConfig: Models.MethodConfig,\n    expressPath: string,\n  ) => {\n    return [\n      'response',\n      ClassHelpers.getName(target),\n      methodConfig.methodName,\n      methodConfig.type,\n      expressPath,\n    ].join('--');\n  };\n\n\n\n  export const ipcKeyNameRequest = (\n    target: Function,\n    methodConfig: Models.MethodConfig,\n    expressPath: string,\n  ) => {\n    return [\n      'request',\n      ClassHelpers.getName(target),\n      methodConfig.methodName,\n      methodConfig.type,\n      expressPath,\n    ].join('--');\n  };\n\n\n\n  export const websqlMocks = headers => {\n    const response: Express.Response = {\n      status(status: any) {\n\n        return {\n          send(send: any) {\n\n          },\n        };\n      },\n      setHeader(key: string, value: any) {\n\n        headers[key] = value;\n      },\n    };\n    const request: Express.Request = {};\n    return { request, response };\n  };\n\n}\n\n ;({}); // @--end-of-file-for-module=taon lib/helpers/taon-helpers.ts"]}