@carno.js/core 0.2.3

package/dist/utils/createInstance.d.ts

@@ -0,0 +1 @@
+export declare function createInstance(obj: any): any;

package/dist/utils/createInstance.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInstance = createInstance;
+const classOf_1 = require("./classOf");
+function createInstance(obj) {
+    return obj ? ((0, classOf_1.classOf)(obj) !== Object ? Object.create(obj) : {}) : {};
+}

package/dist/utils/decoratorTypeOf.d.ts

@@ -0,0 +1,11 @@
+export declare enum DecoratorTypes {
+    PARAM = "parameter",
+    PARAM_CTOR = "parameter.constructor",
+    PARAM_STC = "parameter.static",
+    PROP = "property",
+    PROP_STC = "property.static",
+    METHOD = "method",
+    METHOD_STC = "method.static",
+    CLASS = "class"
+}
+export declare function decoratorTypeOf(args: any[]): DecoratorTypes;

package/dist/utils/decoratorTypeOf.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DecoratorTypes = void 0;
+exports.decoratorTypeOf = decoratorTypeOf;
+const classOf_1 = require("./classOf");
+var DecoratorTypes;
+(function (DecoratorTypes) {
+    DecoratorTypes["PARAM"] = "parameter";
+    DecoratorTypes["PARAM_CTOR"] = "parameter.constructor";
+    DecoratorTypes["PARAM_STC"] = "parameter.static";
+    DecoratorTypes["PROP"] = "property";
+    DecoratorTypes["PROP_STC"] = "property.static";
+    DecoratorTypes["METHOD"] = "method";
+    DecoratorTypes["METHOD_STC"] = "method.static";
+    DecoratorTypes["CLASS"] = "class";
+})(DecoratorTypes || (exports.DecoratorTypes = DecoratorTypes = {}));
+function decoratorTypeOf(args) {
+    const [target, propertyKey, descriptor] = args;
+    const staticType = (type) => {
+        return target !== (0, classOf_1.classOf)(target) ? type : `${type}.static`;
+    };
+    if (typeof descriptor === "number") {
+        return propertyKey ? staticType("parameter") : DecoratorTypes.PARAM_CTOR;
+    }
+    if (descriptor && descriptor.value) {
+        return staticType("method");
+    }
+    if ((propertyKey && descriptor === undefined) || descriptor) {
+        return staticType("property");
+    }
+    return DecoratorTypes.CLASS;
+}

package/dist/utils/deepClone.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Return a cloned value
+ * @param source
+ * @param stack
+ */
+export declare function deepClone(source: any, stack?: WeakMap<object, any>): any;

package/dist/utils/deepClone.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepClone = deepClone;
+const isArray_1 = require("./isArray");
+const isDate_1 = require("./isDate");
+const isFunction_1 = require("./isFunction");
+const isNil_1 = require("./isNil");
+const isPrimitive_1 = require("./isPrimitive");
+const isSymbol_1 = require("./isSymbol");
+const isBuffer_1 = require("./isBuffer");
+const isRegExp_1 = require("./isRegExp");
+const isBasicType = (source) => (0, isNil_1.isNil)(source) || (0, isPrimitive_1.isPrimitive)(source) || (0, isSymbol_1.isSymbol)(source) || (0, isFunction_1.isFunction)(source);
+/**
+ * Return a cloned value
+ * @param source
+ * @param stack
+ */
+function deepClone(source, stack = new WeakMap()) {
+    let dest;
+    if (isBasicType(source)) {
+        return source;
+    }
+    if ((0, isBuffer_1.isBuffer)(source)) {
+        const copy = Buffer.alloc(source.length);
+        source.copy(copy);
+        return copy;
+    }
+    if ((0, isDate_1.isDate)(source)) {
+        return new Date(source);
+    }
+    if ((0, isRegExp_1.isRegExp)(source)) {
+        return new RegExp(source);
+    }
+    const stacked = stack.get(source);
+    if (stacked) {
+        // See issue #1619
+        return stacked;
+    }
+    if ((0, isArray_1.isArray)(source)) {
+        dest = [];
+    }
+    else {
+        dest = {};
+        stack.set(source, dest);
+    }
+    for (const key in source) {
+        // Use getOwnPropertyDescriptor instead of source[key] to prevent from triggering setter/getter.
+        const descriptor = Object.getOwnPropertyDescriptor(source, key);
+        if (descriptor) {
+            if (!(0, isFunction_1.isFunction)(descriptor.value)) {
+                dest[key] = deepClone(descriptor.value, stack);
+            }
+            else {
+                Object.defineProperty(dest, key, descriptor);
+            }
+        }
+    }
+    if (!(0, isArray_1.isArray)(source)) {
+        const prototype = Reflect.getPrototypeOf(source);
+        Reflect.setPrototypeOf(dest, prototype);
+    }
+    return dest;
+}

