@leyyo/common 1.0.0 → 1.0.2

package/dist/assertion/index-types.d.ts

@@ -1,79 +1,470 @@
-import { Leyyo } from "../leyyo";
-import { Arr, OneOrMore, ShiftMain, ShiftSecure } from "../aliases";
-import { TypeOpt } from "../to";
+import { Arr, AssertionCallback, AssertionOpt, InitLike, ShiftMain, ShiftSecure, ToTypeOpt } from "../shared";
+/**
+ * Basic assertions to easy use
+ * */
 export interface CommonAssertion extends ShiftSecure<CommonAssertionSecure> {
-    raise(opt: string, value?: any, indicator?: string, def?: string): void;
-    raise(opt: AssertionCallback, value?: any, indicator?: string, def?: string): void;
+    /**
+     * Raises an error with given parameters
+     *
+     * @param {string} message - error message
+     * @param {any?} value
+     * @param {string?} indicator - developer indicator
+     * @param {string?} def - default error message
+     * */
+    raise(message: string, value?: any, indicator?: string, def?: string): void;
+    /**
+     * Raises an error with given parameters
+     *
+     * @param {AssertionCallback} fn - callback which should return {@link AssertionOpt}
+     * @param {any?} value
+     * @param {string?} indicator - developer indicator
+     * @param {string?} def - default error message
+     * */
+    raise(fn: AssertionCallback, value?: any, indicator?: string, def?: string): void;
+    /**
+     * Raises an error with given parameters
+     *
+     * @param {AssertionOpt} opt - options
+     * @param {any?} value
+     * @param {string?} indicator - developer indicator
+     * @param {string?} def - default error message
+     * */
     raise(opt: AssertionOpt, value?: any, indicator?: string, def?: string): void;
+    /**
+     * Empty function, it can be more useful sometimes
+     *
+     * @param {Arr} params - insignificant parameters
+     * */
     emptyFn(...params: Arr): void;
-    secureJson<E = unknown>(value: unknown): E;
-    realNumber(value: number, opt?: TypeOpt): number;
-    notEmpty(value: unknown, message?: string): void;
-    notEmpty(value: unknown, fn?: AssertionCallback): void;
-    notEmpty(value: unknown, opt?: AssertionOpt): void;
-    primitive(value: unknown, message?: string): void;
-    primitive(value: unknown, fn?: AssertionCallback): void;
-    primitive(value: unknown, opt?: AssertionOpt): void;
-    value(value: unknown, message?: string): void;
-    value(value: unknown, fn?: AssertionCallback): void;
-    value(value: unknown, opt?: AssertionOpt): void;
-    key(value: unknown, message?: string): void;
-    key(value: unknown, fn?: AssertionCallback): void;
-    key(value: unknown, opt?: AssertionOpt): void;
-    object(value: unknown, message?: string): void;
-    object(value: unknown, fn?: AssertionCallback): void;
-    object(value: unknown, opt?: AssertionOpt): void;
-    array(value: unknown, message?: string): void;
-    array(value: unknown, fn?: AssertionCallback): void;
-    array(value: unknown, opt?: AssertionOpt): void;
-    func(value: unknown, message?: string): void;
-    func(value: unknown, fn?: AssertionCallback): void;
-    func(value: unknown, opt?: AssertionOpt): void;
-    number(value: unknown, message?: string): void;
-    number(value: unknown, fn?: AssertionCallback): void;
-    number(value: unknown, opt?: AssertionOpt): void;
-    positiveNumber(value: unknown, message?: string): void;
-    positiveNumber(value: unknown, fn?: AssertionCallback): void;
-    positiveNumber(value: unknown, opt?: AssertionOpt): void;
-    integer(value: unknown, message?: string): void;
-    integer(value: unknown, fn?: AssertionCallback): void;
-    integer(value: unknown, opt?: AssertionOpt): void;
-    positiveInteger(value: unknown, message?: string): void;
-    positiveInteger(value: unknown, fn?: AssertionCallback): void;
-    positiveInteger(value: unknown, opt?: AssertionOpt): void;
-    string(value: unknown, message?: string): void;
-    string(value: unknown, fn?: AssertionCallback): void;
-    string(value: unknown, opt?: AssertionOpt): void;
-    text(value: unknown, message?: string): string;
-    text(value: unknown, fn?: AssertionCallback): string;
-    text(value: unknown, opt?: AssertionOpt): string;
-    clazz(value: unknown, message?: string): void;
-    clazz(value: unknown, fn?: AssertionCallback): void;
-    clazz(value: unknown, opt?: AssertionOpt): void;
-    date(value: unknown, message?: string): void;
-    date(value: unknown, fn?: AssertionCallback): void;
-    date(value: unknown, opt?: AssertionOpt): void;
-    boolean(value: unknown, message?: string): void;
-    boolean(value: unknown, fn?: AssertionCallback): void;
-    boolean(value: unknown, opt?: AssertionOpt): void;
+    /**
+     * Converts ant value secure json value
+     *
+     * Controls:
+     * - circular dependency
+     * - depth control
+     * - handling function and symbol values
+     *
+     * @param {any} value
+     * @returns {any} - it based on generic
+     * */
+    secureJson<E = unknown>(value: any): E;
+    /**
+     * Validates value is real number
+     *
+     * Real number means: !NaN and isFinite
+     *
+     * @param {any} value
+     * @param {ToTypeOpt} opt
+     * @returns {number}
+     * */
+    realNumber(value: number, opt?: ToTypeOpt): number;
+    /**
+     * Asserts value is not empty
+     * @see CommonIs#empty
+     *
+     * @param {any} value
+     * @param {string?} message
+     * */
+    notEmpty(value: any, message?: string): void;
+    /**
+     * Asserts value is not empty
+     * @see CommonIs#empty
+     *
+     * @param {any} value
+     * @param {AssertionCallback?} fn - it should return {@link AssertionOpt}
+     * */
+    notEmpty(value: any, fn?: AssertionCallback): void;
+    /**
+     * Asserts value is not empty
+     * @see CommonIs#empty
+     *
+     * @param {any} value
+     * @param {AssertionOpt?} opt
+     * */
+    notEmpty(value: any, opt?: AssertionOpt): void;
+    /**
+     * Asserts value is a primitive
+     * @see CommonIs#primitive
+     *
+     * @param {any} value
+     * @param {string?} message
+     * */
+    primitive(value: any, message?: string): void;
+    /**
+     * Asserts value is a primitive
+     * @see CommonIs#primitive
+     *
+     * @param {any} value
+     * @param {AssertionCallback?} fn - it should return {@link AssertionOpt}
+     * */
+    primitive(value: any, fn?: AssertionCallback): void;
+    /**
+     * Asserts value is a primitive
+     * @see CommonIs#primitive
+     *
+     * @param {any} value
+     * @param {AssertionOpt?} opt
+     * */
+    primitive(value: any, opt?: AssertionOpt): void;
+    /**
+     * Asserts value is a real value
+     * @see CommonIs#realValue
+     *
+     * @param {any} value
+     * @param {string?} message
+     * */
+    realValue(value: any, message?: string): void;
+    /**
+     * Asserts value is a real value
+     * @see CommonIs#realValue
+     *
+     * @param {any} value
+     * @param {AssertionCallback?} fn - it should return {@link AssertionOpt}
+     * */
+    realValue(value: any, fn?: AssertionCallback): void;
+    /**
+     * Asserts value is a real value
+     * @see CommonIs#realValue
+     *
+     * @param {any} value
+     * @param {AssertionOpt?} opt
+     * */
+    realValue(value: any, opt?: AssertionOpt): void;
+    /**
+     * Asserts value is a key
+     * @see CommonIs#key
+     *
+     * @param {any} value
+     * @param {string?} message
+     * */
+    key(value: any, message?: string): void;
+    /**
+     * Asserts value is a key
+     * @see CommonIs#key
+     *
+     * @param {any} value
+     * @param {AssertionCallback?} fn - it should return {@link AssertionOpt}
+     * */
+    key(value: any, fn?: AssertionCallback): void;
+    /**
+     * Asserts value is a key
+     * @see CommonIs#key
+     *
+     * @param {any} value
+     * @param {AssertionOpt?} opt
+     * */
+    key(value: any, opt?: AssertionOpt): void;
+    /**
+     * Asserts value is an object
+     * @see CommonIs#object
+     *
+     * @param {any} value
+     * @param {string?} message
+     * */
+    object(value: any, message?: string): void;
+    /**
+     * Asserts value is an object
+     * @see CommonIs#object
+     *
+     * @param {any} value
+     * @param {AssertionCallback?} fn - it should return {@link AssertionOpt}
+     * */
+    object(value: any, fn?: AssertionCallback): void;
+    /**
+     * Asserts value is an object
+     * @see CommonIs#object
+     *
+     * @param {any} value
+     * @param {AssertionOpt?} opt
+     * */
+    object(value: any, opt?: AssertionOpt): void;
+    /**
+     * Asserts value is an array
+     * @see CommonIs#empty
+     *
+     * @param {any} value
+     * @param {string?} message
+     * */
+    array(value: any, message?: string): void;
+    /**
+     * Asserts value is an array
+     * @see CommonIs#array
+     *
+     * @param {any} value
+     * @param {AssertionCallback?} fn - it should return {@link AssertionOpt}
+     * */
+    array(value: any, fn?: AssertionCallback): void;
+    /**
+     * Asserts value is an array
+     * @see CommonIs#array
+     *
+     * @param {any} value
+     * @param {AssertionOpt?} opt
+     * */
+    array(value: any, opt?: AssertionOpt): void;
+    /**
+     * Asserts value is a function
+     * @see CommonIs#func
+     *
+     * @param {any} value
+     * @param {string?} message
+     * */
+    func(value: any, message?: string): void;
+    /**
+     * Asserts value is a function
+     * @see CommonIs#func
+     *
+     * @param {any} value
+     * @param {AssertionCallback?} fn - it should return {@link AssertionOpt}
+     * */
+    func(value: any, fn?: AssertionCallback): void;
+    /**
+     * Asserts value is a function
+     * @see CommonIs#func
+     *
+     * @param {any} value
+     * @param {AssertionOpt?} opt
+     * */
+    func(value: any, opt?: AssertionOpt): void;
+    /**
+     * Asserts value is a number
+     * @see CommonIs#number
+     *
+     * @param {any} value
+     * @param {string?} message
+     * */
+    number(value: any, message?: string): void;
+    /**
+     * Asserts value is a number
+     * @see CommonIs#number
+     *
+     * @param {any} value
+     * @param {AssertionCallback?} fn - it should return {@link AssertionOpt}
+     * */
+    number(value: any, fn?: AssertionCallback): void;
+    /**
+     * Asserts value is a number
+     * @see CommonIs#number
+     *
+     * @param {any} value
+     * @param {AssertionOpt?} opt
+     * */
+    number(value: any, opt?: AssertionOpt): void;
+    /**
+     * Asserts value is a positive number
+     * @see CommonIs#number
+     *
+     * @param {any} value
+     * @param {string?} message
+     * */
+    positiveNumber(value: any, message?: string): void;
+    /**
+     * Asserts value is a positive number
+     * @see CommonIs#number
+     *
+     * @param {any} value
+     * @param {AssertionCallback?} fn - it should return {@link AssertionOpt}
+     * */
+    positiveNumber(value: any, fn?: AssertionCallback): void;
+    /**
+     * Asserts value is a positive number
+     * @see CommonIs#number
+     *
+     * @param {any} value
+     * @param {AssertionOpt?} opt
+     * */
+    positiveNumber(value: any, opt?: AssertionOpt): void;
+    /**
+     * Asserts value is an integer
+     * @see CommonIs#integer
+     *
+     * @param {any} value
+     * @param {string?} message
+     * */
+    integer(value: any, message?: string): void;
+    /**
+     * Asserts value is an integer
+     * @see CommonIs#integer
+     *
+     * @param {any} value
+     * @param {AssertionCallback?} fn - it should return {@link AssertionOpt}
+     * */
+    integer(value: any, fn?: AssertionCallback): void;
+    /**
+     * Asserts value is an integer
+     * @see CommonIs#integer
+     *
+     * @param {any} value
+     * @param {AssertionOpt?} opt
+     * */
+    integer(value: any, opt?: AssertionOpt): void;
+    /**
+     * Asserts value is a safe integer
+     * @see CommonIs#safeInteger
+     *
+     * @param {any} value
+     * @param {string?} message
+     * */
+    safeInteger(value: any, message?: string): void;
+    /**
+     * Asserts value is a safe integer
+     * @see CommonIs#safeInteger
+     *
+     * @param {any} value
+     * @param {AssertionCallback?} fn - it should return {@link AssertionOpt}
+     * */
+    safeInteger(value: any, fn?: AssertionCallback): void;
+    /**
+     * Asserts value is a safe integer
+     * @see CommonIs#safeInteger
+     *
+     * @param {any} value
+     * @param {AssertionOpt?} opt
+     * */
+    safeInteger(value: any, opt?: AssertionOpt): void;
+    /**
+     * Asserts value is a positive integer
+     * @see CommonIs#integer
+     *
+     * @param {any} value
+     * @param {string?} message
+     * */
+    positiveInteger(value: any, message?: string): void;
+    /**
+     * Asserts value is a positive integer
+     * @see CommonIs#integer
+     *
+     * @param {any} value
+     * @param {AssertionCallback?} fn - it should return {@link AssertionOpt}
+     * */
+    positiveInteger(value: any, fn?: AssertionCallback): void;
+    /**
+     * Asserts value is a positive integer
+     * @see CommonIs#integer
+     *
+     * @param {any} value
+     * @param {AssertionOpt?} opt
+     * */
+    positiveInteger(value: any, opt?: AssertionOpt): void;
+    /**
+     * Asserts value is a string
+     * @see CommonIs#string
+     *
+     * @param {any} value
+     * @param {string?} message
+     * */
+    string(value: any, message?: string): void;
+    /**
+     * Asserts value is a string
+     * @see CommonIs#string
+     *
+     * @param {any} value
+     * @param {AssertionCallback?} fn - it should return {@link AssertionOpt}
+     * */
+    string(value: any, fn?: AssertionCallback): void;
+    /**
+     * Asserts value is a string
+     * @see CommonIs#string
+     *
+     * @param {any} value
+     * @param {AssertionOpt?} opt
+     * */
+    string(value: any, opt?: AssertionOpt): void;
+    /**
+     * Asserts value is a text
+     * @see CommonIs#text
+     *
+     * @param {any} value
+     * @param {string?} message
+     * */
+    text(value: any, message?: string): string;
+    /**
+     * Asserts value is a text
+     * @see CommonIs#text
+     *
+     * @param {any} value
+     * @param {AssertionCallback?} fn - it should return {@link AssertionOpt}
+     * */
+    text(value: any, fn?: AssertionCallback): string;
+    /**
+     * Asserts value is a text
+     * @see CommonIs#text
+     *
+     * @param {any} value
+     * @param {AssertionOpt?} opt
+     * */
+    text(value: any, opt?: AssertionOpt): string;
+    /**
+     * Asserts value is a possible class
+     * @see CommonIs#clazz
+     *
+     * @param {any} value
+     * @param {string?} message
+     * */
+    clazz(value: any, message?: string): void;
+    /**
+     * Asserts value is a possible class
+     * @see CommonIs#clazz
+     *
+     * @param {any} value
+     * @param {AssertionCallback?} fn - it should return {@link AssertionOpt}
+     * */
+    clazz(value: any, fn?: AssertionCallback): void;
+    /**
+     * Asserts value is a possible class
+     * @see CommonIs#clazz
+     *
+     * @param {any} value
+     * @param {AssertionOpt?} opt
+     * */
+    clazz(value: any, opt?: AssertionOpt): void;
+    /**
+     * Asserts value is a date
+     *
+     * @param {any} value
+     * @param {string?} message
+     * */
+    date(value: any, message?: string): void;
+    /**
+     * Asserts value is a date
+     *
+     * @param {any} value
+     * @param {AssertionCallback?} fn - it should return {@link AssertionOpt}
+     * */
+    date(value: any, fn?: AssertionCallback): void;
+    /**
+     * Asserts value is a date
+     *
+     * @param {any} value
+     * @param {AssertionOpt?} opt
+     * */
+    date(value: any, opt?: AssertionOpt): void;
+    /**
+     * Asserts value is a boolean
+     * @see CommonIs#boolean
+     *
+     * @param {any} value
+     * @param {string?} message
+     * */
+    boolean(value: any, message?: string): void;
+    /**
+     * Asserts value is a boolean
+     * @see CommonIs#boolean
+     *
+     * @param {any} value
+     * @param {AssertionCallback?} fn - it should return {@link AssertionOpt}
+     * */
+    boolean(value: any, fn?: AssertionCallback): void;
+    /**
+     * Asserts value is a boolean
+     * @see CommonIs#boolean
+     *
+     * @param {any} value
+     * @param {AssertionOpt?} opt
+     * */
+    boolean(value: any, opt?: AssertionOpt): void;
 }
