@leyyo/common 1.0.8 → 1.0.9

package/dist/assertion/common-assertion.js

@@ -2,12 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommonAssertion = void 0;
 const internal_1 = require("../internal");
-const to_1 = require("../to");
 // noinspection JSUnusedGlobalSymbols
 /** @inheritDoc */
 class CommonAssertion {
     // endregion properties
-    constructor() {
+    constructor(lyy) {
+        this.lyy = lyy;
+        // region properties
         this._EMPTY = [null, undefined];
     }
     // region internal
@@ -17,158 +18,640 @@ class CommonAssertion {
         }
         else if (typeof opt === 'function') {
             try {
-                return this._run(opt());
+                const values = opt();
+                if (Array.isArray(values)) {
+                    let [pck, testCase, opt2] = values;
+                    if (!opt2) {
+                        opt2 = {};
+                    }
+                    opt2['message'] = this.lyy.test.code(pck, testCase);
+                    return opt2;
+                }
+                else if (typeof values === 'string') {
+                    return { issue: values };
+                }
+                else {
+                    return (values && values.contructor === Object) ? values : {};
+                }
             }
             catch (e) {
-                const key = `cv[${Date.now()}]`;
+                const now = Date.now();
                 return {
-                    [key]: [e.message, e.name]
+                    message: e.message,
+                    [`e-${now}-name`]: e.name,
                 };
             }
         }
         else {
-            return opt;
+            return ((opt === null || opt === void 0 ? void 0 : opt.contructor) === Object) ? opt : {};
         }
     }
-    // endregion internal
-    // region types
-    /** @inheritDoc */
-    array(value, opt) {
+    _optional(value, fn) {
+        if (this._EMPTY.includes(value)) {
+            return;
+        }
+        fn();
+    }
+    _array(value, opt, issue, fn) {
         if (!Array.isArray(value)) {
-            this.dev.invalid(this._run(opt), { issue: 'invalid.array', value, type: typeof value });
+            throw this.lyy.dev.invalidError(this._run(opt), { issue, reason: 'type', type: typeof value });
+        }
+        const arr = value;
+        if (arr.length < 1) {
+            throw this.lyy.dev.invalidError(this._run(opt), { issue, reason: 'size', size: 0 });
+        }
+        const wrongIndexes = arr.filter(item => !fn(item)).map((_v, index) => index);
+        if (wrongIndexes.length > 0) {
+            throw this.lyy.dev.invalidError(this._run(opt), { issue, reason: 'items', wrongIndexes });
         }
     }
-    /** @inheritDoc */
-    boolean(value, opt) {
-        if (typeof value !== 'boolean') {
-            this.dev.invalid(this._run(opt), { issue: 'invalid.boolean', value, type: typeof value });
+    _is(value, opt, issue, fn, extra) {
+        if (!fn(value)) {
+            throw this.lyy.dev.invalidError(this._run(opt), Object.assign({ issue, value, type: typeof value }, extra));
         }
     }
+    _replaceMethod(method) {
+        if (method.endsWith('?')) {
+            method = method.slice(0, -1) + 'Optional';
+        }
+        else if (method.endsWith('[]')) {
+            method = method.slice(0, -2) + 'Array';
+        }
+        return method;
+    }
+    _execLambda(value, method, opt, isDual, throwable, another) {
+        if (typeof method !== 'string') {
+            if (throwable) {
+                throw this.lyy.dev.invalidError(this._run(opt), { issue: 'invalid.method.name', value: method });
+            }
+            return 'invalid.method.name';
+        }
+        method = this._replaceMethod(method);
+        const fn = this[method];
+        if (typeof fn !== 'function') {
+            if (throwable) {
+                throw this.lyy.dev.invalidError(this._run(opt), { issue: 'unknown.assertion.method', value: method });
+            }
+            return 'unknown.assertion.method';
+        }
+        try {
+            if (isDual) {
+                fn(value, another, opt);
+            }
+            else {
+                fn(value, opt);
+            }
+        }
+        catch (e) {
+            if (throwable) {
+                throw e;
+            }
+            return e.message;
+        }
+        return undefined;
+    }
+    _isTupleReason(value, setting) {
+        if (!Array.isArray(setting)) {
+            return 'invalid.tuple.setting';
+        }
+        if (!Array.isArray(value)) {
+            return 'tuple.should.be.array';
+        }
+        const arr = value;
+        if (arr.length < 1) {
+            return 'tuple.empty.array';
+        }
+        if (arr.length !== setting.length) {
+            return 'tuple.size.conflict';
+        }
+        let index = -1;
+        for (const set of setting) {
+            index++;
+            let method;
+            let another;
+            let isDual;
+            if (Array.isArray(set)) {
+                if (set[0] === 'or') {
+                    const orCase = set;
+                    if (!this._isOrCase(arr[index], orCase[1])) {
+                        return 'invalid-or-case';
+                    }
+                    break;
+                }
+                const dualCase = set;
+                method = dualCase[0];
+                another = dualCase[1];
+                isDual = true;
+                if (another === undefined) {
+                    return 'invalid.tuple.setting';
+                }
+            }
+            else if (typeof set === 'string') {
+                method = set;
+            }
+            const issue = this._execLambda(arr[index], method, {}, isDual, false, another);
+            if (issue) {
+                return issue;
+            }
+        }
+        return undefined;
+    }
+    _isTuple(value, setting) {
+        return !this._isTupleReason(value, setting);
+    }
+    _isOrCase(value, types) {
+        for (const type of types) {
+            let method;
+            let another;
+            let isDual;
+            if (typeof type === 'string') {
+                method = type;
+            }
+            else if (Array.isArray(type) && type.length === 2) {
+                method = type[0];
+                another = type[1];
+                isDual = true;
+            }
+            const issue = this._execLambda(value, method, {}, isDual, false, another);
+            if (!issue) {
+                return true;
+            }
+        }
+        return false;
+    }
+    // endregion internal
+    // region general
     /** @inheritDoc */
-    clazz(value, opt) {
-        switch (typeof value) {
-            case "function":
-                return;
-            case "object":
-                if (!value) {
-                    return;
+    notEmpty(value, opt) {
+        if (this._EMPTY.includes(value)) {
+            throw this.lyy.dev.invalidError(this._run(opt), { issue: 'empty', value, type: typeof value });
+        }
+        return value;
+    }
+    // endregion general
+    // region or
+    orCase(value, types, opt) {
+        let firstError;
+        for (const type of types) {
+            let method;
+            let another;
+            let isDual;
+            let errorOccurred;
+            if (Array.isArray(type)) {
+                const dualCase = type;
+                method = dualCase[0];
+                another = dualCase[1];
+                isDual = true;
+                if (another === undefined) {
+                    if (!firstError) {
+                        firstError = this.lyy.dev.invalidError(this._run(opt), { issue: 'invalid.tuple.setting', value: method });
+                    }
+                    errorOccurred = true;
                 }
-                break;
-            case "string":
-                if (value.trim() !== '') {
+            }
+            else if (typeof type === 'string') {
+                method = type;
+            }
+            if (!errorOccurred) {
+                const issue = this._execLambda(value, method, opt, isDual, false, another);
+                if (!issue) {
                     return;
                 }
-                break;
+                if (!firstError) {
+                    firstError = this.lyy.dev.invalidError(this._run(opt), { issue, value: method });
+                }
+            }
+        }
+        if (firstError) {
+            throw firstError;
         }
-        this.dev.invalid(this._run(opt), { issue: 'invalid.class', value, type: typeof value });
     }
     /** @inheritDoc */
-    date(value, opt) {
-        if (!(value instanceof Date)) {
-            this.dev.invalid(this._run(opt), { issue: 'invalid.date', value, type: typeof value });
-        }
+    orCaseOptional(value, types, opt) {
+        this._optional(value, () => this.orCase(value, types, opt));
     }
     /** @inheritDoc */
-    func(value, opt) {
-        if (typeof value !== 'function') {
-            this.dev.invalid(this._run(opt), { issue: 'invalid.function', value, type: typeof value });
-        }
+    orCaseArray(value, types, opt) {
+        this._array(value, opt, 'invalid.orCase.array', (v) => this._isOrCase(v, types));
     }
+    // endregion or
+    // region realValue
     /** @inheritDoc */
-    sym(value, opt) {
-        if (typeof value !== 'symbol') {
-            this.dev.invalid(this._run(opt), { issue: 'invalid.symbol', value, type: typeof value });
-        }
+    realValue(value, opt) {
+        this._is(value, opt, 'invalid.realValue', v => this.lyy.is.realValue(v), {});
     }
     /** @inheritDoc */
-    integer(value, opt) {
-        if (!Number.isInteger(value)) {
-            this.dev.invalid(this._run(opt), { issue: 'invalid.integer', value, type: typeof value });
+    realValueOptional(value, opt) {
+        this._optional(value, () => this.realValue(value, opt));
+    }
+    /** @inheritDoc */
+    realValueArray(value, opt) {
+        this._array(value, opt, 'invalid.realValue.array', (v) => this.lyy.is.realValue(v));
+    }
+    // endregion realValue
+    // region object
+    /** @inheritDoc */
+    object(value, opt) {
+        this._is(value, opt, 'invalid.object', v => this.lyy.is.object(v), {});
+    }
+    /** @inheritDoc */
+    objectOptional(value, opt) {
+        this._optional(value, () => this.object(value, opt));
+    }
+    objectArray(value, opt) {
+        this._array(value, opt, 'invalid.object.array', (v) => this.lyy.is.object(v));
+    }
+    // endregion object
+    // region bareObject
+    /** @inheritDoc */
+    bareObject(value, opt) {
+        this._is(value, opt, 'invalid.bareObject', v => this.lyy.is.bareObject(v), {});
+    }
+    /** @inheritDoc */
+    bareObjectOptional(value, opt) {
+        this._optional(value, () => this.bareObject(value, opt));
+    }
+    bareObjectArray(value, opt) {
+        this._array(value, opt, 'invalid.bareObject.array', (v) => this.lyy.is.bareObject(v));
+    }
+    // endregion bareObject
+    // region anotherObject
+    /** @inheritDoc */
+    anotherObject(value, opt) {
+        this._is(value, opt, 'invalid.anotherObject', v => this.lyy.is.anotherObject(v), {});
+    }
+    /** @inheritDoc */
+    anotherObjectOptional(value, opt) {
+        this._optional(value, () => this.anotherObject(value, opt));
+    }
+    /** @inheritDoc */
+    anotherObjectArray(value, opt) {
+        this._array(value, opt, 'invalid.anotherObject.array', (v) => this.lyy.is.anotherObject(v));
+    }
+    // endregion anotherObject
+    // region array
+    /** @inheritDoc */
+    array(value, opt) {
+        this._is(value, opt, 'invalid.array', v => Array.isArray(v) && v.length > 0, {});
+    }
+    /** @inheritDoc */
+    arrayOptional(value, opt) {
+        this._optional(value, () => this.array(value, opt));
+    }
+    /** @inheritDoc */
+    arrayArray(value, opt) {
+        this._array(value, opt, 'invalid.array.array', (v) => Array.isArray(v));
+    }
+    // endregion array
+    // region instanceOf
+    /** @inheritDoc */
+    instanceOf(value, clazz, opt) {
+        this._is(value, opt, 'invalid.instanceOf', v => this.lyy.is.instanceOf(v, clazz), { clazz });
+    }
+    /** @inheritDoc */
+    instanceOfOptional(value, clazz, opt) {
+        this._optional(value, () => this.instanceOf(value, clazz, opt));
+    }
+    /** @inheritDoc */
+    instanceOfArray(value, clazz, opt) {
+        this._array(value, opt, 'invalid.instanceOf.array', (v) => this.lyy.is.instanceOf(v, clazz));
+    }
+    // endregion instanceOf
+    // region tuple
+    /** @inheritDoc */
+    tuple(value, setting, opt) {
+        if (!Array.isArray(setting)) {
+            throw this.lyy.dev.invalidError(this._run(opt), {
+                issue: 'invalid.tuple.setting',
+                value: setting,
+                type: typeof setting
+            });
+        }
+        if (!Array.isArray(value)) {
+            throw this.lyy.dev.invalidError(this._run(opt), {
+                issue: 'tuple.should.be.array',
+                value: setting,
+                type: typeof setting
+            });
+        }
+        const arr = value;
+        if (arr.length !== setting.length) {
+            throw this.lyy.dev.invalidError(this._run(opt), {
+                issue: 'tuple.size.conflict',
+                value: arr.length,
+                setting: setting.length
+            });
         }
+        setting.forEach((set, index) => {
+            let method;
+            let another;
+            let isDual;
+            if (Array.isArray(set)) {
+                if (set[0] === 'or') {
+                    const orCase = set;
+                    this.orCase(arr[index], orCase[1], opt);
+                    return;
+                }
+                const dualCase = set;
+                method = dualCase[0];
+                another = dualCase[1];
+                isDual = true;
+                if (another === undefined) {
+                    throw this.lyy.dev.invalidError(this._run(opt), {
+                        issue: 'invalid.tuple.setting',
+                        index,
+                        value: setting,
+                        type: typeof setting
+                    });
+                }
+            }
+            else if (typeof set === 'string') {
+                method = set;
+            }
+            this._execLambda(arr[index], method, opt, isDual, true, another);
+        });
+    }
+    /** @inheritDoc */
+    tupleOptional(value, setting, opt) {
+        this._optional(value, () => this.tuple(value, setting, opt));
+    }
+    /** @inheritDoc */
+    tupleArray(value, setting, opt) {
+        this._array(value, opt, 'invalid.tuple.array', (v) => this._isTuple(v, setting));
+    }
+    // endregion tuple
+    // region primitive
+    /** @inheritDoc */
+    primitive(value, opt) {
+        this._is(value, opt, 'invalid.primitive', v => this.lyy.is.primitive(v), {});
+    }
+    /** @inheritDoc */
+    primitiveOptional(value, opt) {
+        this._optional(value, () => this.primitive(value, opt));
+    }
+    /** @inheritDoc */
+    primitiveArray(value, opt) {
+        this._array(value, opt, 'invalid.primitive.array', (v) => this.lyy.is.primitive(v));
     }
+    // endregion primitive
+    // region key
     /** @inheritDoc */
     key(value, opt) {
-        if (!['string', 'number'].includes(typeof value)) {
-            this.dev.invalid(this._run(opt), { issue: 'invalid.key', value, type: typeof value });
-        }
+        this._is(value, opt, 'invalid.key', v => this.lyy.is.key(v), {});
     }
     /** @inheritDoc */
-    notEmpty(value, opt) {
-        if (this._EMPTY.includes(value)) {
-            this.dev.invalid(this._run(opt), { issue: 'empty', value, type: typeof value });
-        }
+    keyOptional(value, opt) {
+        this._optional(value, () => this.key(value, opt));
+    }
+    /** @inheritDoc */
+    keyArray(value, opt) {
+        this._array(value, opt, 'invalid.key.array', (v) => this.lyy.is.key(v));
+    }
+    // endregion key
+    // region arrayLike
+    /** @inheritDoc */
+    arrayLike(value, opt) {
+        this._is(value, opt, 'invalid.arrayLike', v => this.lyy.is.arrayLike(v), {});
+    }
+    /** @inheritDoc */
+    arrayLikeOptional(value, opt) {
+        this._optional(value, () => this.arrayLike(value, opt));
+    }
+    /** @inheritDoc */
+    arrayLikeArray(value, opt) {
+        this._array(value, opt, 'invalid.arrayLike.array', (v) => this.lyy.is.arrayLike(v));
+    }
+    // endregion arrayLike
+    // region function
+    /** @inheritDoc */
+    func(value, opt) {
+        this._is(value, opt, 'invalid.function', v => this.lyy.is.func(v), {});
+    }
+    /** @inheritDoc */
+    funcOptional(value, opt) {
+        this._optional(value, () => this.func(value, opt));
+    }
+    /** @inheritDoc */
+    funcArray(value, opt) {
+        this._array(value, opt, 'invalid.function.array', (v) => this.lyy.is.func(v));
+    }
+    // endregion function
+    // region symbol
+    /** @inheritDoc */
+    sym(value, opt) {
+        this._is(value, opt, 'invalid.symbol', v => this.lyy.is.sym(v), {});
+    }
+    /** @inheritDoc */
+    symOptional(value, opt) {
+        this._optional(value, () => this.sym(value, opt));
     }
     /** @inheritDoc */
+    symArray(value, opt) {
+        this._array(value, opt, 'invalid.symbol.array', (v) => this.lyy.is.sym(v));
+    }
+    // endregion symbol
+    // region number
+    /** @inheritDoc */
     number(value, opt) {
-        if (typeof value !== 'number') {
-            this.dev.invalid(this._run(opt), { issue: 'invalid.number', value, type: typeof value });
-        }
+        this._is(value, opt, 'invalid.number', v => this.lyy.is.number(v), {});
     }
     /** @inheritDoc */
-    object(value, opt) {
-        if (!value || typeof value !== 'object' && !Array.isArray(value)) {
-            this.dev.invalid(this._run(opt), { issue: 'invalid.object', value, type: typeof value });
-        }
+    numberOptional(value, opt) {
+        this._optional(value, () => this.number(value, opt));
     }
     /** @inheritDoc */
-    bareObject(value, opt) {
-        if (!value || typeof value !== 'object' && value.constructor !== Object) {
-            this.dev.invalid(this._run(opt), { issue: 'invalid.bare.object', value, type: typeof value });
-        }
+    numberArray(value, opt) {
+        this._array(value, opt, 'invalid.number.array', (v) => this.lyy.is.number(v));
     }
+    // endregion number
+    // region positiveNumber
     /** @inheritDoc */
-    positiveInteger(value, opt) {
-        if (!Number.isInteger(value) || (value <= 0)) {
-            this.dev.invalid(this._run(opt), { issue: 'invalid.positive.integer', value, type: typeof value });
-        }
+    positiveNumber(value, opt) {
+        this._is(value, opt, 'invalid.positiveNumber', v => this.lyy.is.positiveNumber(v), {});
+    }
+    /** @inheritDoc */
+    positiveNumberOptional(value, opt) {
+        this._optional(value, () => this.positiveNumber(value, opt));
+    }
+    /** @inheritDoc */
+    positiveNumberArray(value, opt) {
+        this._array(value, opt, 'invalid.positiveNumber.array', (v) => this.lyy.is.positiveNumber(v));
     }
+    // endregion positiveNumber
+    // region nonNegativeNumber
+    /** @inheritDoc */
+    nonNegativeNumber(value, opt) {
+        this._is(value, opt, 'invalid.nonNegativeNumber', v => this.lyy.is.nonNegativeNumber(v), {});
+    }
+    /** @inheritDoc */
+    nonNegativeNumberOptional(value, opt) {
+        this._optional(value, () => this.nonNegativeNumber(value, opt));
+    }
+    /** @inheritDoc */
+    nonNegativeNumberArray(value, opt) {
+        this._array(value, opt, 'invalid.nonNegativeNumber.array', (v) => this.lyy.is.nonNegativeNumber(v));
+    }
+    // endregion nonNegativeNumber
+    // region integer
+    /** @inheritDoc */
+    integer(value, opt) {
+        this._is(value, opt, 'invalid.integer', v => this.lyy.is.integer(v), {});
+    }
+    /** @inheritDoc */
+    integerOptional(value, opt) {
+        this._optional(value, () => this.integer(value, opt));
+    }
+    /** @inheritDoc */
+    integerArray(value, opt) {
+        this._array(value, opt, 'invalid.integer.array', (v) => this.lyy.is.integer(v));
+    }
+    // endregion integer
+    // region safeInteger
     /** @inheritDoc */
     safeInteger(value, opt) {
-        if (!Number.isSafeInteger(value)) {
-            this.dev.invalid(this._run(opt), { issue: 'invalid.safe.integer', value, type: typeof value });
-        }
+        this._is(value, opt, 'invalid.safeInteger', v => this.lyy.is.safeInteger(v), {});
     }
     /** @inheritDoc */
-    positiveNumber(value, opt) {
-        if (typeof value !== 'number' || (value <= 0)) {
-            this.dev.invalid(this._run(opt), { issue: 'invalid.positive', value, type: typeof value });
-        }
+    safeIntegerOptional(value, opt) {
+        this._optional(value, () => this.safeInteger(value, opt));
     }
     /** @inheritDoc */
-    primitive(value, opt) {
-        if (!to_1.PrimitiveItems.includes(typeof value)) {
-            this.dev.invalid(this._run(opt), { issue: 'invalid.primitive', value, type: typeof value });
-        }
+    safeIntegerArray(value, opt) {
+        this._array(value, opt, 'invalid.safeInteger.array', (v) => this.lyy.is.safeInteger(v));
+    }
+    // endregion safeInteger
+    // region positiveInteger
+    /** @inheritDoc */
+    positiveInteger(value, opt) {
+        this._is(value, opt, 'invalid.positiveInteger', v => this.lyy.is.positiveInteger(v), {});
+    }
+    /** @inheritDoc */
+    positiveIntegerOptional(value, opt) {
+        this._optional(value, () => this.positiveInteger(value, opt));
+    }
+    /** @inheritDoc */
+    positiveIntegerArray(value, opt) {
+        this._array(value, opt, 'invalid.positiveInteger.array', (v) => this.lyy.is.positiveInteger(v));
+    }
+    // endregion positiveInteger
+    // region nonNegativeInteger
+    nonNegativeInteger(value, opt) {
+        this._is(value, opt, 'invalid.nonNegativeInteger', v => this.lyy.is.nonNegativeInteger(v), {});
+    }
+    nonNegativeIntegerArray(value, opt) {
+        this._optional(value, () => this.nonNegativeInteger(value, opt));
+    }
+    nonNegativeIntegerOptional(value, opt) {
+        this._array(value, opt, 'invalid.nonNegativeInteger.array', (v) => this.lyy.is.nonNegativeInteger(v));
     }
+    // endregion nonNegativeInteger
+    // region string
     /** @inheritDoc */
     string(value, opt) {
-        if (typeof value !== 'string') {
-            this.dev.invalid(this._run(opt), { issue: 'invalid.string', value, type: typeof value });
-        }
+        this._is(value, opt, 'invalid.string', v => this.lyy.is.string(v), {});
+    }
+    /** @inheritDoc */
+    stringOptional(value, opt) {
+        this._optional(value, () => this.string(value, opt));
     }
     /** @inheritDoc */
+    stringArray(value, opt) {
+        this._array(value, opt, 'invalid.string.array', (v) => this.lyy.is.string(v));
+    }
+    // endregion string
+    // region text
+    /** @inheritDoc */
     text(value, opt) {
-        if (typeof value !== 'string' || value.trim() === '') {
-            this.dev.invalid(this._run(opt), { issue: 'invalid.text', value, type: typeof value });
-        }
+        this._is(value, opt, 'invalid.text', v => this.lyy.is.text(v), {});
     }
     /** @inheritDoc */
-    realValue(value, opt) {
-        if (!to_1.RealValueItems.includes(typeof value)) {
-            this.dev.invalid(this._run(opt), { issue: 'invalid.real.value', value, type: typeof value });
-        }
+    textOptional(value, opt) {
+        this._optional(value, () => this.text(value, opt));
+    }
+    /** @inheritDoc */
+    textArray(value, opt) {
+        this._array(value, opt, 'invalid.text.array', (v) => this.lyy.is.text(v));
+    }
+    // endregion text
+    // region clazz
+    /** @inheritDoc */
+    clazz(value, opt) {
+        this._is(value, opt, 'invalid.class', v => this.lyy.is.clazz(v), {});
+    }
+    /** @inheritDoc */
+    clazzOptional(value, opt) {
+        this._optional(value, () => this.clazz(value, opt));
+    }
+    /** @inheritDoc */
+    clazzArray(value, opt) {
+        this._array(value, opt, 'invalid.clazz.array', (v) => this.lyy.is.clazz(v));
+    }
+    // endregion clazz
+    // region possibleFunc
+    /** @inheritDoc */
+    possibleFunc(value, opt) {
+        this._is(value, opt, 'invalid.possibleFunc', v => this.lyy.is.possibleFunc(v), {});
+    }
+    /** @inheritDoc */
+    possibleFuncOptional(value, opt) {
+        this._optional(value, () => this.possibleFunc(value, opt));
+    }
+    /** @inheritDoc */
+    possibleFuncArray(value, opt) {
+        this._array(value, opt, 'invalid.possibleFunc.array', (v) => this.lyy.is.possibleFunc(v));
+    }
+    // endregion possibleFunc
+    // region boolean
+    /** @inheritDoc */
+    boolean(value, opt) {
+        this._is(value, opt, 'invalid.boolean', v => this.lyy.is.boolean(v), {});
+    }
+    /** @inheritDoc */
+    booleanOptional(value, opt) {
+        this._optional(value, () => this.boolean(value, opt));
+    }
+    /** @inheritDoc */
+    booleanArray(value, opt) {
+        this._array(value, opt, 'invalid.boolean.array', (v) => this.lyy.is.boolean(v));
+    }
+    // endregion boolean
+    // region enum
+    /** @inheritDoc */
+    enum(value, map, opt) {
+        this._is(value, opt, 'invalid.enum', v => this.lyy.is.enumeration(v, map), {});
+    }
+    /** @inheritDoc */
+    enumOptional(value, map, opt) {
+        this._optional(value, () => this.enum(value, map, opt));
+    }
+    /** @inheritDoc */
+    enumArray(value, map, opt) {
+        this._array(value, opt, 'invalid.enum.array', (v) => this.lyy.is.enumeration(v, map));
+    }
+    // endregion enum
+    // region literal
+    /** @inheritDoc */
+    literal(value, items, opt) {
+        this._is(value, opt, 'invalid.literal', v => this.lyy.is.literal(v, items), {});
+    }
+    /** @inheritDoc */
+    literalOptional(value, items, opt) {
+        this._optional(value, () => this.literal(value, items, opt));
+    }
+    /** @inheritDoc */
+    literalArray(value, items, opt) {
+        this._array(value, opt, 'invalid.literal.array', (v) => this.lyy.is.literal(v, items));
     }
-    // endregion types
+    // endregion literal
     // region secure
     /** @inheritDoc */
     get $back() {
         return this;
     }
     /** @inheritDoc */
-    $init(leyyo) {
-        this.dev = leyyo.dev;
-        leyyo.$secure.$lazyRun(() => {
-            leyyo.fqn.register(null, CommonAssertion, 'class', internal_1.FQN_PCK);
+    $init() {
+        this.lyy.$secure.$lazyRun(() => {
+            this.lyy.fqn.register(null, CommonAssertion, 'class', internal_1.FQN);
         });
     }
     /** @inheritDoc */