@leyyo/common 1.0.0 → 1.0.2

package/dist/assertion/common-assertion-impl.d.ts

@@ -1,34 +1,65 @@
-import { AssertionCallback, AssertionOpt, CommonAssertion, CommonAssertionSecure } from "./index-types";
+import { CommonAssertion, CommonAssertionSecure } from "./index-types";
 import { Leyyo } from "../leyyo";
-import { TypeOpt } from "../to";
-import { Arr, Obj } from "../aliases";
+import { Arr, AssertionCallback, AssertionOpt, Obj, ToTypeOpt } from "../shared";
+/** @inheritDoc */
 export declare class CommonAssertionImpl implements CommonAssertion, CommonAssertionSecure {
     private is;
-    private callback;
+    private fqn;
     constructor();
-    private buildMessage;
+    /**
+     * Build error parameters as message and params
+     * */
+    private buildErrorParameters;
+    /**
+     * Inner secure json function, it will be used after creating weak set
+     * */
     _secureJson(value: unknown, level: number, set: WeakSet<Obj>): unknown;
+    /** @inheritDoc */
     raise(opt: string | AssertionOpt | AssertionCallback, value?: any, indicator?: string, def?: string): void;
+    /** @inheritDoc */
     emptyFn(...params: Arr): void;
+    /** @inheritDoc */
     secureJson<E = unknown>(value: unknown): E;
-    realNumber(value: number, opt?: TypeOpt): number;
+    /** @inheritDoc */
     array(value: unknown, opt?: string | AssertionOpt | AssertionCallback): void;
+    /** @inheritDoc */
     boolean(value: unknown, opt?: string | AssertionOpt | AssertionCallback): void;
+    /** @inheritDoc */
     clazz(value: unknown, opt?: string | AssertionOpt | AssertionCallback): void;
+    /** @inheritDoc */
     date(value: unknown, opt?: string | AssertionOpt | AssertionCallback): void;
+    /** @inheritDoc */
     func(value: unknown, opt?: string | AssertionOpt | AssertionCallback): void;
+    /** @inheritDoc */
     integer(value: unknown, opt?: string | AssertionOpt | AssertionCallback): void;
+    /** @inheritDoc */
     key(value: unknown, opt?: string | AssertionOpt | AssertionCallback): void;
+    /** @inheritDoc */
     notEmpty(value: unknown, opt?: string | AssertionOpt | AssertionCallback): void;
+    /** @inheritDoc */
     number(value: unknown, opt?: string | AssertionOpt | AssertionCallback): void;
+    /** @inheritDoc */
+    realNumber(value: number, opt?: ToTypeOpt): number;
+    /** @inheritDoc */
     object(value: unknown, opt?: string | AssertionOpt | AssertionCallback): void;
+    /** @inheritDoc */
     positiveInteger(value: unknown, opt?: string | AssertionOpt | AssertionCallback): void;
+    /** @inheritDoc */
+    safeInteger(value: any, opt?: string | AssertionCallback | AssertionOpt): void;
+    /** @inheritDoc */
     positiveNumber(value: unknown, opt?: string | AssertionOpt | AssertionCallback): void;
+    /** @inheritDoc */
     primitive(value: unknown, opt?: string | AssertionOpt | AssertionCallback): void;
+    /** @inheritDoc */
     string(value: unknown, opt?: string | AssertionOpt | AssertionCallback): void;
+    /** @inheritDoc */
     text(value: unknown, opt?: string | AssertionOpt | AssertionCallback): string;
-    value(value: unknown, opt?: string | AssertionOpt | AssertionCallback): void;
+    /** @inheritDoc */
+    realValue(value: unknown, opt?: string | AssertionOpt | AssertionCallback): void;
+    /** @inheritDoc */
     get $back(): CommonAssertion;
+    /** @inheritDoc */
     $init(leyyo: Leyyo): void;
+    /** @inheritDoc */
     get $secure(): CommonAssertionSecure;
 }

package/dist/assertion/common-assertion-impl.js

