@carno.js/core 0.2.3

package/dist/utils/isInheritedFrom.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInheritedFrom = isInheritedFrom;
+const classOf_1 = require("./classOf");
+const ancestorOf_1 = require("./ancestorOf");
+const nameOf_1 = require("./nameOf");
+function isInheritedFrom(target, from, deep = 5) {
+    if (!target || !from) {
+        return false;
+    }
+    target = (0, classOf_1.classOf)(target);
+    from = (0, classOf_1.classOf)(from);
+    while ((0, nameOf_1.nameOf)(target) !== "") {
+        if (!deep) {
+            return false;
+        }
+        if (target === from) {
+            return true;
+        }
+        target = (0, ancestorOf_1.ancestorOf)(target);
+        deep--;
+    }
+    return false;
+}

package/dist/utils/isMomentObject.d.ts

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

package/dist/utils/isMomentObject.js

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

package/dist/utils/isMongooseObject.d.ts

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

package/dist/utils/isMongooseObject.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isObjectID = isObjectID;
+exports.isMongooseObject = isMongooseObject;
+const hasJsonMethod_1 = require("./hasJsonMethod");
+function isObjectID(obj) {
+    return obj && obj._bsontype;
+}
+function isMongooseObject(obj) {
+    return !!(((0, hasJsonMethod_1.hasJsonMethod)(obj) && obj.$isMongooseModelPrototype) || isObjectID(obj));
+}

package/dist/utils/isNil.d.ts

@@ -0,0 +1 @@
+export declare function isNil(value: any): boolean;

package/dist/utils/isNil.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNil = isNil;
+function isNil(value) {
+    return value === undefined || value === null;
+}

package/dist/utils/isNumber.d.ts

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

package/dist/utils/isNumber.js

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

package/dist/utils/isObject.d.ts

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

package/dist/utils/isObject.js

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

package/dist/utils/isObservable.d.ts

@@ -0,0 +1 @@
+export declare function isObservable<T>(obj: any): boolean;

package/dist/utils/isObservable.js

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

package/dist/utils/isPlainObject.d.ts

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

package/dist/utils/isPlainObject.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isClassObject = isClassObject;
+exports.isPlainObject = isPlainObject;
+const classOf_1 = require("./classOf");
+/**
+ *
+ * @param target
+ * @returns {boolean}
+ */
+function isClassObject(target) {
+    return target === Object;
+}
+function isPlainObject(target) {
+    return isClassObject((0, classOf_1.classOf)(target)) && target !== Object;
+}

package/dist/utils/isPrimitive.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Return true if the given obj is a primitive.
+ * @param target
+ * @returns {boolean}
+ * @ignore
+ */
+export declare function isPrimitiveOrPrimitiveClass(target: any): boolean;
+/**
+ * Return true if the given obj is a primitive.
+ * @param target
+ * @returns {boolean}
+ */
+export declare function isPrimitive(target: any): boolean;
+export declare function isPrimitiveClass(target: any): boolean;

package/dist/utils/isPrimitive.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPrimitiveOrPrimitiveClass = isPrimitiveOrPrimitiveClass;
+exports.isPrimitive = isPrimitive;
+exports.isPrimitiveClass = isPrimitiveClass;
+const isBoolean_1 = require("./isBoolean");
+const isNumber_1 = require("./isNumber");
+const isString_1 = require("./isString");
+/**
+ * Return true if the given obj is a primitive.
+ * @param target
+ * @returns {boolean}
+ * @ignore
+ */
+function isPrimitiveOrPrimitiveClass(target) {
+    return (0, isString_1.isStringOrStringClass)(target) || (0, isNumber_1.isNumberOrNumberClass)(target) || (0, isBoolean_1.isBooleanOrBooleanClass)(target);
+}
+/**
+ * Return true if the given obj is a primitive.
+ * @param target
+ * @returns {boolean}
+ */
+function isPrimitive(target) {
+    return (0, isString_1.isString)(target) || (0, isNumber_1.isNumber)(target) || (0, isBoolean_1.isBoolean)(target);
+}
+function isPrimitiveClass(target) {
+    return [String, Number, Boolean].includes(target);
+}