package/dist/utils/deepMerge.d.ts

@@ -0,0 +1,9 @@
+export type DeepMergeReducerCB = (collection: any[], value: any, options?: DeepMergeOptions) => any;
+export type DeepMergeComparatorCB = (item: any, ref: any) => boolean;
+export interface DeepMergeOptions {
+    reducers?: Record<string, DeepMergeReducerCB>;
+    parentKey?: string;
+    cleanUndefinedProps?: boolean;
+}
+export declare function mergeReducerBuilder(cb: DeepMergeComparatorCB): (collection: any[], value: any, options: DeepMergeOptions) => any[];
+export declare function deepMerge<T = any, C = any>(source: T & any, obj: C & any, options?: DeepMergeOptions): (T & C) | undefined | null;

package/dist/utils/deepMerge.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeReducerBuilder = mergeReducerBuilder;
+exports.deepMerge = deepMerge;
+const createInstance_1 = require("./createInstance");
+const isFunction_1 = require("./isFunction");
+const isPrimitive_1 = require("./isPrimitive");
+const isSymbol_1 = require("./isSymbol");
+const objectKeys_1 = require("./objectKeys");
+function mergeReducerBuilder(cb) {
+    return (collection, value, options) => {
+        const index = collection.findIndex((item) => cb(item, value));
+        if (index === -1) {
+            return [...collection, value];
+        }
+        collection[index] = deepMerge(collection[index], value, options);
+        return collection;
+    };
+}
+const defaultReducer = mergeReducerBuilder((a, b) => a === b);
+function getReducer({ reducers, parentKey }) {
+    if (!reducers) {
+        return defaultReducer;
+    }
+    if (parentKey && reducers[parentKey]) {
+        return reducers[parentKey];
+    }
+    return reducers["default"] || defaultReducer;
+}
+function shouldReturnObj(obj, source) {
+    return (0, isPrimitive_1.isPrimitive)(obj) || (0, isSymbol_1.isSymbol)(obj) || (0, isFunction_1.isFunction)(obj) || source === undefined;
+}
+function shouldReturnSource(obj, source) {
+    return obj === undefined || obj === null || (obj === "" && source !== "");
+}
+function deepMerge(source, obj, options = {}) {
+    if (shouldReturnSource(obj, source)) {
+        return source;
+    }
+    if (shouldReturnObj(obj, source)) {
+        return obj;
+    }
+    if (Array.isArray(source)) {
+        const reducer = getReducer(options);
+        // @ts-ignore
+        return [].concat(obj).reduce((out, value) => reducer(out, value, options), [...source]);
+    }
+    return [...(0, objectKeys_1.objectKeys)(source), ...(0, objectKeys_1.objectKeys)(obj)].reduce((out, key) => {
+        const src = source && source[key];
+        const value = deepMerge(src, obj && obj[key], {
+            ...options,
+            parentKey: key
+        });
+        if (options.cleanUndefinedProps && value === undefined) {
+            return out;
+        }
+        return {
+            ...out,
+            [key]: value
+        };
+    }, (0, createInstance_1.createInstance)(source));
+}

package/dist/utils/descriptorOf.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Return the descriptor for a given class and propertyKey
+ * @param target
+ * @param {string} propertyKey
+ * @returns {PropertyDescriptor}
+ */
+export declare function descriptorOf(target: any, propertyKey: string | symbol): PropertyDescriptor;
+export declare function isMethodDescriptor(target: any, propertyKey: string | symbol): any;