@@ -1,13 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommonAssertionImpl = void 0;
-const error_1 = require("../error");
+const exception_1 = require("../exception");
+// noinspection JSUnusedGlobalSymbols
+/** @inheritDoc */
 class CommonAssertionImpl {
     // endregion properties
     constructor() {
     }
     // region internal
-    buildMessage(v2, indicator) {
+    /**
+     * Build error parameters as message and params
+     * */
+    buildErrorParameters(v2, indicator) {
         if (typeof v2 === 'string') {
             return { message: v2, params: { indicator } };
         }
@@ -21,7 +26,7 @@ class CommonAssertionImpl {
         }
         if (typeof v2 === 'function') {
             try {
-                return this.buildMessage(v2(), indicator);
+                return this.buildErrorParameters(v2(), indicator);
             }
             catch (e) {
                 return { params: { indicator, callbackError: e.message } };
@@ -36,6 +41,9 @@ class CommonAssertionImpl {
         }
         return { params: { json, indicator } };
     }
+    /**
+     * Inner secure json function, it will be used after creating weak set
+     * */
     _secureJson(value, level, set) {
         if ([null, undefined].includes(value)) {
             return null;
@@ -43,10 +51,10 @@ class CommonAssertionImpl {
         switch (typeof value) {
             case 'object':
                 if (set.has(value)) {
-                    return `<circular>${this.callback.fqnName(value === null || value === void 0 ? void 0 : value.constructor)}`;
+                    return `<circular>${this.fqn.name(value === null || value === void 0 ? void 0 : value.constructor)}`;
                 }
                 if (level >= 10) {
-                    return `<max-depth>${this.callback.fqnName(value === null || value === void 0 ? void 0 : value.constructor)}`;
+                    return `<max-depth>${this.fqn.name(value === null || value === void 0 ? void 0 : value.constructor)}`;
                 }
                 set.add(value);
                 if (Array.isArray(value)) {
@@ -68,7 +76,7 @@ class CommonAssertionImpl {
                 }
                 return obj;
             case 'function':
-                return `<function>${this.callback.fqnName(value)}`;
+                return `<function>${this.fqn.name(value)}`;
             case 'symbol':
                 return `<symbol>${value.toString()}`;
         }
@@ -76,133 +84,163 @@ class CommonAssertionImpl {
     }
     // endregion internal
     // region raise
+    /** @inheritDoc */
     raise(opt, value, indicator, def) {
-        const { message, params } = this.buildMessage(opt, indicator);
+        const { message, params } = this.buildErrorParameters(opt, indicator);
         const type = typeof value;
         switch (type) {
             case "object":
-                params.type = `object(${this.callback.fqnName(value.constructor)})`;
+                params.type = `object(${this.fqn.name(value.constructor)})`;
                 break;
             case "function":
-                params.type = `function(${this.callback.fqnName(value)})`;
+                params.type = `function(${this.fqn.name(value)})`;
                 break;
             default:
                 params.type = type;
                 break;
         }
         def = def !== null && def !== void 0 ? def : 'Assertion error';
-        throw new error_1.AssertionException(message !== null && message !== void 0 ? message : def, params);
+        throw new exception_1.AssertionException(message !== null && message !== void 0 ? message : def, params);
     }
+    /** @inheritDoc */
     // noinspection JSUnusedLocalSymbols
-    emptyFn(...params) { }
+    emptyFn(...params) {
+    }
+    /** @inheritDoc */
     secureJson(value) {
         return this._secureJson(value, 0, new WeakSet());
     }
-    realNumber(value, opt) {
-        if (isNaN(value) || !isFinite(value)) {
-            if (!opt) {
-                opt = {};
-            }
-            if (!opt.silent) {
-                delete opt.silent;
-                this.raise(opt, value, 'not.real.number', 'Not real number');
-            }
-            return null;
-        }
-        return value;
-    }
     // endregion raise
     // region types
+    /** @inheritDoc */
     array(value, opt) {
         if (!this.is.array(value)) {
             this.raise(opt, value, 'invalid.array.value', 'Invalid array value');
         }
     }
+    /** @inheritDoc */
     boolean(value, opt) {
         if (!this.is.boolean(value)) {
             this.raise(opt, value, 'invalid.boolean.value', 'Invalid boolean value');
         }
     }
+    /** @inheritDoc */
     clazz(value, opt) {
         if (!this.is.clazz(value)) {
             this.raise(opt, value, 'invalid.class.value', 'Invalid class value');
         }
     }
+    /** @inheritDoc */
     date(value, opt) {
         if (!(value instanceof Date)) {
             this.raise(opt, value, 'invalid.date.value', 'Invalid date value');
         }
     }
+    /** @inheritDoc */
     func(value, opt) {
         if (!this.is.func(value)) {
             this.raise(opt, value, 'invalid.function.value', 'Invalid function value');
         }
     }
+    /** @inheritDoc */
     integer(value, opt) {
         if (!this.is.integer(value)) {
             this.raise(opt, value, 'invalid.integer.value', 'Invalid integer value');
         }
     }
+    /** @inheritDoc */
     key(value, opt) {
         if (!this.is.key(value)) {
             this.raise(opt, value, 'invalid.key.value', 'Invalid key value');
         }
     }
+    /** @inheritDoc */
     notEmpty(value, opt) {
         if (this.is.empty(value)) {
             this.raise(opt, value, 'empty.value', 'Empty value');
         }
     }
+    /** @inheritDoc */
     number(value, opt) {
         if (!this.is.number(value)) {
             this.raise(opt, value, 'invalid.number.value', 'Invalid number value');
         }
     }
+    /** @inheritDoc */
+    realNumber(value, opt) {
+        if (isNaN(value) || !isFinite(value)) {
+            if (!opt) {
+                opt = {};
+            }
+            if (!opt.silent) {
+                delete opt.silent;
+                this.raise(opt, value, 'not.real.number', 'Not real number');
+            }
+            return null;
+        }
+        return value;
+    }
+    /** @inheritDoc */
     object(value, opt) {
         if (!this.is.object(value)) {
             this.raise(opt, value, 'invalid.object.value', 'Invalid object value');
         }
     }
+    /** @inheritDoc */
     positiveInteger(value, opt) {
         if (!this.is.integer(value) || (value <= 0)) {
             this.raise(opt, value, 'invalid.positive.integer.value', 'Invalid positive integer value');
         }
     }
+    /** @inheritDoc */
+    safeInteger(value, opt) {
+        if (!this.is.safeInteger(value) || (value <= 0)) {
+            this.raise(opt, value, 'invalid.safe.integer.value', 'Invalid safe integer value');
+        }
+    }
+    /** @inheritDoc */
     positiveNumber(value, opt) {
         if (!this.is.number(value) || (value <= 0)) {
             this.raise(opt, value, 'invalid.positive.number.value', 'Invalid positive number value');
         }
     }
+    /** @inheritDoc */
     primitive(value, opt) {
         if (!this.is.primitive(value)) {
             this.raise(opt, value, 'invalid.primitive.value', 'Invalid primitive value');
         }
     }
+    /** @inheritDoc */
     string(value, opt) {
         if (!this.is.string(value)) {
             this.raise(opt, value, 'invalid.string.value', 'Invalid string value');
         }
     }
+    /** @inheritDoc */
     text(value, opt) {
         if (!this.is.text(value)) {
             this.raise(opt, value, 'invalid.text.value', 'Invalid text value');
         }
         return value.trim();
     }
-    value(value, opt) {
+    /** @inheritDoc */
+    realValue(value, opt) {
         if (!this.is.text(value)) {
             this.raise(opt, value, 'invalid.value.value', 'Invalid regular value');
         }
     }
     // endregion types
     // region secure
+    /** @inheritDoc */
     get $back() {
         return this;
     }
+    /** @inheritDoc */
     $init(leyyo) {
         this.is = leyyo.is;
-        this.callback = leyyo.callback;
+        this.fqn = leyyo.fqn;
     }
+    /** @inheritDoc */
     get $secure() {
         return this;
     }