typescript-class-helpers 21.0.32 → 21.0.35

package/websql-prod/fesm2022/typescript-class-helpers-websql.mjs

@@ -1,226 +1,20 @@
-import { CoreModels__NS__ClassNameStaticProperty, ___NS__cloneDeep, ___NS__isUndefined, ___NS__isBoolean, ___NS__first, ___NS__isFunction, ___NS__isNil, ___NS__isString, Helpers__NS__log, UtilsOs__NS__isBrowser, ___NS__isArray, ___NS__isNull, ___NS__uniq, ___NS__isNumber, ___NS__isEqual, ___NS__isObject, ___NS__isRegExp, ___NS__isBuffer, ___NS__isArrayBuffer, ___NS__isDate } from 'tnp-core/websql-prod';
+import { ___NS__isNil, ___NS__isString, ___NS__isFunction, Helpers__NS__log, CoreModels__NS__ClassNameStaticProperty, ___NS__isUndefined, ___NS__isNull, ___NS__uniq } from 'tnp-core/websql-prod';
 
-/**
- * @deprecated
- */
-class Models__NS__ParamConfig {
-}
-/**
- * @deprecated
- */
-class Models__NS__MethodConfig {
-    constructor() {
-        //#endregion
-        this.parameters = {};
-    }
-}
-/**
- * @deprecated
- */
-class Models__NS__ClassConfig {
-    constructor() {
-        // @ts-ignore
-        this.singleton = void 0;
-        this.injections = [];
-        this.vChildren = [];
-        this.methods = {};
-    }
-}
-//end of namespace Models
-
-const SYMBOL = {
-    MODELS_MAPPING: Symbol(),
-    DEFAULT_MODEL: Symbol(),
-    STORAGE: 'classesstorage',
-    CLASSES: 'classes',
-    ClassNameStaticProperty: CoreModels__NS__ClassNameStaticProperty,
-};
-
-function defaultValues() {
-    return ___NS__cloneDeep({
-        [SYMBOL.CLASSES]: []
-    });
-}
-function getStorage(property) {
-    /* */
-    /* */
-    /* */
-    /* */
-    if (typeof property === 'string') {
-        const storageInClassStaticProp = getStorage();
-        return storageInClassStaticProp[property];
-    }
-    if (typeof defaultValues.prototype[SYMBOL.STORAGE] === 'undefined') {
-        defaultValues.prototype[SYMBOL.STORAGE] = defaultValues();
-    }
-    return defaultValues.prototype[SYMBOL.STORAGE];
-}
-
-function getClasses$1() {
-    const s = getStorage();
-    return s[SYMBOL.CLASSES];
-}
-// @ts-ignore
-function setClassName(target, className, options) {
-    let { classFamily, uniqueKey, classNameInBrowser, singleton } = options || {
-        classFamily: void 0,
-        uniqueKey: 'id',
-        classNameInBrowser: void 0,
-        singleton: void 0,
-        autoinstance: false
-    };
-    if (!___NS__isUndefined(singleton) && ___NS__isBoolean(singleton) && singleton) {
-        singleton = 'first-instance';
-    }
-    if (!uniqueKey) {
-        uniqueKey = 'id';
-    }
-    if (target) {
-        const config = ___NS__first(CLASSNAME__NS__getClassConfig(target));
-        config.className = className;
-        config.uniqueKey = uniqueKey;
-        config.classNameInBrowser = classNameInBrowser;
-        // console.log(`Setting class Name to "${target.name}"`)
-    }
-    const existed = getClasses$1()
-        .find(f => f.className === className);
-    if (existed) {
-        existed.target = target;
-    }
-    else {
-        const res = {
-            className,
-            classNameInBrowser,
-            target,
-            uniqueKey,
-            classFamily
-        };
-        if (___NS__isUndefined(classFamily)) {
-            Object.defineProperty(res, 'classFamily', {
-                get: function () {
-                    const parent = Object.getPrototypeOf(target);
-                    if (!___NS__isFunction(parent) || parent.name === 'Object' || parent.name === '') {
-                        return className;
-                    }
-                    const classNameNew = CLASSNAME__NS__getClassName(parent);
-                    return CLASSNAME__NS__getClassFamilyByClassName(classNameNew);
-                }
-            });
-        }
-        getClasses$1().push(res);
-    }
-    const Original = target;
-    if (singleton === 'first-instance' || singleton === 'last-instance') {
-        const obj = {
-            // @ts-ignore
-            decoratedConstructor: function (...args) {
-                // console.log(`DECORATED CONSTRUCTOR OF ${Original.name}`)
-                const context = Original.apply(this, args);
-                const existedSingleton = CLASS.getSingleton(Original);
-                if (!existedSingleton || singleton === 'last-instance') {
-                    CLASS.setSingletonObj(Original, this);
-                    CLASS.setSingletonObj(obj.decoratedConstructor, this);
-                    // console.log(`Singleton created for "${className}", mode: ${singleton} `);
-                }
-                else {
-                    // console.log('ingleton exists')
-                }
-                return context;
-            }
-        };
-        // copy prototype so intanceof operator still works
-        obj.decoratedConstructor.prototype = Original.prototype;
-        // @ts-ignore
-        Object.keys(Original).forEach((name) => { obj.decoratedConstructor[name] = Original[name]; });
-        Object.defineProperty(obj.decoratedConstructor, 'name', {
-            value: className,
-            configurable: true,
-        });
-        // (obj.decoratedConstructor as any).name = className;
-        // console.log('return new contruor', decoratedConstructor)
-        return obj.decoratedConstructor;
-    }
-    else if (singleton === 'autoinstance') {
-        // console.log(`AUTOINSTANCE FOR ${target.name}`)
-        const auto = new Original();
-        CLASS.setSingletonObj(Original, auto);
-        // console.log(`Singleton created for "${className}", mode: ${singleton} `)
-    }
-}
-
-const registerd = {
-    configs: [],
-    classes: [],
-};
-
-const ERROR_MSG_CLASS_WITHOUT_DECORATOR = `[typescript-class-helpers][getClassName(...)](PRODUCTION MODE ERROR)
-Please use decoartor @CLASSNAME for each entity or controller
-This is preventing class name problem in minified code.
-
-import { CLASS } from 'typescript-class-helpers';
-
-@CLASS.NAME('ExampleClass')
-class ExampleClass {
-  ...
-}
-`;
-
-/* */
 /* */