package/dist/utils/descriptorOf.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.descriptorOf = descriptorOf;
+exports.isMethodDescriptor = isMethodDescriptor;
+/**
+ * Return the descriptor for a given class and propertyKey
+ * @param target
+ * @param {string} propertyKey
+ * @returns {PropertyDescriptor}
+ */
+function descriptorOf(target, propertyKey) {
+    return Object.getOwnPropertyDescriptor((target && target.prototype) || target, propertyKey);
+}
+function isMethodDescriptor(target, propertyKey) {
+    return descriptorOf(target, propertyKey)?.value;
+}

package/dist/utils/getClassOrSymbol.d.ts

@@ -0,0 +1 @@
+export declare function getClassOrSymbol(target: any): any;

package/dist/utils/getClassOrSymbol.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getClassOrSymbol = getClassOrSymbol;
+const classOf_1 = require("./classOf");
+const isClass_1 = require("./isClass");
+function getClassOrSymbol(target) {
+    return (0, isClass_1.isClass)(target) ? (0, classOf_1.classOf)(target) : target;
+}

package/dist/utils/getConstructorArgNames.d.ts

@@ -0,0 +1 @@
+export declare function getConstructorArgNames(target: any): string[];

package/dist/utils/getConstructorArgNames.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConstructorArgNames = getConstructorArgNames;
+const toStringConstructor_1 = require("./toStringConstructor");
+function getConstructorArgNames(target) {
+    return (0, toStringConstructor_1.toStringConstructor)(target)
+        .split("constructor(")[1]
+        .split(")")[0]
+        .split(", ")
+        .filter(Boolean)
+        .map((s) => s.trim());
+}

package/dist/utils/getMethodArgTypes.d.ts

@@ -0,0 +1 @@
+export declare function getMethodArgTypes(target: any, methodName: string): any;

package/dist/utils/getMethodArgTypes.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMethodArgTypes = getMethodArgTypes;
+function getMethodArgTypes(target, methodName) {
+    if (!target[methodName]) {
+        throw new Error(`Method ${methodName} not found`);
+    }
+    return Reflect.getMetadata('design:paramtypes', target, methodName) || [];
+}

package/dist/utils/getValue.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Get value from scope
+ * @param {string} expression
+ * @param scope
+ * @returns {any}
+ */
+export declare function getValue<T = any>(scope: any, expression: string | undefined): T | undefined;
+/**
+ * Get value from scope
+ * @param {string} expression
+ * @param scope
+ * @param defaultValue
+ * @param separator
+ * @returns {any}
+ */
+export declare function getValue<T = any>(scope: any, expression: string | undefined, defaultValue: T, separator?: string): T;
+/**
+ * Get value from scope
+ * @param {string} expression
+ * @param scope
+ * @returns {any}
+ */
+export declare function getValue<T = any>(expression: string | undefined, scope: any): T | undefined;
+/**
+ * Get value from scope
+ * @param {string} expression
+ * @param scope
+ * @param defaultValue
+ * @param separator
+ * @returns {any}
+ */
+export declare function getValue<T = any>(expression: string | undefined, scope: any, defaultValue: T, separator?: string): T;

package/dist/utils/getValue.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getValue = getValue;
+const isFunction_1 = require("./isFunction");
+const isObject_1 = require("./isObject");
+const isString_1 = require("./isString");
+const mapOptions = (args) => {
+    const [expression, scope, defaultValue, separator = "."] = args;
+    if ((0, isObject_1.isObject)(scope) || (0, isString_1.isString)(expression)) {
+        return {
+            expression,
+            scope,
+            defaultValue,
+            separator
+        };
+    }
+    return {
+        expression: scope,
+        scope: expression,
+        defaultValue,
+        separator
+    };
+};
+function getValue(...args) {
+    const options = mapOptions(args);
+    let scope = options.scope;
+    const { expression, defaultValue, separator } = options;
+    if (!expression) {
+        return scope;
+    }
+    if (!scope) {
+        return defaultValue;
+    }
+    const keys = expression.split(separator);
+    const getValue = (key) => {
+        if (scope) {
+            if (scope[key] !== undefined || ((0, isObject_1.isObject)(scope) && key in scope)) {
+                return scope[key];
+            }
+            if ((0, isFunction_1.isFunction)(scope.get)) {
+                return scope.get(key);
+            }
+        }
+    };
+    while ((scope = getValue(keys.shift())) && keys.length) { }
+    return scope === undefined ? defaultValue : scope;
+}

