@litert/typeguard 1.0.0 → 1.2.0

package/src/lib/Context.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright 2019 Angus.Fenying <fenying@litert.org>
+ * Copyright 2022 Angus Fenying <fenying@litert.org>
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import * as i from "./Internal";
+import * as i from './Internal';
 
 export class Context implements i.IContext {
 
@@ -80,7 +80,7 @@ export class Context implements i.IContext {
 
         if (!prev) {
 
-            throw new Error("Failed to pop stack.");
+            throw new Error('Failed to pop stack.');
         }
 
         this.vName = prev.vName;

package/src/lib/FilterCompiler.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright 2019 Angus.Fenying <fenying@litert.org>
+ * Copyright 2022 Angus Fenying <fenying@litert.org>
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,143 +14,143 @@
  * limitations under the License.
  */
 
-import * as C from "./Common";
-import * as I from "./Internal";
+import * as C from './Common';
+import * as I from './Internal';
 
 export class FilterCompiler
 implements I.IFilterCompiler {
 
     public constructor(
-        private _lang: C.ILanguageBuilder,
-        private _bitc: I.IBuiltInTypeCompiler
+        private readonly _lang: C.ILanguageBuilder,
+        private readonly _bitc: I.IBuiltInTypeCompiler
     ) {}
 
     public compile(rule: string, ctx: I.IContext): string {
 
         let vName = ctx.vName;
 
-        const filter = rule.slice(1).split(" ");
+        const filter = rule.slice(1).split(' ');
 
         if (filter.slice(2).length !== filter.slice(2).filter((x) => /^\d+(\.\d+)?$/.test(x)).length) {
 
-            throw new TypeError("Only number is allowed as filter arguments.");
+            throw new TypeError('Only number is allowed as filter arguments.');
         }
 
-        let ret: string[] = [];
+        const ret: string[] = [];
 
         switch (filter[0]) {
-        case "array.length":
-            ret.push(this._lang.isArray(vName, true));
-            vName = this._lang.arrayLength(vName);
-            break;
-        case "string.length":
-            ret.push(this._lang.isString(vName, true));
-            vName = this._lang.stringLength(vName);
-            break;
-        case "value":
-            ret.push(this._lang.isNumber(vName, true));
-            break;
-        default:
-            ret.push(this._bitc.compile(filter[0], ctx, []));
-            break;
+            case 'array.length':
+                ret.push(this._lang.isArray(vName, true));
+                vName = this._lang.arrayLength(vName);
+                break;
+            case 'string.length':
+                ret.push(this._lang.isString(vName, true));
+                vName = this._lang.stringLength(vName);
+                break;
+            case 'value':
+                ret.push(this._lang.isNumber(vName, true));
+                break;
+            default:
+                ret.push(this._bitc.compile(filter[0], ctx, []));
+                break;
         }
 
         switch (filter[1]) {
-        case "between":
+            case 'between':
 
-            if (filter.length !== 4) {
-                throw new TypeError(`Filter ${filter[1]} require 2 arguments.`);
-            }
+                if (filter.length !== 4) {
+                    throw new TypeError(`Filter ${filter[1]} require 2 arguments.`);
+                }
 
-            ret.push(this._lang.gte(vName, filter[2]));
-            ret.push(this._lang.lte(vName, filter[3]));
+                ret.push(this._lang.gte(vName, filter[2]));
+                ret.push(this._lang.lte(vName, filter[3]));
 
-            break;
+                break;
 
-        case "gt":
-        case ">":
+            case 'gt':
+            case '>':
 
-            if (filter.length !== 3) {
-                throw new TypeError(`Filter ${filter[1]} require 1 argument.`);
-            }
+                if (filter.length !== 3) {
+                    throw new TypeError(`Filter ${filter[1]} require 1 argument.`);
+                }
 
-            ret.push(this._lang.gt(vName, filter[2]));
+                ret.push(this._lang.gt(vName, filter[2]));
 
-            break;
+                break;
 
-        case "ge":
-        case "gte":
-        case ">=":
+            case 'ge':
+            case 'gte':
+            case '>=':
 
-            if (filter.length !== 3) {
-                throw new TypeError(`Filter ${filter[1]} require 1 argument.`);
-            }
+                if (filter.length !== 3) {
+                    throw new TypeError(`Filter ${filter[1]} require 1 argument.`);
+                }
 
-            ret.push(this._lang.gte(vName, filter[2]));
+                ret.push(this._lang.gte(vName, filter[2]));
 
-            break;
+                break;
 
-        case "lt":
-        case "<":
+            case 'lt':
+            case '<':
 
-            if (filter.length !== 3) {
-                throw new TypeError(`Filter ${filter[1]} require 1 argument.`);
-            }
+                if (filter.length !== 3) {
+                    throw new TypeError(`Filter ${filter[1]} require 1 argument.`);
+                }
 
-            ret.push(this._lang.lt(vName, filter[2]));
+                ret.push(this._lang.lt(vName, filter[2]));
 
-            break;
+                break;
 
-        case "le":
-        case "lte":
-        case "<=":
+            case 'le':
+            case 'lte':
+            case '<=':
 
-            if (filter.length !== 3) {
-                throw new TypeError(`Filter ${filter[1]} require 1 argument.`);
-            }
+                if (filter.length !== 3) {
+                    throw new TypeError(`Filter ${filter[1]} require 1 argument.`);
+                }
 
-            ret.push(this._lang.lte(vName, filter[2]));
+                ret.push(this._lang.lte(vName, filter[2]));
 
-            break;
+                break;
 
-        case "eq":
-        case "==":
+            case 'eq':
+            case '==':
 
-            if (filter.length !== 3) {
-                throw new TypeError(`Filter ${filter[1]} require 1 argument.`);
-            }
+                if (filter.length !== 3) {
+                    throw new TypeError(`Filter ${filter[1]} require 1 argument.`);
+                }
 
-            ret.push(this._lang.eq(vName, filter[2]));
+                ret.push(this._lang.eq(vName, filter[2]));
 
-            break;
+                break;
 
-        case "ne":
-        case "!=":
+            case 'ne':
+            case '!=':
 
-            if (filter.length !== 3) {
-                throw new TypeError(`Filter ${filter[1]} require 1 argument.`);
-            }
+                if (filter.length !== 3) {
+                    throw new TypeError(`Filter ${filter[1]} require 1 argument.`);
+                }
 
-            ret.push(this._lang.ne(vName, filter[2]));
+                ret.push(this._lang.ne(vName, filter[2]));
 
-            break;
+                break;
 
-        case "timesof":
+            case 'timesof':
 
-            if (filter.length !== 3) {
-                throw new TypeError(`Filter ${filter[1]} require 1 argument.`);
-            }
+                if (filter.length !== 3) {
+                    throw new TypeError(`Filter ${filter[1]} require 1 argument.`);
+                }
 
-            ret.push(this._lang.eq(
-                this._lang.modOf(vName, filter[2]),
-                "0"
-            ));
+                ret.push(this._lang.eq(
+                    this._lang.modOf(vName, filter[2]),
+                    '0'
+                ));
 
-            break;
+                break;
 
-        default:
+            default:
 
-            throw new TypeError(`Unknown filter type "${filter[1]}".`);
+                throw new TypeError(`Unknown filter type "${filter[1]}".`);
         }
 
         return this._lang.and(ret);

package/src/lib/InlineCompiler.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright 2019 Angus.Fenying <fenying@litert.org>
+ * Copyright 2022 Angus Fenying <fenying@litert.org>
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,16 +14,17 @@
  * limitations under the License.
  */
 
-import { createCompiler } from "./Compiler";
-import { createJavaScriptLanguageBuilder } from "./langs/JavaScript";
-import * as C from "./Common";
+import { createCompiler } from './Compiler';
+import { createJavaScriptLanguageBuilder } from './langs/JavaScript';
+import * as C from './Common';
+import * as I from './Internal';
 
 export interface IInlineCompileOptions extends C.ICompileOptions {
 
     /**
      * Added `debugger` statement before executing checking code.
      */
-    "stopOnEntry"?: boolean;
+    'stopOnEntry'?: boolean;
 }
 
 export interface IInlineCompiler {
@@ -34,14 +35,22 @@ export interface IInlineCompiler {
      *
      * @param options The options of compilation.
      */
-    compile<T>(options: IInlineCompileOptions): C.TypeChecker<T>;
+    compile<T>(options: IInlineCompileOptions): C.ITypeChecker<T>;
 
     /**
      * Get the type-checker of a pre-defined type.
      *
      * @param name The name of the pre-defined type.
      */
-    getPredefinedType<T>(name: string): C.TypeChecker<T>;
+    getPredefinedType<T>(name: string): C.ITypeChecker<T>;
+
+    /**
+     * Register a pre-defined type checker.
+     *
+     * @param name      The name of the pre-defined type (without prefix `@`)
+     * @param checker   The checker callback of the pre-defined type.
+     */
+    addPredefinedType<T>(name: string, checker: C.ITypeChecker<T>): this;
 
     /**
      * Check if a pre-defined type is compiled.
@@ -59,11 +68,11 @@ export interface IInlineCompiler {
 class InlineCompiler
 implements IInlineCompiler {
 
-    private _defTypes: Record<string, C.TypeChecker<any>>;
+    private _defTypes: Record<string, C.ITypeChecker<any>>;
 
     private _missingTypes: Record<string, boolean>;
 
-    private _compiler: C.ICompiler;
+    private readonly _compiler: C.ICompiler;
 
     public constructor() {
 
@@ -78,7 +87,7 @@ implements IInlineCompiler {
         );
     }
 
-    public compile<T>(options: IInlineCompileOptions): C.TypeChecker<T> {
+    public compile<T>(options: IInlineCompileOptions): C.ITypeChecker<T> {
 
         const result = this._compiler.compile(options);
 
@@ -92,7 +101,7 @@ implements IInlineCompiler {
         stopOnEntry?: boolean
     ): void {
 
-        for (let x of types) {
+        for (const x of types) {
 
             if (this._defTypes[x]) {
 
@@ -115,6 +124,18 @@ implements IInlineCompiler {
         }
     }
 
+    public addPredefinedType(name: string, checker: C.ITypeChecker<any>): this {
+
+        if (!I.RE_VALID_CUSTOM_TYPE_NAME.test(name)) {
+
+            throw new TypeError(`Invalid name ${ JSON.stringify(name) } for a pre-defined type.`);
+        }
+
+        this._defTypes[name] = checker;
+
+        return this;
+    }
+
     public detectUndefinedTypes(): string[] {
 
         return Object.keys(this._missingTypes);
@@ -125,7 +146,7 @@ implements IInlineCompiler {
         return !!this._defTypes[name];
     }
 
-    public getPredefinedType(name: string): C.TypeChecker<any> {
+    public getPredefinedType(name: string): C.ITypeChecker<any> {
 
         if (!this._defTypes[name]) {
 
@@ -138,9 +159,9 @@ implements IInlineCompiler {
     private _wrapCheckerCode(
         info: C.ICompileResult,
         stopOnEntry: boolean = false
-    ): C.TypeChecker<any> {
+    ): C.ITypeChecker<any> {
 
-        const soe = stopOnEntry ? "debugger;" : "";
+        const soe = stopOnEntry ? 'debugger;' : '';
 
         return (new Function(
             info.typeSlotName,

package/src/lib/Internal.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright 2019 Angus.Fenying <fenying@litert.org>
+ * Copyright 2022 Angus Fenying <fenying@litert.org>
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,19 +14,19 @@
  * limitations under the License.
  */
 
-export const MAP_SUFFIX = "{}";
+export const MAP_SUFFIX = '{}';
 
-export const LIST_SUFFIX = "[]";
+export const LIST_SUFFIX = '[]';
 
-export const MODIFIER_PREFIX = "$.";
+export const MODIFIER_PREFIX = '$.';
 
-export const FILTER_PREFIX = "|";
+export const FILTER_PREFIX = '|';
 
-export const IMPLICIT_SYMBOL = "?";
+export const IMPLICIT_SYMBOL = '?';
 
-export const PREDEF_TYPE_SYMBOL = "@";
+export const PREDEF_TYPE_SYMBOL = '@';
 
-export const NEGATIVE_SYMBOL = "!";
+export const NEGATIVE_SYMBOL = '!';
 
 export const KEY_MAP_SUFFIX = `->${MAP_SUFFIX}`;
 
@@ -34,9 +34,9 @@ export const KEY_LIST_SUFFIX = `->${LIST_SUFFIX}`;
 
 export const KEY_ARRAY_SUFFIX = /->\[\s*(\d+)(\s*,\s*(\d+)?)?\s*\]$/;
 
-export const KEY_STRICT_SUFFIX = "->()";
+export const KEY_STRICT_SUFFIX = '->()';
 
-export const KEY_EQUAL_SUFFIX = "->(=)";
+export const KEY_EQUAL_SUFFIX = '->(=)';
 
 export enum EFlags {
 
@@ -123,3 +123,5 @@ export interface IBuiltInTypeCompiler {
 
     isElemental(type: string): boolean;
 }
+
+export const RE_VALID_CUSTOM_TYPE_NAME = /^[-:.\w]+$/;

package/src/lib/Modifiers.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright 2019 Angus.Fenying <fenying@litert.org>
+ * Copyright 2022 Angus Fenying <fenying@litert.org>
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import * as I from "./Internal";
+import * as I from './Internal';
 
 export const PREFIX: string = I.MODIFIER_PREFIX;
 

package/src/lib/index.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright 2019 Angus.Fenying <fenying@litert.org>
+ * Copyright 2022 Angus Fenying <fenying@litert.org>
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-export * from "./InlineCompiler";
-export * from "./langs/JavaScript";
-export * from "./Compiler";
-export * from "./Common";
+export * from './InlineCompiler';
+export * from './langs/JavaScript';
+export * from './Compiler';
+export * from './Common';

package/src/lib/langs/JavaScript.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright 2019 Angus.Fenying <fenying@litert.org>
+ * Copyright 2022 Angus Fenying <fenying@litert.org>
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,19 +14,19 @@
  * limitations under the License.
  */
 
-import * as C from "../Common";
+import * as C from '../Common';
 
 class JavaScriptLanguage
 implements C.ILanguageBuilder {
 
     public switchCase(expr: string, cases: string[]): string {
 
-        return `switch (${expr}) { ${cases.join("")} }`;
+        return `switch (${expr}) { ${cases.join('')} }`;
     }
 
     public caseIf(cond: string[], expr: string): string {
 
-        return `${cond.map((x) => `case ${x}:`).join(" ")} { ${expr} break; }`;
+        return `${cond.map((x) => `case ${x}:`).join(' ')} { ${expr} break; }`;
     }
 
     public caseDefault(expr: string): string {
@@ -61,7 +61,7 @@ implements C.ILanguageBuilder {
 
     public call(fnName: string, ...args: string[]): string {
 
-        return `${fnName}(${args.join(",")})`;
+        return `${fnName}(${args.join(',')})`;
     }
 
     public startsWith(
@@ -105,14 +105,19 @@ implements C.ILanguageBuilder {
             return conditions[0];
         }
 
-        conditions = this._dereplicate(conditions.filter((x) => x !== "true"));
+        if (conditions.includes('true')) {
+
+            return 'true';
+        }
+
+        conditions = this._dereplicate(conditions.filter((x) => x !== 'false'));
 
         if (!conditions.length) {
 
-            return "true";
+            return 'true';
         }
 
-        return `${conditions.map((x) => `(${x})`).join(" || ")}`;
+        return `${conditions.map((x) => `(${x})`).join(' || ')}`;
     }
 
     public and(conditions: string[]): string {
@@ -122,14 +127,19 @@ implements C.ILanguageBuilder {
             return conditions[0];
         }
 
-        conditions = this._dereplicate(conditions.filter((x) => x !== "true"));
+        if (conditions.includes('false')) {
+
+            return 'false';
+        }
+
+        conditions = this._dereplicate(conditions.filter((x) => x !== 'true'));
 
         if (!conditions.length) {
 
-            return "true";
+            return 'true';
         }
 
-        return `${conditions.map((x) => `(${x})`).join(" && ")}`;
+        return `${conditions.map((x) => `(${x})`).join(' && ')}`;
     }
 
     public eq(a: string, b: string | number): string {
@@ -182,11 +192,11 @@ implements C.ILanguageBuilder {
         regExp: string
     ): string {
 
-        let m = regExp.match(/^\/(.+)\/([a-z]*)$/i);
+        const m = /^\/(.+)\/([a-z]*)$/i.exec(regExp);
 
         if (m) {
 
-            return `/${m[1]}/${m[2] || ""}.test(${expr})`;
+            return `/${m[1]}/${m[2] || ''}.test(${expr})`;
         }
 
         return `/${regExp}/.test(${expr})`;
@@ -204,12 +214,12 @@ implements C.ILanguageBuilder {
 
     private _equal(positive: boolean = true): string {
 
-        return positive ? "===" : "!==";
+        return positive ? '===' : '!==';
     }
 
     private _not(positive: boolean = true): string {
 
-        return positive ? "" : "!";
+        return positive ? '' : '!';
     }
 
     public isString(vn: string, positive: boolean = true): string {
@@ -242,13 +252,13 @@ implements C.ILanguageBuilder {
             this.isNumber(vn, true),
             this.and([
                 this.isString(vn, true),
-                this.matchRegExp(vn, "^[+-]?\\d+(\\.\\d+)?$")
+                this.matchRegExp(vn, '^[+-]?\\d+(\\.\\d+)?$')
             ])
         ]) : this.and([
             this.isNumber(vn, false),
             this.or([
                 this.isString(vn, false),
-                this.not(this.matchRegExp(vn, "^[+-]?\\d+(\\.\\d+)?$"))
+                this.not(this.matchRegExp(vn, '^[+-]?\\d+(\\.\\d+)?$'))
             ])
         ]);
     }
@@ -291,7 +301,7 @@ implements C.ILanguageBuilder {
 
     public series(statements: string[]): string {
 
-        return statements.map((s) => s.endsWith(";") ? s : `${s};`).join("");
+        return statements.map((s) => s.endsWith(';') ? s : `${s};`).join('');
     }
 
     public ifThen(
@@ -369,22 +379,22 @@ implements C.ILanguageBuilder {
 
     public get literalFalse(): string {
 
-        return `false`;
+        return 'false';
     }
 
     public get literalTrue(): string {
 
-        return `true`;
+        return 'true';
     }
 
     public get maxSafeInteger(): string {
 
-        return "0X1FFFFFFFFFFFFF";
+        return '0X1FFFFFFFFFFFFF';
     }
 
     public get minSafeInteger(): string {
 
-        return "-0X1FFFFFFFFFFFFF";
+        return '-0X1FFFFFFFFFFFFF';
     }
 
     public isTrueValue(vn: string): string {
@@ -408,10 +418,10 @@ implements C.ILanguageBuilder {
         body: string
     ): string {
 
-        return `(function(${params.join(", ")}) {
+        return `(function(${params.join(', ')}) {
             ${body}
         })(${
-            args.join(", ")
+            args.join(', ')
         })`;
     }
 }