@litert/typeguard 1.0.1 → 1.3.0-dev.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,22 +14,22 @@
  * limitations under the License.
  */
 
-import * as i from "./Internal";
+import * as i from './Internal';
 
 export class Context implements i.IContext {
 
-    public trace: boolean;
-
-    public tracePoint: number;
-
     public vCursor: number;
 
     public stack: i.IContextData[];
 
     public flags: Record<string, i.EFlagValue>;
 
+    public tracePath: string = '';
+
     public constructor(
         public vName: string,
+        public vTraceName: string,
+        public vTracePrefix: string,
         public readonly typeSlotName: string,
         public readonly referredTypes: Record<string, boolean>
     ) {
@@ -38,17 +38,14 @@ export class Context implements i.IContext {
         this.vCursor = 0;
 
         this.flags = {};
-
-        this.tracePoint = 0;
-
-        this.trace = false;
     }
 
     public trap(subjChanged: boolean = false): void {
 
         this.stack.push({
             vName: this.vName,
-            flags: this.flags
+            flags: this.flags,
+            tracePath: this.tracePath,
         });
 
         const prevFlags = this.flags;
@@ -80,10 +77,11 @@ 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;
         this.flags = prev.flags;
+        this.vName = prev.vName;
+        this.tracePath = prev.tracePath;
     }
 }

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,13 +159,18 @@ 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,
-            `return function(${info.arguments[0].name}) {${soe}
+            `return function(${
+                info.arguments
+                    .map((a) => a.initial ? `${a.name} = ${a.initial}` : a.name)
+                    .join(',')
+            }) {
+                ${soe}
 
                 return ${info.source};
             };`

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 {
 
@@ -72,16 +72,18 @@ export enum EFlagValue {
 
 export interface IContextData {
 
+    flags: Record<string, EFlagValue>;
+
     vName: string;
 
-    flags: Record<string, EFlagValue>;
+    tracePath: string;
 }
 
 export interface IContext extends IContextData {
 
-    trace: boolean;
+    vTraceName: string;
 
-    tracePoint: number;
+    vTracePrefix: string;
 
     vCursor: number;
 
@@ -123,3 +125,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';