package/dist/utils/hasJsonMethod.d.ts

@@ -0,0 +1 @@
+export declare function hasJsonMethod(obj: any): boolean;

package/dist/utils/hasJsonMethod.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasJsonMethod = hasJsonMethod;
+function hasJsonMethod(obj) {
+    return obj && typeof obj.toJSON === "function";
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,15 @@
+export * from './isObject';
+export * from './classOf';
+export * from './isString';
+export * from './isFunction';
+export * from './getConstructorArgNames';
+export * from './getValue';
+export * from './isClassValidator';
+export * from './getMethodArgTypes';
+export * from './getClassOrSymbol';
+export * from './isRequestScope';
+export * from './nameOf';
+export * from './isPrimitiveType';
+export * from './setValue';
+export * from './isClass';
+export * from './methodsOf';

package/dist/utils/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./isObject"), exports);
+__exportStar(require("./classOf"), exports);
+__exportStar(require("./isString"), exports);
+__exportStar(require("./isFunction"), exports);
+__exportStar(require("./getConstructorArgNames"), exports);
+__exportStar(require("./getValue"), exports);
+__exportStar(require("./isClassValidator"), exports);
+__exportStar(require("./getMethodArgTypes"), exports);
+__exportStar(require("./getClassOrSymbol"), exports);
+__exportStar(require("./isRequestScope"), exports);
+__exportStar(require("./nameOf"), exports);
+__exportStar(require("./isPrimitiveType"), exports);
+__exportStar(require("./setValue"), exports);
+__exportStar(require("./isClass"), exports);
+__exportStar(require("./methodsOf"), exports);

package/dist/utils/isArray.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Return true if value is an array
+ * @param target
+ * @returns {boolean}
+ */
+export declare function isArray<T = any>(target: unknown): target is T[];
+/**
+ * Return true if the clazz is an array.
+ * @param target
+ * @returns {boolean}
+ * @ignore
+ */
+export declare function isArrayOrArrayClass<T = any>(target: unknown): target is T[];

package/dist/utils/isArray.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isArray = isArray;
+exports.isArrayOrArrayClass = isArrayOrArrayClass;
+/**
+ * Return true if value is an array
+ * @param target
+ * @returns {boolean}
+ */
+function isArray(target) {
+    return Array.isArray(target);
+}
+/**
+ * Return true if the clazz is an array.
+ * @param target
+ * @returns {boolean}
+ * @ignore
+ */
+function isArrayOrArrayClass(target) {
+    return target === Array || isArray(target);
+}

package/dist/utils/isArrowFn.d.ts

@@ -0,0 +1 @@
+export declare function isArrowFn(target: any): target is Function;

package/dist/utils/isArrowFn.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isArrowFn = isArrowFn;
+const isFunction_1 = require("./isFunction");
+function isArrowFn(target) {
+    return target && (0, isFunction_1.isFunction)(target) && !target.prototype;
+}

package/dist/utils/isBoolean.d.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ * @param target
+ * @returns {boolean}
+ */
+export declare function isBoolean(target: any): target is boolean;
+export declare function isBooleanOrBooleanClass(target: any): target is boolean;

package/dist/utils/isBoolean.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBoolean = isBoolean;
+exports.isBooleanOrBooleanClass = isBooleanOrBooleanClass;
+/**
+ *
+ * @param target
+ * @returns {boolean}
+ */
+function isBoolean(target) {
+    return typeof target === "boolean" || target instanceof Boolean || target === Boolean;
+}
+function isBooleanOrBooleanClass(target) {
+    return typeof target === "boolean" || target instanceof Boolean || target === Boolean;
+}

package/dist/utils/isBuffer.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Tests to see if the object is Buffer
+ * @param target
+ * @returns {boolean}
+ */
+export declare function isBuffer(target: any): target is Buffer;
+export declare function isUint8Array(target: any): target is Uint8Array;

package/dist/utils/isBuffer.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBuffer = isBuffer;
+exports.isUint8Array = isUint8Array;
+/**
+ * Tests to see if the object is Buffer
+ * @param target
+ * @returns {boolean}
+ */
+function isBuffer(target) {
+    // is Class
+    if (target && "isBuffer" in target && typeof target.isBuffer === "function") {
+        return true;
+    }
+    return isUint8Array(target);
+}
+function isUint8Array(target) {
+    return !!(target && (target === Uint8Array || target instanceof Uint8Array));
+}

package/dist/utils/isClass.d.ts

@@ -0,0 +1 @@
+export declare function isClass(target: any): boolean;

package/dist/utils/isClass.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isClass = isClass;
+const isArray_1 = require("./isArray");
+const isArrowFn_1 = require("./isArrowFn");
+const isBuffer_1 = require("./isBuffer");
+const isDate_1 = require("./isDate");
+const isPlainObject_1 = require("./isPlainObject");
+const isPrimitive_1 = require("./isPrimitive");
+const isPromise_1 = require("./isPromise");
+const isSymbol_1 = require("./isSymbol");
+function isClass(target) {
+    if (!target) {
+        return false;
+    }
+    if ((0, isArrowFn_1.isArrowFn)(target)) {
+        return false;
+    }
+    return !((0, isSymbol_1.isSymbol)(target) ||
+        (0, isPrimitive_1.isPrimitiveOrPrimitiveClass)(target) ||
+        (0, isPlainObject_1.isClassObject)(target) ||
+        (0, isDate_1.isDate)(target) ||
+        (0, isPromise_1.isPromise)(target) ||
+        (0, isArray_1.isArrayOrArrayClass)(target) ||
+        (0, isBuffer_1.isBuffer)(target));
+}

package/dist/utils/isClassValidator.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Verifica se a classe possui implementação do class-validator ou class-transformer.
+ *
+ * @param token
+ */
+export declare function isClassValidator(token: Function): boolean;

package/dist/utils/isClassValidator.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isClassValidator = isClassValidator;
+const class_validator_1 = require("class-validator");
+/**
+ * Verifica se a classe possui implementação do class-validator ou class-transformer.
+ *
+ * @param token
+ */
+function isClassValidator(token) {
+    const validationMetadata = (0, class_validator_1.getMetadataStorage)();
+    return validationMetadata.getTargetValidationMetadatas(token, '', false, false, []).length > 0;
+}

package/dist/utils/isCollection.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Return true if the target.
+ * @param target
+ * @returns {boolean}
+ */
+export declare function isCollection(target: any): boolean;

package/dist/utils/isCollection.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCollection = isCollection;
+const isArray_1 = require("./isArray");
+/**
+ * Return true if the target.
+ * @param target
+ * @returns {boolean}
+ */
+function isCollection(target) {
+    return ((0, isArray_1.isArrayOrArrayClass)(target) ||
+        target === Map ||
+        target instanceof Map ||
+        target === Set ||
+        target instanceof Set ||
+        target === WeakMap ||
+        target instanceof WeakMap ||
+        target === WeakSet ||
+        target instanceof WeakSet);
+}

package/dist/utils/isDate.d.ts

@@ -0,0 +1,6 @@
+/**
+ *
+ * @param target
+ * @returns {boolean}
+ */
+export declare function isDate(target: any): target is Date;

package/dist/utils/isDate.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDate = isDate;
+/**
+ *
+ * @param target
+ * @returns {boolean}
+ */
+function isDate(target) {
+    return target === Date || (target instanceof Date && !isNaN(+target));
+}

package/dist/utils/isEmpty.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Return true if the value is an empty string, null or undefined.
+ * @param value
+ * @returns {boolean}
+ */
+export declare function isEmpty(value: any): boolean;

package/dist/utils/isEmpty.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEmpty = isEmpty;
+const isNil_1 = require("./isNil");
+/**
+ * Return true if the value is an empty string, null or undefined.
+ * @param value
+ * @returns {boolean}
+ */
+function isEmpty(value) {
+    return value === "" || (0, isNil_1.isNil)(value);
+}

package/dist/utils/isFunction.d.ts

@@ -0,0 +1 @@
+export declare function isFunction(target: any): target is Function;

package/dist/utils/isFunction.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFunction = isFunction;
+function isFunction(target) {
+    return typeof target === "function";
+}

package/dist/utils/isInheritedFrom.d.ts

@@ -0,0 +1 @@
+export declare function isInheritedFrom(target: any, from: any, deep?: number): boolean;