-export interface CommonAssertionSecure extends ShiftMain<CommonAssertion> {
-    $init(leyyo: Leyyo): void;
-}
-export interface AssertionOpt {
-    indicator?: AssertionReason | string;
-    param?: string;
-    where?: string;
-    value?: any;
-    expected?: OneOrMore<string>;
-    current?: string;
-    type?: string;
-    [k: string]: any;
-}
-type AssertionReason = 'invalid.type' | 'not.found' | 'duplicated' | 'empty';
-export type AssertionCallback = () => string | AssertionOpt;
-export interface AssertionBuiltResult {
-    message?: string;
-    params: AssertionOpt;
-}
-export {};
+/**
+ * Secure assertion methods
+ * */
+export type CommonAssertionSecure = ShiftMain<CommonAssertion> & InitLike;

package/dist/assertion/index.d.ts

@@ -1,3 +1,2 @@
 export * from './index-types';
 export * from './common-assertion-impl';
-export * from './assert';

package/dist/assertion/index.js

@@ -16,4 +16,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./index-types"), exports);
 __exportStar(require("./common-assertion-impl"), exports);
-__exportStar(require("./assert"), exports);

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

@@ -1,17 +1,19 @@
-import { CommonError, CommonErrorSecure, ExceptionLike } from "./index-types";
+import { CommonError, CommonErrorSecure } from "./index-types";
 import { Leyyo } from "../leyyo";
