ast-types 0.15.1 → 0.15.2

package/def/babel-core.js

@@ -5,11 +5,13 @@ var es_proposals_1 = (0, tslib_1.__importDefault)(require("./es-proposals"));
 var types_1 = (0, tslib_1.__importDefault)(require("../lib/types"));
 var shared_1 = (0, tslib_1.__importDefault)(require("../lib/shared"));
 function default_1(fork) {
+    var _a, _b, _c, _d, _e;
     fork.use(es_proposals_1.default);
     var types = fork.use(types_1.default);
     var defaults = fork.use(shared_1.default).defaults;
     var def = types.Type.def;
     var or = types.Type.or;
+    var isUndefined = types.builtInTypes.undefined;
     def("Noop")
         .bases("Statement")
         .build();
@@ -63,55 +65,49 @@ function default_1(fork) {
         .field("body", [def("Statement")])
         .field("directives", [def("Directive")], defaults.emptyArray)
         .field("interpreter", or(def("InterpreterDirective"), null), defaults["null"]);
+    function makeLiteralExtra(rawValueType, toRaw) {
+        if (rawValueType === void 0) { rawValueType = String; }
+        return [
+            "extra",
+            {
+                rawValue: rawValueType,
+                raw: String,
+            },
+            function getDefault() {
+                var value = types.getFieldValue(this, "value");
+                return {
+                    rawValue: value,
+                    raw: toRaw ? toRaw(value) : String(value),
+                };
+            },
+        ];
+    }
     // Split Literal
-    def("StringLiteral")
+    (_a = def("StringLiteral")
         .bases("Literal")
         .build("value")
-        .field("value", String);
-    def("NumericLiteral")
+        .field("value", String))
+        .field.apply(_a, makeLiteralExtra(String, function (val) { return JSON.stringify(val); }));
+    (_b = def("NumericLiteral")
         .bases("Literal")
         .build("value")
         .field("value", Number)
-        .field("raw", or(String, null), defaults["null"])
-        .field("extra", {
-        rawValue: Number,
-        raw: String
-    }, function getDefault() {
-        return {
-            rawValue: this.value,
-            raw: this.value + ""
-        };
-    });
-    def("BigIntLiteral")
+        .field("raw", or(String, null), defaults["null"]))
+        .field.apply(_b, makeLiteralExtra(Number));
+    (_c = def("BigIntLiteral")
         .bases("Literal")
         .build("value")
         // Only String really seems appropriate here, since BigInt values
         // often exceed the limits of JS numbers.
-        .field("value", or(String, Number))
-        .field("extra", {
-        rawValue: String,
-        raw: String
-    }, function getDefault() {
-        return {
-            rawValue: String(this.value),
-            raw: this.value + "n",
-        };
-    });
+        .field("value", or(String, Number)))
+        .field.apply(_c, makeLiteralExtra(String, function (val) { return val + "n"; }));
     // https://github.com/tc39/proposal-decimal
     // https://github.com/babel/babel/pull/11640
-    def("DecimalLiteral")
+    (_d = def("DecimalLiteral")
         .bases("Literal")
         .build("value")
-        .field("value", String)
-        .field("extra", {
-        rawValue: String,
-        raw: String
-    }, function getDefault() {
-        return {
-            rawValue: String(this.value),
-            raw: this.value + "m",
-        };
-    });
+        .field("value", String))
+        .field.apply(_d, makeLiteralExtra(String, function (val) { return val + "m"; }));
     def("NullLiteral")
         .bases("Literal")
         .build()
@@ -120,13 +116,22 @@ function default_1(fork) {
         .bases("Literal")
         .build("value")
         .field("value", Boolean);
-    def("RegExpLiteral")
+    (_e = def("RegExpLiteral")
         .bases("Literal")
         .build("pattern", "flags")
         .field("pattern", String)
         .field("flags", String)
         .field("value", RegExp, function () {
         return new RegExp(this.pattern, this.flags);
+    }))
+        .field.apply(_e, makeLiteralExtra(or(RegExp, isUndefined), function (exp) { return "/".concat(exp.pattern, "/").concat(exp.flags || ""); })).field("regex", {
+        pattern: String,
+        flags: String
+    }, function () {
+        return {
+            pattern: this.pattern,
+            flags: this.flags,
+        };
     });
     var ObjectExpressionProperty = or(def("Property"), def("ObjectMethod"), def("ObjectProperty"), def("SpreadProperty"), def("SpreadElement"));
     // Split Property -> ObjectProperty and ObjectMethod

package/def/core.js

@@ -262,26 +262,7 @@ function default_1(fork) {
     def("Literal")
         .bases("Expression")
         .build("value")
-        .field("value", or(String, Boolean, null, Number, RegExp))
-        .field("regex", or({
-        pattern: String,
-        flags: String
-    }, null), function () {
-        if (this.value instanceof RegExp) {
-            var flags = "";
-            if (this.value.ignoreCase)
-                flags += "i";
-            if (this.value.multiline)
-                flags += "m";
-            if (this.value.global)
-                flags += "g";
-            return {
-                pattern: this.value.source,
-                flags: flags
-            };
-        }
-        return null;
-    });
+        .field("value", or(String, Boolean, null, Number, RegExp, BigInt));
     // Abstract (non-buildable) comment supertype. Not a Node.
     def("Comment")
         .bases("Printable")

package/def/es-proposals.js

@@ -61,7 +61,7 @@ function default_1(fork) {
     // https://github.com/babel/babel/pull/12469
     def("ModuleExpression")
         .bases("Node")
-        .build("program")
+        .build("body")
         .field("body", def("Program"));
 }
 exports.default = default_1;

package/fork.d.ts

@@ -1,5 +1,5 @@
-import { Def, Plugin } from "./types";
-export default function (defs: Def[]): {
+import { Plugin } from "./types";
+export default function (plugins: Plugin<any>[]): {
     Type: {
         or(...types: any[]): import("./lib/types").Type<any>;
         from<T>(value: any, name?: string | undefined): import("./lib/types").Type<T>;
@@ -19,6 +19,7 @@ export default function (defs: Def[]): {
         boolean: import("./lib/types").Type<boolean>;
         null: import("./lib/types").Type<null>;
         undefined: import("./lib/types").Type<undefined>;
+        BigInt: import("./lib/types").Type<BigInt>;
     };
     namedTypes: import("./gen/namedTypes").NamedTypes;
     builders: import("./gen/builders").builders;

package/fork.js

@@ -6,10 +6,10 @@ var path_visitor_1 = (0, tslib_1.__importDefault)(require("./lib/path-visitor"))
 var equiv_1 = (0, tslib_1.__importDefault)(require("./lib/equiv"));
 var path_1 = (0, tslib_1.__importDefault)(require("./lib/path"));
 var node_path_1 = (0, tslib_1.__importDefault)(require("./lib/node-path"));
-function default_1(defs) {
+function default_1(plugins) {
     var fork = createFork();
     var types = fork.use(types_1.default);
-    defs.forEach(fork.use);
+    plugins.forEach(fork.use);
     types.finalize();
     var PathVisitor = fork.use(path_visitor_1.default);
     return {

package/gen/builders.d.ts

@@ -292,15 +292,11 @@ export interface PropertyBuilder {
     }): namedTypes.Property;
 }
 export interface LiteralBuilder {
-    (value: string | boolean | null | number | RegExp): namedTypes.Literal;
+    (value: string | boolean | null | number | RegExp | BigInt): namedTypes.Literal;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-        regex?: {
-            pattern: string;
-            flags: string;
-        } | null;
-        value: string | boolean | null | number | RegExp;
+        value: string | boolean | null | number | RegExp | BigInt;
     }): namedTypes.Literal;
 }
 export interface SequenceExpressionBuilder {
@@ -911,7 +907,7 @@ export interface TupleExpressionBuilder {
     }): namedTypes.TupleExpression;
 }
 export interface ModuleExpressionBuilder {
-    (): namedTypes.ModuleExpression;
+    (body: K.ProgramKind): namedTypes.ModuleExpression;
     from(params: {
         body: K.ProgramKind;
         comments?: K.CommentKind[] | null;
@@ -1009,10 +1005,6 @@ export interface JSXTextBuilder {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         raw?: string;
-        regex?: {
-            pattern: string;
-            flags: string;
-        } | null;
         value: string;
     }): namedTypes.JSXText;
 }
@@ -1812,11 +1804,11 @@ export interface StringLiteralBuilder {
     (value: string): namedTypes.StringLiteral;
     from(params: {
         comments?: K.CommentKind[] | null;
+        extra?: {
+            rawValue: string;
+            raw: string;
+        };
         loc?: K.SourceLocationKind | null;
-        regex?: {
-            pattern: string;
-            flags: string;
-        } | null;
         value: string;
     }): namedTypes.StringLiteral;
 }
@@ -1830,10 +1822,6 @@ export interface NumericLiteralBuilder {
         };
         loc?: K.SourceLocationKind | null;
         raw?: string | null;
-        regex?: {
-            pattern: string;
-            flags: string;
-        } | null;
         value: number;
     }): namedTypes.NumericLiteral;
 }
@@ -1846,10 +1834,6 @@ export interface BigIntLiteralBuilder {
             raw: string;
         };
         loc?: K.SourceLocationKind | null;
-        regex?: {
-            pattern: string;
-            flags: string;
-        } | null;
         value: string | number;
     }): namedTypes.BigIntLiteral;
 }
