@leyyo/common 1.0.0 → 1.0.1

package/dist/aliases.d.ts

@@ -91,16 +91,44 @@ type OneOfByKey<T> = {
 type XorIn<T> = {
     [K in keyof T]: T[K];
 } & unknown;
+/**
+ * An interface which contains secure mode members and provides to shift to main mode
+ * */
 export interface ShiftSecure<S extends ShiftMain<any>> {
+    /**
+     * Shifts to secure mode
+     * */
     get $secure(): S;
 }
-export interface ShiftFlat<D> {
-    get $flat(): D;
-}
+/**
+ * An interface which contains main mode members and provides to shift to secure mode
+ *
+ * IT's so useful to hide some public members
+ * - to see clean auto-completed members in IDE
+ * - to indicated that secure mode members should be used in special cases
+ * */
 export interface ShiftMain<M extends ShiftSecure<any>> {
+    /**
+     * Shifts to main mode
+     * */
     get $back(): M;
 }
+/**
+ * An interface which provides to flat generic interfaces/classes to prevent verbose casting commands
+ * */
+export interface ShiftFlat<D> {
+    /**
+     * Flats current classes, or eliminate generic parameters
+     * */
+    get $flat(): D;
+}
+/**
+ * Useful interface which provides initialization state for instances
+ * */
 export interface InitLike {
+    /**
+     * Initializes the instance
+     * */
     $init(...args: Arr): void;
 }
 /**

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

@@ -1,34 +1,66 @@
 import { AssertionCallback, AssertionOpt, CommonAssertion, CommonAssertionSecure } from "./index-types";
 import { Leyyo } from "../leyyo";
-import { TypeOpt } from "../to";
+import { ToTypeOpt } from "../to";
 import { Arr, Obj } from "../aliases";
+/** @inheritDoc */
 export declare class CommonAssertionImpl implements CommonAssertion, CommonAssertionSecure {
     private is;
     private callback;
     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

@@ -2,12 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommonAssertionImpl = void 0;
 const error_1 = require("../error");
+/** @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 +25,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 +40,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;
@@ -76,8 +83,9 @@ 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":
@@ -93,116 +101,145 @@ class CommonAssertionImpl {
         def = def !== null && def !== void 0 ? def : 'Assertion error';
         throw new error_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;
     }
+    /** @inheritDoc */
     get $secure() {
         return this;
     }