typescript-class-helpers/lib/typescript-class-helpers.js

Usefull helper to have in your typescript project

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.CLASS = void 0;
exports.getClassName = getClassName;
exports.getFromObject = getFromObject;
const FormData = require("form-data"); // @backend @esmRemove
const lib_1 = require("tnp-core/lib");
const lib_2 = require("tnp-core/lib");
const REGISTRY_SYMBOL = Symbol.for('TAON.CLASS_REGISTRY');
function getRegistry() {
    const g = globalThis;
    if (!g[REGISTRY_SYMBOL]) {
        g[REGISTRY_SYMBOL] = new Map();
    }
    return g[REGISTRY_SYMBOL];
}
const classes = getRegistry();
function getClassName(target) {
    if (lib_1._.isNil(target)) {
        return void 0;
    }
    if (lib_1._.isString(target)) {
        return target;
    }
    if (target === Date) {
        return 'Date';
    }
    if (target === FormData) {
        return 'FormData';
    }
    if (!lib_1._.isFunction(target)) {
        // console.log(target);
        lib_2.Helpers.log(`[typescript-class-helpers][getClassName] target is not a class`);
        return void 0;
    }
    if (!lib_1._.isNil(target[lib_1.CoreModels.ClassNameStaticProperty])) {
        return target[lib_1.CoreModels.ClassNameStaticProperty];
    }
    // special thing when cloning classes
    if (target.name?.startsWith('class_')) {
        return '';
    }
    return;
}
function getFromObject(o) {
    if (lib_1._.isUndefined(o) || lib_1._.isNull(o)) {
        return;
    }
    if (o.constructor) {
        return o.constructor;
    }
    const p = Object.getPrototypeOf(o);
    return p && p.constructor;
}
const notAllowedAsMethodName = [
    'length',
    'name',
    'arguments',
    'caller',
    'constructor',
    'apply',
    'bind',
    'call',
    'toString',
    '__defineGetter__',
    '__defineSetter__',
    'hasOwnProperty',
    '__lookupGetter__',
    '__lookupSetter__',
    'isPrototypeOf',
    'propertyIsEnumerable',
    'valueOf',
    '__proto__',
    'toLocaleString',
];
var CLASS;
(function (CLASS) {
    /**
     * PLEASE PROVIDE NAME AS TYPED STRING, NOT VARIABLE
     * Decorator requred for production mode
     * @param name Name of class
     */
    function NAME(className) {
        return function (target) {
            return setClassName(target, className);
        };
    }
    CLASS.NAME = NAME;
    function setName(target, className) {
        setClassName(target, className);
    }
    CLASS.setName = setName;
    function getClassNameFromObjInstanceOrClassFn(target) {
        if (typeof target === 'object') {
            return getNameFromObject(target);
        }
        return getClassName(target);
    }
    CLASS.getClassNameFromObjInstanceOrClassFn = getClassNameFromObjInstanceOrClassFn;
    function setClassName(target, className) {
        target[lib_1.CoreModels.ClassNameStaticProperty] = className;
        classes.set(className, target);
    }
    CLASS.setClassName = setClassName;
    function getBy(className) {
        let res;
        if (Array.isArray(className)) {
            if (className.length !== 1) {
                throw `Mapping error... please use proper class names:
  {
    propertyObject: 'MyClassName',
    propertyWithArray: ['MyClassName']
  }

        `;
            }
            className = className[0];
        }
        if (typeof className === 'function') {
            // TODO QUICK_FIX
            res = className;
        }
        if (className === 'Date') {
            res = Date;
        }
        if (className === 'FormData') {
            res = FormData;
        }
        const classFromMap = classes.get(className);
        return classFromMap ? classFromMap : res;
    }
    CLASS.getBy = getBy;
    function getFromObject(o) {
        if (lib_1._.isUndefined(o) || lib_1._.isNull(o)) {
            return;
        }
        if (o.constructor) {
            return o.constructor;
        }
        const p = Object.getPrototypeOf(o);
        return p && p.constructor;
    }
    CLASS.getFromObject = getFromObject;
    function getName(target) {
        return getClassName(target);
    }
    CLASS.getName = getName;
    function getNameFromObject(o) {
        const fnCLass = getFromObject(o);
        return getName(fnCLass);
    }
    CLASS.getNameFromObject = getNameFromObject;
    CLASS.getMethodsNames = (classOrClassInstance, allMethodsNames = []) => {
        if (!classOrClassInstance) {
            return allMethodsNames;
        }
        const isClassFunction = lib_1._.isFunction(classOrClassInstance);
        const classFun = isClassFunction
            ? classOrClassInstance
            : Object.getPrototypeOf(classOrClassInstance);
        const objectToCheck = isClassFunction
            ? classOrClassInstance?.prototype
            : classOrClassInstance;
        const prototypeObj = Object.getPrototypeOf(objectToCheck || {});
        const properties = lib_1._.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 CLASS.getMethodsNames(Object.getPrototypeOf(classFun), allMethodsNames);
    };
})(CLASS || (exports.CLASS = CLASS = {}));
//# sourceMappingURL=typescript-class-helpers.js.map