@@ -1862,10 +1846,6 @@ export interface DecimalLiteralBuilder {
             raw: string;
         };
         loc?: K.SourceLocationKind | null;
-        regex?: {
-            pattern: string;
-            flags: string;
-        } | null;
         value: string;
     }): namedTypes.DecimalLiteral;
 }
@@ -1874,10 +1854,6 @@ export interface NullLiteralBuilder {
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-        regex?: {
-            pattern: string;
-            flags: string;
-        } | null;
         value?: null;
     }): namedTypes.NullLiteral;
 }
@@ -1886,10 +1862,6 @@ export interface BooleanLiteralBuilder {
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-        regex?: {
-            pattern: string;
-            flags: string;
-        } | null;
         value: boolean;
     }): namedTypes.BooleanLiteral;
 }
@@ -1897,13 +1869,17 @@ export interface RegExpLiteralBuilder {
     (pattern: string, flags: string): namedTypes.RegExpLiteral;
     from(params: {
         comments?: K.CommentKind[] | null;
+        extra?: {
+            rawValue: RegExp | undefined;
+            raw: string;
+        };
         flags: string;
         loc?: K.SourceLocationKind | null;
         pattern: string;
         regex?: {
             pattern: string;
             flags: string;
-        } | null;
+        };
         value?: RegExp;
     }): namedTypes.RegExpLiteral;
 }