-import { Dict } from "../aliases";
-import { Exception } from "./exception";
+import { Dict } from "../shared";
+import { ExceptionLike } from "../exception";
 export declare class CommonErrorImpl implements CommonError, CommonErrorSecure {
+    private hook;
     get $back(): CommonError;
     $init(leyyo: Leyyo): void;
     get $secure(): CommonErrorSecure;
     addOmit(clz: Function, ...properties: Array<string>): boolean;
     addSign(err: Error, ...keys: Array<string>): boolean;
     afterCreate(e: ExceptionLike): void;
+    register(cls: Function): void;
     build(e: Error | string): ExceptionLike;
     buildStack(e: Error): void;
-    copyStack(exception: Exception, error: Error): void;
+    copyStack(exception: ExceptionLike, error: Error): void;
     causedBy(e: Error | string): ExceptionLike;
     getOmit(clz: Function): Array<string>;
     getSign(err: Error): Array<string>;

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

@@ -1,14 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommonErrorImpl = void 0;
-const exception_1 = require("./exception");
-const constants_1 = require("../constants");
+const shared_1 = require("../shared");
+const exception_1 = require("../exception");
 // noinspection JSUnusedLocalSymbols
 class CommonErrorImpl {
     get $back() {
         return this;
     }
     $init(leyyo) {
+        this.hook = leyyo.hook;
         const fields = ['build', 'afterCreate', 'causedBy', 'toObject', 'buildStack', 'copyStack',
             'initSign', 'addSign', 'getSign', 'removeSign', 'hasSign',
             'initOmit', 'addOmit', 'getOmit', 'inheritOmit'];
@@ -17,9 +18,9 @@ class CommonErrorImpl {
             rec[field] = this[field];
         });
         // define itself temporarily for error operations
-        leyyo.callback.defineProvider(constants_1.LY_ATTACHED_ERROR, CommonErrorImpl, rec);
+        this.hook.defineProvider(shared_1.LY_ATTACHED_ERROR, CommonErrorImpl, rec);
         // when new error provider is defined, replace all common methods
-        leyyo.callback.whenProviderDefined(constants_1.LY_ATTACHED_ERROR, CommonErrorImpl, (ins) => {
+        this.hook.whenProviderDefined(shared_1.LY_ATTACHED_ERROR, CommonErrorImpl, (ins) => {
             fields.forEach(field => {
                 if (typeof ins[field] === 'function') {
                     this[field] = ins[field];
@@ -39,6 +40,9 @@ class CommonErrorImpl {
     afterCreate(e) {
         e.$secure.$setName(e.constructor.name);
     }
+    register(cls) {
+        this.hook.queueForCallback(shared_1.LY_PENDING_ERROR_REGISTER, cls);
+    }
     build(e) {
         if (e instanceof exception_1.Exception) {
             return e;