package/dist/utils/isPrimitiveType.d.ts

@@ -0,0 +1 @@
+export declare function isPrimitiveType(type: any): boolean;

package/dist/utils/isPrimitiveType.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPrimitiveType = isPrimitiveType;
+function isPrimitiveType(type) {
+    return (type === String ||
+        type === Number ||
+        type === Boolean ||
+        type === Symbol ||
+        type === undefined ||
+        type === null);
+}

package/dist/utils/isPromise.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Tests to see if the object is an ES2015 (ES6) Promise
+ * @see {@link https://www.ecma-international.org/ecma-262/6.0/#sec-promise-objects}
+ * @param target
+ * @returns {boolean}
+ */
+export declare function isPromise<T = any>(target: any): target is Promise<T>;

package/dist/utils/isPromise.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPromise = isPromise;
+/**
+ * Tests to see if the object is an ES2015 (ES6) Promise
+ * @see {@link https://www.ecma-international.org/ecma-262/6.0/#sec-promise-objects}
+ * @param target
+ * @returns {boolean}
+ */
+function isPromise(target) {
+    return (target === Promise ||
+        target instanceof Promise ||
+        (!!target && typeof target.subscribe !== "function" && typeof target.then === "function"));
+}

package/dist/utils/isProtectedKey.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Prevent prototype pollution vulnerability
+ * @param key
+ */
+export declare function isProtectedKey(key: string): boolean;

package/dist/utils/isProtectedKey.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isProtectedKey = isProtectedKey;
+/**
+ * Prevent prototype pollution vulnerability
+ * @param key
+ */
+function isProtectedKey(key) {
+    return ["__proto__", "constructor", "prototype"].includes(key);
+}

package/dist/utils/isRegExp.d.ts

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

package/dist/utils/isRegExp.js

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

package/dist/utils/isRequestScope.d.ts

@@ -0,0 +1,11 @@
+import { TokenProvider } from "../commons";
+import { InjectorService } from "../container";
+import { Provider } from "../domain";
+/**
+ * Check if the provider is a request scope or have some dependency that is a request scope
+
+ * @param provider
+ * @param deps
+ * @param injector
+ */
+export declare function isRequestScope(provider: Provider, deps: TokenProvider[], injector: InjectorService): boolean;

package/dist/utils/isRequestScope.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRequestScope = isRequestScope;
+const domain_1 = require("../domain");
+/**
+ * Check if the provider is a request scope or have some dependency that is a request scope
+
+ * @param provider
+ * @param deps
+ * @param injector
+ */
+function isRequestScope(provider, deps, injector) {
+    if (provider.scope === 'request')
+        return true;
+    if (deps.length === 0)
+        return false;
+    return deps.some(dep => {
+        const depProvider = injector.get(dep);
+        if (!depProvider)
+            return false;
+        return depProvider.scope === domain_1.ProviderScope.REQUEST;
+    });
+}

package/dist/utils/isSerializable.d.ts

@@ -0,0 +1 @@
+export declare function isSerializable(data: any): boolean;

package/dist/utils/isSerializable.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSerializable = isSerializable;
+const isStream_1 = require("./isStream");
+const isBoolean_1 = require("./isBoolean");
+const isNumber_1 = require("./isNumber");
+const isString_1 = require("./isString");
+const isNil_1 = require("./isNil");
+function isSerializable(data) {
+    return !(Buffer.isBuffer(data) || (0, isStream_1.isStream)(data) || (0, isBoolean_1.isBoolean)(data) || (0, isNumber_1.isNumber)(data) || (0, isString_1.isString)(data) || (0, isNil_1.isNil)(data));
+}

package/dist/utils/isStream.d.ts

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

package/dist/utils/isStream.js

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

package/dist/utils/isString.d.ts

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

package/dist/utils/isString.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isString = isString;
+exports.isStringOrStringClass = isStringOrStringClass;
+/**
+ * @param target
+ * @returns {boolean}
+ */
+function isString(target) {
+    return typeof target === "string";
+}
+function isStringOrStringClass(target) {
+    return typeof target === "string" || target instanceof String || target === String;
+}

package/dist/utils/isSymbol.d.ts

@@ -0,0 +1,6 @@
+/**
+ *
+ * @param target
+ */
+export declare function isSymbol(target: any): target is symbol;
+export declare function isSymbolOrSymbolClass(target: any): target is symbol;

package/dist/utils/isSymbol.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSymbol = isSymbol;
+exports.isSymbolOrSymbolClass = isSymbolOrSymbolClass;
+/**
+ *
+ * @param target
+ */
+function isSymbol(target) {
+    return typeof target === "symbol";
+}
+function isSymbolOrSymbolClass(target) {
+    return typeof target === "symbol" || target instanceof Symbol || target === Symbol;
+}

package/dist/utils/methodsOf.d.ts

@@ -0,0 +1,9 @@
+import { Type } from "../commons";
+/**
+ * Return all methods for a given class.
+ * @param target
+ */
+export declare function methodsOf(target: any): {
+    target: Type;
+    propertyKey: string;
+}[];

package/dist/utils/methodsOf.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.methodsOf = methodsOf;
+const classOf_1 = require("./classOf");
+const ancestorsOf_1 = require("./ancestorsOf");
+const prototypeOf_1 = require("./prototypeOf");
+/**
+ * Return all methods for a given class.
+ * @param target
+ */
+function methodsOf(target) {
+    const methods = new Map();
+    target = (0, classOf_1.classOf)(target);
+    (0, ancestorsOf_1.ancestorsOf)(target).forEach((target) => {
+        const keys = Reflect.ownKeys((0, prototypeOf_1.prototypeOf)(target));
+        // @ts-ignore
+        keys.forEach((propertyKey) => {
+            if (propertyKey !== "constructor") {
+                methods.set(propertyKey, { target, propertyKey });
+            }
+        });
+    });
+    return Array.from(methods.values());
+}

package/dist/utils/nameOf.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Get the provide name.
+ * @param targetClass
+ */
+export declare function nameOfClass(targetClass: any): string;
+/**
+ * Get symbol name.
+ * @param sym
+ */
+export declare const nameOfSymbol: (sym: symbol) => string;
+/**
+ * Get object name
+ */
+export declare function nameOf(obj: any): string;

package/dist/utils/nameOf.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nameOfSymbol = void 0;
+exports.nameOfClass = nameOfClass;
+exports.nameOf = nameOf;
+/**
+ * Get the provide name.
+ * @param targetClass
+ */
+function nameOfClass(targetClass) {
+    return typeof targetClass === "function" ? targetClass.name : targetClass.constructor.name;
+}
+/**
+ * Get symbol name.
+ * @param sym
+ */
+const nameOfSymbol = (sym) => sym.toString().replace("Symbol(", "").replace(")", "");
+exports.nameOfSymbol = nameOfSymbol;
+/**
+ * Get object name
+ */
+function nameOf(obj) {
+    switch (typeof obj) {
+        default:
+            return "" + obj;
+        case "symbol":
+            return (0, exports.nameOfSymbol)(obj);
+        case "function":
+            return nameOfClass(obj);
+    }
+}

package/dist/utils/objectKeys.d.ts

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

package/dist/utils/objectKeys.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectKeys = objectKeys;
+const isProtectedKey_1 = require("./isProtectedKey");
+function objectKeys(obj) {
+    return Object.keys(obj).filter((key) => !(0, isProtectedKey_1.isProtectedKey)(key));
+}

package/dist/utils/primitiveOf.d.ts

@@ -0,0 +1 @@
+export declare function primitiveOf(target: any): "string" | "number" | "boolean" | "any";

package/dist/utils/primitiveOf.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.primitiveOf = primitiveOf;
+const isBoolean_1 = require("./isBoolean");
+const isNumber_1 = require("./isNumber");
+const isString_1 = require("./isString");
+function primitiveOf(target) {
+    if ((0, isString_1.isStringOrStringClass)(target)) {
+        return "string";
+    }
+    if ((0, isNumber_1.isNumberOrNumberClass)(target)) {
+        return "number";
+    }
+    if ((0, isBoolean_1.isBooleanOrBooleanClass)(target)) {
+        return "boolean";
+    }
+    return "any";
+}

package/dist/utils/prototypeOf.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Return the prototype of the given class.
+ * @param target
+ * @returns {any}
+ */
+export declare function prototypeOf(target: any): any;

package/dist/utils/prototypeOf.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prototypeOf = prototypeOf;
+const classOf_1 = require("./classOf");
+/**
+ * Return the prototype of the given class.
+ * @param target
+ * @returns {any}
+ */
+function prototypeOf(target) {
+    return (0, classOf_1.classOf)(target) === target ? target.prototype : target;
+}

package/dist/utils/setValue.d.ts

@@ -0,0 +1 @@
+export declare function setValue(scope: any, expression: string, value: any, separator?: string): void;

package/dist/utils/setValue.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setValue = setValue;
+const isProtectedKey_1 = require("./isProtectedKey");
+function setValue(scope, expression, value, separator = ".") {
+    const keys = expression.split(separator);
+    const setValue = (key, add) => {
+        if ((0, isProtectedKey_1.isProtectedKey)(key)) {
+            return false;
+        }
+        if (add) {
+            if (typeof scope.set === "function") {
+                scope.set(key, value);
+            }
+            else {
+                scope[key] = value;
+            }
+            return false;
+        }
+        if (typeof scope.set === "function") {
+            if (!scope.has(key)) {
+                scope.set(key, {});
+            }
+            scope = scope.get(key);
+        }
+        else {
+            scope = scope[key] = scope[key] || {};
+        }
+        return true;
+    };
+    while (setValue(keys.shift(), !keys.length)) { }
+}

package/dist/utils/toMap.d.ts

@@ -0,0 +1,3 @@
+export type ToMapIdentityCB<V> = (item: V, index: string | number) => string | string[];
+export type ToMapIdentity<V> = string | ToMapIdentityCB<V>;
+export declare function toMap<K extends keyof any = any, V = any>(input: Record<K, V> | V[], keyOrFn?: ToMapIdentity<V>): Map<K, V>;

package/dist/utils/toMap.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toMap = toMap;
+const isArray_1 = require("./isArray");
+const isString_1 = require("./isString");
+function createIdentityFn(keyOrFn) {
+    if (!keyOrFn) {
+        return (v, k) => String(k);
+    }
+    if ((0, isString_1.isString)(keyOrFn)) {
+        return (item) => {
+            return item[keyOrFn];
+        };
+    }
+    return keyOrFn;
+}
+function toMap(input, keyOrFn) {
+    if ((0, isArray_1.isArray)(input)) {
+        const identity = createIdentityFn(keyOrFn || "id");
+        return input.reduce((map, value, index) => {
+            const ids = [].concat(identity(value, index));
+            ids.forEach((id) => {
+                const item = map.get(id);
+                value = item?.merge?.(value) || value;
+                map.set(id, value);
+            });
+            return map;
+        }, new Map());
+    }
+    const identity = createIdentityFn(keyOrFn);
+    return Object.entries(input).reduce((map, [key, value]) => {
+        return map.set(identity(value, key), value);
+    }, new Map());
+}

package/dist/utils/toStringConstructor.d.ts

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

package/dist/utils/toStringConstructor.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toStringConstructor = toStringConstructor;
+const constructorOf_1 = require("./constructorOf");
+function toStringConstructor(target) {
+    const ctr = (0, constructorOf_1.constructorOf)(target);
+    const strings = ctr.toString().split("\n");
+    const ctrString = strings.find((s) => s.indexOf("constructor(") > -1) || "constructor()";
+    return `${ctrString.replace("{", "").trim()}`;
+}