-function getClasses() {
-    const s = getStorage();
-    return s[SYMBOL.CLASSES];
-}
-//namespace CLASSNAME
-function CLASSNAME__NS__getClassConfig(target, configs = [], callerTarget) {
-    if (!___NS__isFunction(target)) {
-        throw `[typescript-class-helper][getClassConfig] Cannot get class config from: ${target}`;
-    }
-    let config;
-    const parentClass = Object.getPrototypeOf(target);
-    const isValidParent = ___NS__isFunction(parentClass) && parentClass.name !== '';
-    if (registerd.classes.includes(target)) {
-        config =
-            registerd.configs[registerd.classes.findIndex(c => c === target)];
+const REGISTRY_SYMBOL = Symbol.for('TAON.CLASS_REGISTRY');
+function getRegistry() {
+    const g = globalThis;
+    if (!g[REGISTRY_SYMBOL]) {
+        g[REGISTRY_SYMBOL] = new Map();
     }
-    else {
-        config = new Models__NS__ClassConfig();
-        config.classReference = target;
-        registerd.classes.push(target);
-    }
-    registerd.configs[registerd.classes.findIndex(c => c === target)] = config;
-    if (callerTarget) {
-        const callerTargetConfig = registerd.configs[registerd.classes.findIndex(c => c === callerTarget)];
-        if (!config.vChildren.includes(callerTargetConfig)) {
-            config.vChildren.push(callerTargetConfig);
-        }
-        callerTargetConfig.vParent = config;
-    }
-    configs.push(config);
-    return isValidParent
-        ? CLASSNAME__NS__getClassConfig(parentClass, configs, target)
-        : configs;
-}
-/**
- * PLEASE PROVIDE NAME AS TYPED STRING, NOT VARIABLE
- * Decorator requred for production mode
- * @param name Name of class
- */
-function CLASSNAME__NS__CLASSNAME(className, options) {
-    return function (target) {
-        // console.log(`CLASSNAME Inited ${className}`)
-        return setClassName(target, className, options);
-    };
+    return g[REGISTRY_SYMBOL];
 }
-function CLASSNAME__NS__getClassName(target, production = false) {
+const classes = getRegistry();
+function getClassName(target) {
     if (___NS__isNil(target)) {
-        // console.log(target);
-        // Helpers__NS__warn(`[typescript-class-helpers][getClassName] target is nil`)
         return void 0;
     }
     if (___NS__isString(target)) {
-        // console.log(target);
-        Helpers__NS__log(`[typescript-class-helpers][getClassName] target is string: '${target}', produciton: ${production}`);
         return target;
     }
     if (target === Date) {
@@ -234,80 +28,71 @@ function CLASSNAME__NS__getClassName(target, production = false) {
         Helpers__NS__log(`[typescript-class-helpers][getClassName] target is not a class`);
         return void 0;
     }
-    if (target[SYMBOL.ClassNameStaticProperty]) {
-        return target[SYMBOL.ClassNameStaticProperty];
-    }
-    const configs = CLASSNAME__NS__getClassConfig(target);
-    const config = ___NS__first(configs);
-    const classNameInBrowser = config?.classNameInBrowser;
-    if (UtilsOs__NS__isBrowser && ___NS__isString(classNameInBrowser)) {
-        return classNameInBrowser;
-    }
-    const className = config?.className;
-    if (typeof className === 'string') {
-        return className;
-    }
-    if (production) {
-        console.log('class without @CLASS.NAME deocrator', target);
-        throw new Error(ERROR_MSG_CLASS_WITHOUT_DECORATOR);
-    }
-    else {
-        // Helpers__NS__log('check for ' + target.name)
-        // setTimeout(() => {
-        //   // Helpers__NS__log('check for ' + target.name + ' === ' + config.className)/
-        //   // TODO this may work, but not yet in singleton/morphi
-        //   if (!config.className) {
-        //     if (target?.name && target.name !== 'Object') {
-        //       ConfigHelpers.log(`[typescript-class-helpers] Please use @CLASS.NAME`
-        //         + `('${(target?.name && !!target.name) ? target.name : '...'}') decorator for class ${target?.name}`)
-        //     }
-        //   }
-        // })
+    if (!___NS__isNil(target[CoreModels__NS__ClassNameStaticProperty])) {
+        return target[CoreModels__NS__ClassNameStaticProperty];
     }
     // special thing when cloning classes
     if (target.name?.startsWith('class_')) {
         return '';
     }
-    return target.name;
+    return;
 }
-// @ts-ignore
-function CLASSNAME__NS__getObjectIndexPropertyValue(obj) {
-    const className = TchHelpers.getNameFromObject(obj);
-    // console.log('className',className)
-    let c = getClasses().find(c => c.className === className);
-    // console.log('c',c)
-    if (c) {
-        return c.uniqueKey;
+function getFromObject(o) {
+    if (___NS__isUndefined(o) || ___NS__isNull(o)) {
+        return;
     }
-}
-// @ts-ignore
-function CLASSNAME__NS__getClassFamilyByClassName(className) {
-    let c = getClasses().find(c => c.className === className);
-    // console.log('getClasses()', getClasses())
-    if (c) {
-        return c.classFamily;
+    if (o.constructor) {
+        return o.constructor;
     }
+    const p = Object.getPrototypeOf(o);
+    return p && p.constructor;
 }
-// @ts-ignore
-function CLASSNAME__NS__getObjectClassFamily(obj) {
-    const className = TchHelpers.getNameFromObject(obj);
-    // console.log('className',className)
-    let c = getClasses().find(c => c.className === className);
-    // console.log('c',c)
-    if (c) {
-        return c.classFamily;
-    }
+const notAllowedAsMethodName = [
+    'length',
+    'name',
+    'arguments',
+    'caller',
+    'constructor',
+    'apply',
+    'bind',
+    'call',
+    'toString',
+    '__defineGetter__',
+    '__defineSetter__',
+    'hasOwnProperty',
+    '__lookupGetter__',
+    '__lookupSetter__',
+    'isPrototypeOf',
+    'propertyIsEnumerable',
+    'valueOf',
+    '__proto__',
+    'toLocaleString',
+];
+//namespace CLASS
+/**
+ * PLEASE PROVIDE NAME AS TYPED STRING, NOT VARIABLE
+ * Decorator requred for production mode
+ * @param name Name of class
+ */
+function CLASS__NS__NAME(className) {
+    return function (target) {
+        return CLASS__NS__setClassName(target, className);
+    };
+}
+function CLASS__NS__setName(target, className) {
+    CLASS__NS__setClassName(target, className);
 }
-function CLASSNAME__NS__getObjectIndexValue(obj) {
-    const className = TchHelpers.getNameFromObject(obj);
-    // console.log('className',className)
-    let c = getClasses().find(c => c.className === className);
-    // console.log('c',c)
-    if (c && ___NS__isString(c.uniqueKey)) {
-        return obj[c.uniqueKey];
+function CLASS__NS__getClassNameFromObjInstanceOrClassFn(target) {
+    if (typeof target === 'object') {
+        return CLASS__NS__getNameFromObject(target);
     }
+    return getClassName(target);
 }
-function CLASSNAME__NS__getClassBy(className) {
+function CLASS__NS__setClassName(target, className) {
+    target[CoreModels__NS__ClassNameStaticProperty] = className;
+    classes.set(className, target);
+}
+function CLASS__NS__getBy(className) {
     let res;
     if (Array.isArray(className)) {
         if (className.length !== 1) {
@@ -331,278 +116,59 @@ function CLASSNAME__NS__getClassBy(className) {
     if (className === 'FormData') {
         res = FormData;
     }
-    let c = getClasses().find(c => c.className === className);
-    if (c) {
-        res = c.target;
-    }
-    // console.log(`getClassBy "${className} return \n\n ${res} \n\n`)
-    // @ts-ignore
-    return res;
+    const classFromMap = classes.get(className);
+    return classFromMap ? classFromMap : res;
 }
-//end of namespace CLASSNAME
-
-/**
-  * @DEPRECATED
-  * Describe fields assigned in class
-  */
-const FRegEx = new RegExp(/(?:this\.)(.+?(?= ))/g);
-function describeFromClassStringify(target, parent = false) {
-    // @ts-ignore
-    var result = [];
-    if (parent) {
-        var proto = Object.getPrototypeOf(target.prototype);
-        if (proto) {
-            // @ts-ignore
-            result = result.concat(describeFromClassStringify(proto.constructor, parent));
-        }
+function CLASS__NS__getFromObject(o) {
+    if (___NS__isUndefined(o) || ___NS__isNull(o)) {
+        return;
     }
-    const classString = target.toString();
-    const matches = classString.match(FRegEx) || [];
-    // console.log({
-    //   classString,
-    // });
-    result = result.concat(matches);
-    return result.map(prop => prop
-        .replace('this.', '')
-        .replace('.', '')
-        .replace(')', '')
-        .replace('(', ''));
-}
-/**
-   * Describe fields assigne through @DefaultModelWithMapping decorator
-   * without functions
-   */
-function describeByDefaultModelsAndMapping(target) {
-    let res = {};
-    if (target) {
-        // @ts-ignore
-        if (target[SYMBOL.DEFAULT_MODEL]) {
-            // @ts-ignore
-            Object.keys(target[SYMBOL.DEFAULT_MODEL])
-                .filter(key => {
-                // @ts-ignore
-                return !___NS__isFunction(target[SYMBOL.DEFAULT_MODEL][key]);
-            })
-                .forEach(key => {
-                // @ts-ignore
-                return res[key] = null;
-            });
-        }
-        // @ts-ignore
-        let mapping = target[SYMBOL.MODELS_MAPPING];
-        if (___NS__isArray(mapping)) {
-            mapping.forEach(m => {
-                Object.keys(m)
-                    .forEach(key => {
-                    // @ts-ignore
-                    res[key] = null;
-                });
-            });
-        }
-        else if (mapping) {
-            Object.keys(mapping)
-                .forEach(key => {
-                // @ts-ignore
-                res[key] = null;
-            });
-        }
+    if (o.constructor) {
+        return o.constructor;
     }
-    let propNames = Object.keys(res).filter(f => !!f);
-    propNames = (!propNames.includes('id') ? ['id'] : []).concat(propNames);
-    return propNames;
+    const p = Object.getPrototypeOf(o);
+    return p && p.constructor;
 }
-
-class TchHelpers {
-    static getBy(className) {
-        return CLASSNAME__NS__getClassBy(className);
-    }
-    static getFromObject(o) {
-        if (___NS__isUndefined(o) || ___NS__isNull(o)) {
-            return;
-        }
-        if (o.constructor) {
-            return o.constructor;
-        }
-        const p = Object.getPrototypeOf(o);
-        return p && p.constructor;
-    }
-    static getName(target, production = false) {
-        return CLASSNAME__NS__getClassName(target, production);
-    }
-    static getNameFromObject(o) {
-        const fnCLass = this.getFromObject(o);
-        return this.getName(fnCLass);
-    }
-    static getConfigs(target) {
-        return CLASSNAME__NS__getClassConfig(target);
-    }
-    static describeProperites(target) {
-        const d1 = describeFromClassStringify(target);
-        const d2 = describeByDefaultModelsAndMapping(target);
-        let uniq = {};
-        // @ts-ignore
-        d1.concat(d2).forEach(p => uniq[p] = p);
-        return Object.keys(uniq)
-            .filter(d => !!d)
-            .filter(d => typeof target.prototype[d] !== 'function');
-    }
+function CLASS__NS__getName(target) {
+    return getClassName(target);
 }
-const notAllowedAsMethodName = [
-    'length', 'name',
-    'arguments', 'caller',
-    'constructor', 'apply',
-    'bind', 'call',
-    'toString',
-    '__defineGetter__',
-    '__defineSetter__', 'hasOwnProperty',
-    '__lookupGetter__', '__lookupSetter__',
-    'isPrototypeOf', 'propertyIsEnumerable',
-    'valueOf', '__proto__', 'toLocaleString',
-];
-const getMethodsNames = (classOrClassInstance, allMethodsNames = []) => {
+function CLASS__NS__getNameFromObject(o) {
+    const fnCLass = CLASS__NS__getFromObject(o);
+    return CLASS__NS__getName(fnCLass);
+}
+const CLASS__NS__getMethodsNames = (classOrClassInstance, allMethodsNames = []) => {
     if (!classOrClassInstance) {
         return allMethodsNames;
     }
     const isClassFunction = ___NS__isFunction(classOrClassInstance);
-    const classFun = (isClassFunction ? classOrClassInstance : Object.getPrototypeOf(classOrClassInstance));
-    const objectToCheck = isClassFunction ? classOrClassInstance?.prototype : classOrClassInstance;
+    const classFun = isClassFunction
+        ? classOrClassInstance
+        : Object.getPrototypeOf(classOrClassInstance);
+    const objectToCheck = isClassFunction
+        ? classOrClassInstance?.prototype
+        : classOrClassInstance;
     const prototypeObj = Object.getPrototypeOf(objectToCheck || {});
     const properties = ___NS__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') {
+    ]).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 getMethodsNames(Object.getPrototypeOf(classFun), allMethodsNames);
-};
-const CLASS = {
-    NAME: CLASSNAME__NS__CLASSNAME,
-    setName: setClassName,
-    getBy: TchHelpers.getBy,
-    /**
-     * @deprecated
-     */
-    getSingleton(target) {
-        if (typeof target !== 'function') {
-            console.error(`[typescript-class-helpers][setSingletonObj] Type of target is not a function`);
-            return;
-        }
-        const config = TchHelpers.getConfigs(target)[0];
-        // console.log(`getSingleton for ${target.name}: `, config.singleton)
-        return config.singleton;
-    },
-    /**
-     * @deprecated
-     */
-    setSingletonObj(target, singletonObject) {
-        // console.log('SET SINGLETON', singletonObject)
-        if (typeof target !== 'function') {
-            console.error(`[typescript-class-helpers][setSingletonObj] Type of target is not a function`);
-            return;
-        }
-        if (Array.isArray(singletonObject)) {
-            console.error(`[typescript-class-helpers][setSingletonObj] Singleton instance cant be an array`);
-            return;
-        }
-        if (typeof singletonObject !== 'object') {
-            console.error(`[typescript-class-helpers][setSingletonObj] Singleton instance cant must be a object`);
-            return;
-        }
-        const className = CLASS.getName(target);
-        // console.log(`SINGLETON SET for TARGET ${className}`)
-        const config = TchHelpers.getConfigs(target)[0];
-        if (config.singleton) {
-            console.warn(`[typescript-class-helpers] You are trying to set singleton of "${className}" second time with different object.`);
-        }
-        config.singleton = singletonObject;
-    },
-    /**
-     * @deprecated
-     */
-    getConfigs: TchHelpers.getConfigs,
-    /**
-     * @deprecated
-     */
-    getConfig: (target) => {
-        return ___NS__first(TchHelpers.getConfigs(target));
-    },
-    getMethodsNames(classOrClassInstance) {
-        return getMethodsNames(classOrClassInstance);
-    },
-    getFromObject: TchHelpers.getFromObject,
-    getName: TchHelpers.getName,
-    getNameFromObject: TchHelpers.getNameFromObject,
-    describeProperites: TchHelpers.describeProperites,
-    /**
-     * @deprecated
-     */
-    OBJECT: (obj) => {
-        return {
-            get indexValue() {
-                return CLASSNAME__NS__getObjectIndexValue(obj);
-            },
-            get indexProperty() {
-                return CLASSNAME__NS__getObjectIndexPropertyValue(obj);
-            },
-            get isClassObject() {
-                if (!___NS__isObject(obj) || ___NS__isArray(obj) || ___NS__isRegExp(obj) ||
-                    ___NS__isBuffer(obj) || ___NS__isArrayBuffer(obj)) {
-                    return false;
-                }
-                if (___NS__isDate(obj)) {
-                    return true;
-                }
-                const className = CLASS.getNameFromObject(obj);
-                return ___NS__isString(className) && className !== 'Object';
-            },
-            isEqual: (anotherObj, compareDeep = false) => {
-                if (!CLASS.OBJECT(obj).isClassObject || !CLASS.OBJECT(anotherObj).isClassObject) {
-                    return false;
-                }
-                if (obj === anotherObj) {
-                    // console.log(`EQ v1: , v2:  - class1 ${CLASS.getNameFromObject(obj)}, class2 ${CLASS.getNameFromObject(anotherObj)}`, obj, anotherObj)
-                    return true;
-                }
-                const v1 = CLASSNAME__NS__getObjectIndexValue(obj);
-                const v2 = CLASSNAME__NS__getObjectIndexValue(anotherObj);
-                const f1 = CLASSNAME__NS__getObjectClassFamily(obj);
-                const f2 = CLASSNAME__NS__getObjectClassFamily(anotherObj);
-                const isFamilyDiff = (!___NS__isString(f1) || !___NS__isString(f2) || (f1 !== f2));
-                // console.log(`DIFF FAMILY ${isFamilyDiff} v1: ${CLASSNAME__NS__getObjectClassFamily(obj)}, v2: ${CLASSNAME__NS__getObjectClassFamily(anotherObj)} - class1 ${CLASS.getNameFromObject(obj)}, class2 ${CLASS.getNameFromObject(anotherObj)}`)
-                if (isFamilyDiff) {
-                    // console.log(`DIFF v1: ${v1}, v2: ${v2} - class1 ${CLASS.getNameFromObject(obj)}, class2 ${CLASS.getNameFromObject(anotherObj)}`)
-                    return false;
-                }
-                if (!CLASS.OBJECT(obj).isClassObject || !CLASS.OBJECT(anotherObj).isClassObject) {
-                    // console.log(`NOT CLASS v1: ${v1}, v2: ${v2} - class1 ${CLASS.getNameFromObject(obj)}, class2 ${CLASS.getNameFromObject(anotherObj)}`)
-                    return false;
-                }
-                // console.log(`v1: ${v1} ,class ${CLASS.getNameFromObject(obj)} ,prop: ${CLASS.OBJECT(obj).indexProperty}`)
-                // console.log(`v2: ${v2} ,class ${CLASS.getNameFromObject(anotherObj)} ,prop: ${CLASS.OBJECT(anotherObj).indexProperty}`)
-                // console.log(`v1: ${v1}, v2: ${v2} - class1 ${CLASS.getNameFromObject(obj)}, class2 ${CLASS.getNameFromObject(anotherObj)}`)
-                // console.log('')
-                if ((___NS__isNumber(v1) && ___NS__isNumber(v2)) || (___NS__isString(v1) && ___NS__isString(v2))) {
-                    const res = (v1 === v2);
-                    // @ts-ignore
-                    return res;
-                }
-                if (compareDeep) {
-                    return ___NS__isEqual(v1, v2);
-                }
-                return false;
-            }
-        };
-    }
+    return CLASS__NS__getMethodsNames(Object.getPrototypeOf(classFun), allMethodsNames);
 };
+//end of namespace CLASS
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { CLASS, Models__NS__ClassConfig, Models__NS__MethodConfig, Models__NS__ParamConfig, SYMBOL, TchHelpers };
+export { CLASS__NS__NAME, CLASS__NS__getBy, CLASS__NS__getClassNameFromObjInstanceOrClassFn, CLASS__NS__getFromObject, CLASS__NS__getMethodsNames, CLASS__NS__getName, CLASS__NS__getNameFromObject, CLASS__NS__setClassName, CLASS__NS__setName, getClassName, getFromObject };
 //# sourceMappingURL=typescript-class-helpers-websql.mjs.map