package/gen/namedTypes.d.ts

@@ -196,11 +196,7 @@ export declare namespace namedTypes {
     }
     interface Literal extends Omit<Expression, "type"> {
         type: "Literal";
-        value: string | boolean | null | number | RegExp;
-        regex?: {
-            pattern: string;
-            flags: string;
-        } | null;
+        value: string | boolean | null | number | RegExp | BigInt;
     }
     interface SequenceExpression extends Omit<Expression, "type"> {
         type: "SequenceExpression";
@@ -1018,6 +1014,10 @@ export declare namespace namedTypes {
     interface StringLiteral extends Omit<Literal, "type" | "value"> {
         type: "StringLiteral";
         value: string;
+        extra?: {
+            rawValue: string;
+            raw: string;
+        };
     }
     interface NumericLiteral extends Omit<Literal, "type" | "value"> {
         type: "NumericLiteral";
@@ -1057,6 +1057,14 @@ export declare namespace namedTypes {
         pattern: string;
         flags: string;
         value?: RegExp;
+        extra?: {
+            rawValue: RegExp | undefined;
+            raw: string;
+        };
+        regex?: {
+            pattern: string;
+            flags: string;
+        };
     }
     interface ClassMethod extends Omit<Declaration, "type">, Omit<Function, "type" | "body"> {
         type: "ClassMethod";

package/lib/types.d.ts

@@ -118,6 +118,7 @@ export default function typesPlugin(_fork: Fork): {
         boolean: Type<boolean>;
         null: Type<null>;
         undefined: Type<undefined>;
+        BigInt: Type<BigInt>;
     };
     getSupertypeNames: (typeName: string) => string[];
     computeSupertypeLookupTable: (candidates: any) => {

package/lib/types.js

@@ -316,6 +316,9 @@ function typesPlugin(_fork) {
     var isBoolean = defBuiltInType("boolean", true);
     var isNull = defBuiltInType("null", null);
     var isUndefined = defBuiltInType("undefined", undefined);
+    var isBigInt = typeof BigInt === "function"
+        ? defBuiltInType("BigInt", BigInt(1234))
+        : new PredicateType("BigInt", function () { return false; });
     var builtInTypes = {
         string: isString,
         function: isFunction,
@@ -327,6 +330,7 @@ function typesPlugin(_fork) {
         boolean: isBoolean,
         null: isNull,
         undefined: isUndefined,
+        BigInt: isBigInt,
     };
     // In order to return the same Def instance every time Type.def is called
     // with a particular name, those instances need to be stored in a cache.

package/main.d.ts

@@ -19,6 +19,7 @@ declare const astNodesAreEquivalent: {
     boolean: Type<boolean>;
     null: Type<null>;
     undefined: Type<undefined>;
+    BigInt: Type<BigInt>;
 }, defineMethod: (name: any, func?: Function | undefined) => Function, eachField: (object: any, callback: (name: any, value: any) => any, context?: any) => void, finalize: () => void, getBuilderName: (typeName: any) => any, getFieldNames: (object: any) => string[], getFieldValue: (object: any, fieldName: any) => any, getSupertypeNames: (typeName: string) => string[], NodePath: import("./lib/node-path").NodePathConstructor, Path: import("./lib/path").PathConstructor, PathVisitor: import("./lib/path-visitor").PathVisitorConstructor, someField: (object: any, callback: (name: any, value: any) => any, context?: any) => boolean, Type: {
     or(...types: any[]): Type<any>;
     from<T>(value: any, name?: string | undefined): Type<T>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "author": "Ben Newman <bn@cs.stanford.edu>",
   "name": "ast-types",
-  "version": "0.15.1",
+  "version": "0.15.2",
   "description": "Esprima-compatible implementation of the Mozilla JS Parser API",
   "keywords": [
     "ast",
@@ -49,7 +49,7 @@
     "espree": "9.1.0",
     "esprima": "4.0.1",
     "esprima-fb": "15001.1001.0-dev-harmony-fb",
-    "flow-parser": "0.165.1",
+    "flow-parser": "0.166.0",
     "glob": "7.2.0",
     "mocha": "^9.1.3",
     "recast": "0.20.5",

package/types.d.ts

@@ -2,5 +2,4 @@ export declare type Fork = {
     use<T>(plugin: Plugin<T>): T;
 };
 export declare type Plugin<T> = (fork: Fork) => T;
-export declare type Def = Plugin<void>;
 export declare type Omit<T, K> = Pick<T, Exclude<keyof T, K>>;