ast-types 0.11.5 → 0.12.1

package/lib/scope.js

@@ -1,35 +1,34 @@
+"use strict";;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var types_1 = __importDefault(require("./types"));
 var hasOwn = Object.prototype.hasOwnProperty;
-
-module.exports = function (fork) {
-    var types = fork.use(require("./types"));
+function scopePlugin(fork) {
+    var types = fork.use(types_1.default);
     var Type = types.Type;
     var namedTypes = types.namedTypes;
     var Node = namedTypes.Node;
     var Expression = namedTypes.Expression;
     var isArray = types.builtInTypes.array;
     var b = types.builders;
-
-    function Scope(path, parentScope) {
+    var Scope = function Scope(path, parentScope) {
         if (!(this instanceof Scope)) {
             throw new Error("Scope constructor cannot be invoked without 'new'");
         }
-        if (!(path instanceof fork.use(require("./node-path")))) {
-            throw new Error("");
-        }
         ScopeType.assert(path.value);
-
         var depth;
-
         if (parentScope) {
             if (!(parentScope instanceof Scope)) {
                 throw new Error("");
             }
             depth = parentScope.depth + 1;
-        } else {
+        }
+        else {
             parentScope = null;
             depth = 0;
         }
-
         Object.defineProperties(this, {
             path: { value: path },
             node: { value: path.value },
@@ -39,85 +38,62 @@ module.exports = function (fork) {
             bindings: { value: {} },
             types: { value: {} },
         });
-    }
-
+    };
     var scopeTypes = [
         // Program nodes introduce global scopes.
         namedTypes.Program,
-
         // Function is the supertype of FunctionExpression,
         // FunctionDeclaration, ArrowExpression, etc.
         namedTypes.Function,
-
         // In case you didn't know, the caught parameter shadows any variable
         // of the same name in an outer scope.
         namedTypes.CatchClause
     ];
-
     var ScopeType = Type.or.apply(Type, scopeTypes);
-
-    Scope.isEstablishedBy = function(node) {
+    Scope.isEstablishedBy = function (node) {
         return ScopeType.check(node);
     };
-
     var Sp = Scope.prototype;
-
-// Will be overridden after an instance lazily calls scanScope.
+    // Will be overridden after an instance lazily calls scanScope.
     Sp.didScan = false;
-
-    Sp.declares = function(name) {
+    Sp.declares = function (name) {
         this.scan();
         return hasOwn.call(this.bindings, name);
     };
-
-    Sp.declaresType = function(name) {
+    Sp.declaresType = function (name) {
         this.scan();
         return hasOwn.call(this.types, name);
     };
-
-    Sp.declareTemporary = function(prefix) {
+    Sp.declareTemporary = function (prefix) {
         if (prefix) {
             if (!/^[a-z$_]/i.test(prefix)) {
                 throw new Error("");
             }
-        } else {
+        }
+        else {
             prefix = "t$";
         }
-
         // Include this.depth in the name to make sure the name does not
         // collide with any variables in nested/enclosing scopes.
         prefix += this.depth.toString(36) + "$";
-
         this.scan();
-
         var index = 0;
         while (this.declares(prefix + index)) {
             ++index;
         }
-
         var name = prefix + index;
         return this.bindings[name] = types.builders.identifier(name);
     };
-
-    Sp.injectTemporary = function(identifier, init) {
+    Sp.injectTemporary = function (identifier, init) {
         identifier || (identifier = this.declareTemporary());
-
         var bodyPath = this.path.get("body");
         if (namedTypes.BlockStatement.check(bodyPath.value)) {
             bodyPath = bodyPath.get("body");
         }
-
-        bodyPath.unshift(
-          b.variableDeclaration(
-            "var",
-            [b.variableDeclarator(identifier, init || null)]
-          )
-        );
-
+        bodyPath.unshift(b.variableDeclaration("var", [b.variableDeclarator(identifier, init || null)]));
         return identifier;
     };
-
-    Sp.scan = function(force) {
+    Sp.scan = function (force) {
         if (force || !this.didScan) {
             for (var name in this.bindings) {
                 // Empty out this.bindings, just in cases.
@@ -127,78 +103,68 @@ module.exports = function (fork) {
             this.didScan = true;
         }
     };
-
     Sp.getBindings = function () {
         this.scan();
         return this.bindings;
     };
-
     Sp.getTypes = function () {
         this.scan();
         return this.types;
     };
-
     function scanScope(path, bindings, scopeTypes) {
         var node = path.value;
         ScopeType.assert(node);
-
         if (namedTypes.CatchClause.check(node)) {
             // A catch clause establishes a new scope but the only variable
             // bound in that scope is the catch parameter. Any other
             // declarations create bindings in the outer scope.
             addPattern(path.get("param"), bindings);
-
-        } else {
+        }
+        else {
             recursiveScanScope(path, bindings, scopeTypes);
         }
     }
-
     function recursiveScanScope(path, bindings, scopeTypes) {
         var node = path.value;
-
         if (path.parent &&
-          namedTypes.FunctionExpression.check(path.parent.node) &&
-          path.parent.node.id) {
+            namedTypes.FunctionExpression.check(path.parent.node) &&
+            path.parent.node.id) {
             addPattern(path.parent.get("id"), bindings);
         }
-
         if (!node) {
             // None of the remaining cases matter if node is falsy.
-
-        } else if (isArray.check(node)) {
-            path.each(function(childPath) {
+        }
+        else if (isArray.check(node)) {
+            path.each(function (childPath) {
                 recursiveScanChild(childPath, bindings, scopeTypes);
             });
-
-        } else if (namedTypes.Function.check(node)) {
-            path.get("params").each(function(paramPath) {
+        }
+        else if (namedTypes.Function.check(node)) {
+            path.get("params").each(function (paramPath) {
                 addPattern(paramPath, bindings);
             });
-
             recursiveScanChild(path.get("body"), bindings, scopeTypes);
-
-        } else if (namedTypes.TypeAlias && namedTypes.TypeAlias.check(node)) {
+        }
+        else if (namedTypes.TypeAlias && namedTypes.TypeAlias.check(node)) {
             addTypePattern(path.get("id"), scopeTypes);
-
-        } else if (namedTypes.VariableDeclarator.check(node)) {
+        }
+        else if (namedTypes.VariableDeclarator.check(node)) {
             addPattern(path.get("id"), bindings);
             recursiveScanChild(path.get("init"), bindings, scopeTypes);
-
-        } else if (node.type === "ImportSpecifier" ||
-          node.type === "ImportNamespaceSpecifier" ||
-          node.type === "ImportDefaultSpecifier") {
+        }
+        else if (node.type === "ImportSpecifier" ||
+            node.type === "ImportNamespaceSpecifier" ||
+            node.type === "ImportDefaultSpecifier") {
             addPattern(
-              // Esprima used to use the .name field to refer to the local
-              // binding identifier for ImportSpecifier nodes, but .id for
-              // ImportNamespaceSpecifier and ImportDefaultSpecifier nodes.
-              // ESTree/Acorn/ESpree use .local for all three node types.
-              path.get(node.local ? "local" :
-                node.name ? "name" : "id"),
-              bindings
-            );
-
-        } else if (Node.check(node) && !Expression.check(node)) {
-            types.eachField(node, function(name, child) {
+            // Esprima used to use the .name field to refer to the local
+            // binding identifier for ImportSpecifier nodes, but .id for
+            // ImportNamespaceSpecifier and ImportDefaultSpecifier nodes.
+            // ESTree/Acorn/ESpree use .local for all three node types.
+            path.get(node.local ? "local" :
+                node.name ? "name" : "id"), bindings);
+        }
+        else if (Node.check(node) && !Expression.check(node)) {
+            types.eachField(node, function (name, child) {
                 var childPath = path.get(name);
                 if (!pathHasValue(childPath, child)) {
                     throw new Error("");
@@ -207,48 +173,41 @@ module.exports = function (fork) {
             });
         }
     }
-
     function pathHasValue(path, value) {
         if (path.value === value) {
             return true;
         }
-
         // Empty arrays are probably produced by defaults.emptyArray, in which
         // case is makes sense to regard them as equivalent, if not ===.
         if (Array.isArray(path.value) &&
-          path.value.length === 0 &&
-          Array.isArray(value) &&
-          value.length === 0) {
+            path.value.length === 0 &&
+            Array.isArray(value) &&
+            value.length === 0) {
             return true;
         }
-
         return false;
     }
-
     function recursiveScanChild(path, bindings, scopeTypes) {
         var node = path.value;
-
         if (!node || Expression.check(node)) {
             // Ignore falsy values and Expressions.
-
-        } else if (namedTypes.FunctionDeclaration.check(node) &&
-                   node.id !== null) {
+        }
+        else if (namedTypes.FunctionDeclaration.check(node) &&
+            node.id !== null) {
             addPattern(path.get("id"), bindings);
-
-        } else if (namedTypes.ClassDeclaration &&
-          namedTypes.ClassDeclaration.check(node)) {
+        }
+        else if (namedTypes.ClassDeclaration &&
+            namedTypes.ClassDeclaration.check(node)) {
             addPattern(path.get("id"), bindings);
-
-        } else if (ScopeType.check(node)) {
+        }
+        else if (ScopeType.check(node)) {
             if (namedTypes.CatchClause.check(node)) {
                 var catchParamName = node.param.name;
                 var hadBinding = hasOwn.call(bindings, catchParamName);
-
                 // Any declarations that occur inside the catch body that do
                 // not have the same name as the catch parameter should count
                 // as bindings in the outer scope.
                 recursiveScanScope(path.get("body"), bindings, scopeTypes);
-
                 // If a new binding matching the catch parameter name was
                 // created while scanning the catch body, ignore it because it
                 // actually refers to the catch parameter and not the outer
@@ -257,99 +216,97 @@ module.exports = function (fork) {
                     delete bindings[catchParamName];
                 }
             }
-
-        } else {
+        }
+        else {
             recursiveScanScope(path, bindings, scopeTypes);
         }
     }
-
     function addPattern(patternPath, bindings) {
         var pattern = patternPath.value;
         namedTypes.Pattern.assert(pattern);
-
         if (namedTypes.Identifier.check(pattern)) {
             if (hasOwn.call(bindings, pattern.name)) {
                 bindings[pattern.name].push(patternPath);
-            } else {
+            }
+            else {
                 bindings[pattern.name] = [patternPath];
             }
-
-        } else if (namedTypes.AssignmentPattern &&
-          namedTypes.AssignmentPattern.check(pattern)) {
-          addPattern(patternPath.get('left'), bindings);
-
-        } else if (namedTypes.ObjectPattern &&
-          namedTypes.ObjectPattern.check(pattern)) {
-            patternPath.get('properties').each(function(propertyPath) {
+        }
+        else if (namedTypes.AssignmentPattern &&
+            namedTypes.AssignmentPattern.check(pattern)) {
+            addPattern(patternPath.get('left'), bindings);
+        }
+        else if (namedTypes.ObjectPattern &&
+            namedTypes.ObjectPattern.check(pattern)) {
+            patternPath.get('properties').each(function (propertyPath) {
                 var property = propertyPath.value;
                 if (namedTypes.Pattern.check(property)) {
                     addPattern(propertyPath, bindings);
-                } else  if (namedTypes.Property.check(property)) {
+                }
+                else if (namedTypes.Property.check(property)) {
                     addPattern(propertyPath.get('value'), bindings);
-                } else if (namedTypes.SpreadProperty &&
-                  namedTypes.SpreadProperty.check(property)) {
+                }
+                else if (namedTypes.SpreadProperty &&
+                    namedTypes.SpreadProperty.check(property)) {
                     addPattern(propertyPath.get('argument'), bindings);
                 }
             });
-
-        } else if (namedTypes.ArrayPattern &&
-          namedTypes.ArrayPattern.check(pattern)) {
-            patternPath.get('elements').each(function(elementPath) {
+        }
+        else if (namedTypes.ArrayPattern &&
+            namedTypes.ArrayPattern.check(pattern)) {
+            patternPath.get('elements').each(function (elementPath) {
                 var element = elementPath.value;
                 if (namedTypes.Pattern.check(element)) {
                     addPattern(elementPath, bindings);
-                } else if (namedTypes.SpreadElement &&
-                  namedTypes.SpreadElement.check(element)) {
+                }
+                else if (namedTypes.SpreadElement &&
+                    namedTypes.SpreadElement.check(element)) {
                     addPattern(elementPath.get("argument"), bindings);
                 }
             });
-
-        } else if (namedTypes.PropertyPattern &&
-          namedTypes.PropertyPattern.check(pattern)) {
+        }
+        else if (namedTypes.PropertyPattern &&
+            namedTypes.PropertyPattern.check(pattern)) {
             addPattern(patternPath.get('pattern'), bindings);
-
-        } else if ((namedTypes.SpreadElementPattern &&
-          namedTypes.SpreadElementPattern.check(pattern)) ||
-          (namedTypes.SpreadPropertyPattern &&
-          namedTypes.SpreadPropertyPattern.check(pattern))) {
+        }
+        else if ((namedTypes.SpreadElementPattern &&
+            namedTypes.SpreadElementPattern.check(pattern)) ||
+            (namedTypes.SpreadPropertyPattern &&
+                namedTypes.SpreadPropertyPattern.check(pattern))) {
             addPattern(patternPath.get('argument'), bindings);
         }
     }
-
     function addTypePattern(patternPath, types) {
         var pattern = patternPath.value;
         namedTypes.Pattern.assert(pattern);
-
         if (namedTypes.Identifier.check(pattern)) {
             if (hasOwn.call(types, pattern.name)) {
                 types[pattern.name].push(patternPath);
-            } else {
+            }
+            else {
                 types[pattern.name] = [patternPath];
             }
-
         }
     }
-
-    Sp.lookup = function(name) {
+    Sp.lookup = function (name) {
         for (var scope = this; scope; scope = scope.parent)
             if (scope.declares(name))
                 break;
         return scope;
     };
-
-    Sp.lookupType = function(name) {
+    Sp.lookupType = function (name) {
         for (var scope = this; scope; scope = scope.parent)
             if (scope.declaresType(name))
                 break;
         return scope;
     };
-
-    Sp.getGlobalScope = function() {
+    Sp.getGlobalScope = function () {
         var scope = this;
         while (!scope.isGlobal)
             scope = scope.parent;
         return scope;
     };
-
     return Scope;
-};
+}
+exports.default = scopePlugin;
+module.exports = exports["default"];

package/lib/shared.d.ts

@@ -0,0 +1,13 @@
+import { Fork } from "../types";
+export default function (fork: Fork): {
+    geq: (than: any) => import("./types").Type<{}>;
+    defaults: {
+        "null": () => null;
+        "emptyArray": () => never[];
+        "false": () => boolean;
+        "true": () => boolean;
+        "undefined": () => void;
+        "use strict": () => string;
+    };
+    isPrimitive: import("./types").Type<{}>;
+};

package/lib/shared.js

@@ -1,46 +1,49 @@
-module.exports = function (fork) {
-    var exports = {};
-    var types = fork.use(require("../lib/types"));
+"use strict";;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var types_1 = __importDefault(require("./types"));
+function default_1(fork) {
+    var types = fork.use(types_1.default);
     var Type = types.Type;
     var builtin = types.builtInTypes;
     var isNumber = builtin.number;
-
     // An example of constructing a new type with arbitrary constraints from
     // an existing type.
-    exports.geq = function (than) {
-        return new Type(function (value) {
-            return isNumber.check(value) && value >= than;
-        }, isNumber + " >= " + than);
-    };
-
+    function geq(than) {
+        return Type.from(function (value) { return isNumber.check(value) && value >= than; }, isNumber + " >= " + than);
+    }
+    ;
     // Default value-returning functions that may optionally be passed as a
     // third argument to Def.prototype.field.
-    exports.defaults = {
+    var defaults = {
         // Functions were used because (among other reasons) that's the most
         // elegant way to allow for the emptyArray one always to give a new
         // array instance.
-        "null": function () { return null },
-        "emptyArray": function () { return [] },
-        "false": function () { return false },
-        "true": function () { return true },
-        "undefined": function () {}
+        "null": function () { return null; },
+        "emptyArray": function () { return []; },
+        "false": function () { return false; },
+        "true": function () { return true; },
+        "undefined": function () { },
+        "use strict": function () { return "use strict"; }
     };
-
-    var naiveIsPrimitive = Type.or(
-      builtin.string,
-      builtin.number,
-      builtin.boolean,
-      builtin.null,
-      builtin.undefined
-    );
-
-    exports.isPrimitive = new Type(function (value) {
+    var naiveIsPrimitive = Type.or(builtin.string, builtin.number, builtin.boolean, builtin.null, builtin.undefined);
+    var isPrimitive = Type.from(function (value) {
         if (value === null)
             return true;
         var type = typeof value;
-        return !(type === "object" ||
-        type === "function");
+        if (type === "object" ||
+            type === "function") {
+            return false;
+        }
+        return true;
     }, naiveIsPrimitive.toString());
-
-    return exports;
-};
+    return {
+        geq: geq,
+        defaults: defaults,
+        isPrimitive: isPrimitive,
+    };
+}
+exports.default = default_1;
+module.exports = exports["default"];

package/lib/types.d.ts

@@ -0,0 +1,140 @@
+import { Fork } from "../types";
+declare type Deep = boolean | ((type: Type<any>, value: any) => void);
+export declare type Type<T> = ArrayType<T> | IdentityType<T> | ObjectType<T> | OrType<T> | PredicateType<T>;
+export interface AnyType {
+    toString(): string;
+    check(value: any, deep?: Deep): boolean;
+    assert(value: any, deep?: Deep): boolean;
+    arrayOf(): AnyType;
+}
+declare abstract class BaseType<T> {
+    abstract toString(): string;
+    abstract check(value: any, deep?: Deep): value is T;
+    assert(value: any, deep?: Deep): value is T;
+    arrayOf(): Type<T[]>;
+}
+declare class ArrayType<T> extends BaseType<T> {
+    readonly elemType: Type<T extends (infer E)[] ? E : never>;
+    readonly kind: "ArrayType";
+    constructor(elemType: Type<T extends (infer E)[] ? E : never>);
+    toString(): string;
+    check(value: any, deep?: Deep): value is T;
+}
+declare class IdentityType<T> extends BaseType<T> {
+    readonly value: T;
+    readonly kind: "IdentityType";
+    constructor(value: T);
+    toString(): string;
+    check(value: any, deep?: Deep): value is T;
+}
+declare class ObjectType<T> extends BaseType<T> {
+    readonly fields: Field<any>[];
+    readonly kind: "ObjectType";
+    constructor(fields: Field<any>[]);
+    toString(): string;
+    check(value: any, deep?: Deep): value is T;
+}
+declare class OrType<T> extends BaseType<T> {
+    readonly types: Type<any>[];
+    readonly kind: "OrType";
+    constructor(types: Type<any>[]);
+    toString(): string;
+    check(value: any, deep?: Deep): value is T;
+}
+declare class PredicateType<T> extends BaseType<T> {
+    readonly name: string;
+    readonly predicate: (value: any, deep?: Deep) => boolean;
+    readonly kind: "PredicateType";
+    constructor(name: string, predicate: (value: any, deep?: Deep) => boolean);
+    toString(): string;
+    check(value: any, deep?: Deep): value is T;
+}
+export declare abstract class Def<T = any> {
+    readonly type: Type<T>;
+    readonly typeName: string;
+    baseNames: string[];
+    ownFields: {
+        [name: string]: Field<any>;
+    };
+    allSupertypes: {
+        [name: string]: Def<any>;
+    };
+    supertypeList: string[];
+    allFields: {
+        [name: string]: Field<any>;
+    };
+    fieldNames: string[];
+    finalized: boolean;
+    buildable: boolean;
+    buildParams: string[];
+    constructor(type: Type<T>, typeName: string);
+    isSupertypeOf(that: Def<any>): boolean;
+    checkAllFields(value: any, deep?: any): boolean;
+    abstract check(value: any, deep?: any): boolean;
+    bases(...supertypeNames: string[]): this;
+    abstract build(...buildParams: string[]): this;
+    abstract field(name: string, type: any, defaultFn?: Function, hidden?: boolean): this;
+    abstract finalize(): void;
+}
+declare class Field<T> {
+    readonly name: string;
+    readonly type: Type<T>;
+    readonly defaultFn?: Function | undefined;
+    readonly hidden: boolean;
+    constructor(name: string, type: Type<T>, defaultFn?: Function | undefined, hidden?: boolean);
+    toString(): string;
+    getValue(obj: {
+        [key: string]: any;
+    }): any;
+}
+declare type FieldType<T> = Field<T>;
+export { FieldType as Field };
+export interface ASTNode {
+    type: string;
+}
+export interface Builder {
+    (...args: any[]): ASTNode;
+    from(obj: {
+        [param: string]: any;
+    }): ASTNode;
+}
+export default function typesPlugin(_fork: Fork): {
+    Type: {
+        or(...types: any[]): Type<any>;
+        from<T>(value: any, name?: string | undefined): Type<T>;
+        def(typeName: string): Def<any>;
+        hasDef(typeName: string): boolean;
+    };
+    builtInTypes: {
+        string: Type<string>;
+        function: Type<Function>;
+        array: Type<any[]>;
+        object: Type<{
+            [key: string]: any;
+        }>;
+        RegExp: Type<RegExp>;
+        Date: Type<Date>;
+        number: Type<number>;
+        boolean: Type<boolean>;
+        null: Type<null>;
+        undefined: Type<undefined>;
+    };
+    getSupertypeNames: (typeName: string) => string[];
+    computeSupertypeLookupTable: (candidates: any) => {
+        [typeName: string]: any;
+    };
+    builders: {
+        [name: string]: Builder;
+    };
+    defineMethod: (name: any, func?: Function | undefined) => Function;
+    getBuilderName: (typeName: any) => any;
+    getStatementBuilderName: (typeName: any) => any;
+    namedTypes: {
+        [name: string]: AnyType;
+    };
+    getFieldNames: (object: any) => string[];
+    getFieldValue: (object: any, fieldName: any) => any;
+    eachField: (object: any, callback: (name: any, value: any) => any, context?: any) => void;
+    someField: (object: any, callback: (name: any, value: any) => any, context?: any) => boolean;
+    finalize: () => void;
+};