@next-core/cook 1.0.1

package/dist/esm/traverse.js

@@ -0,0 +1,157 @@
+export function collectBoundNames(root) {
+  var names = new Set();
+
+  var collect = node => {
+    if (Array.isArray(node)) {
+      for (var n of node) {
+        collect(n);
+      }
+    } else if (node) {
+      // `node` maybe `null` in some cases.
+      switch (node.type) {
+        case "Identifier":
+          names.add(node.name);
+          return;
+
+        case "VariableDeclaration":
+          return collect(node.declarations);
+
+        case "VariableDeclarator":
+          return collect(node.id);
+
+        case "ArrayPattern":
+          return collect(node.elements);
+
+        case "AssignmentPattern":
+          return collect(node.left);
+
+        case "ObjectPattern":
+          return collect(node.properties);
+
+        case "Property":
+          return collect(node.value);
+
+        case "RestElement":
+          return collect(node.argument);
+
+        case "FunctionDeclaration":
+          return collect(node.id);
+      }
+    }
+  };
+
+  collect(root);
+  return Array.from(names);
+}
+export function containsExpression(root) {
+  var collect = node => {
+    if (Array.isArray(node)) {
+      return node.some(collect);
+    } else if (node) {
+      // `node` maybe `null` in some cases.
+      switch (node.type) {
+        case "ArrayPattern":
+          return collect(node.elements);
+
+        case "AssignmentPattern":
+          return true;
+
+        case "ObjectPattern":
+          return collect(node.properties);
+
+        case "Property":
+          return node.computed || collect(node.value);
+
+        case "RestElement":
+          return collect(node.argument);
+      }
+    }
+  };
+
+  return collect(root);
+}
+export function collectScopedDeclarations(root, options) {
+  var declarations = [];
+  var nextOptions = {
+    var: options.var
+  };
+
+  var collect = (node, options) => {
+    if (Array.isArray(node)) {
+      for (var n of node) {
+        collect(n, options);
+      }
+    } else if (node) {
+      // `node` maybe `null` in some cases.
+      switch (node.type) {
+        case "FunctionDeclaration":
+          // At the top level of a function, or script, function declarations are
+          // treated like var declarations rather than like lexical declarations.
+          // See https://tc39.es/ecma262/#sec-static-semantics-toplevellexicallydeclarednames
+          if (Number(!options.var) ^ Number(options.topLevel)) {
+            declarations.push(node);
+          }
+
+          return;
+
+        case "VariableDeclaration":
+          if (Number(!options.var) ^ Number(node.kind === "var")) {
+            declarations.push(node);
+          }
+
+          return;
+
+        case "SwitchCase":
+          collect(node.consequent, nextOptions);
+          return;
+
+        case "CatchClause":
+          collect(node.body, nextOptions);
+          return;
+      }
+
+      if (options.var) {
+        switch (node.type) {
+          case "BlockStatement":
+            collect(node.body, nextOptions);
+            return;
+
+          case "IfStatement":
+            collect(node.consequent, nextOptions);
+            collect(node.alternate, nextOptions);
+            return;
+
+          case "DoWhileStatement":
+          case "WhileStatement":
+            collect(node.body, nextOptions);
+            return;
+
+          case "ForStatement":
+            collect(node.init, nextOptions);
+            collect(node.body, nextOptions);
+            return;
+
+          case "ForInStatement":
+          case "ForOfStatement":
+            collect(node.left, nextOptions);
+            collect(node.body, nextOptions);
+            return;
+
+          case "SwitchStatement":
+            collect(node.cases, nextOptions);
+            return;
+
+          case "TryStatement":
+            collect(node.block, nextOptions);
+            collect(node.handler, nextOptions);
+            collect(node.finalizer, nextOptions);
+            return;
+        }
+      }
+    }
+  };
+
+  collect(root, options);
+  return declarations;
+}
+//# sourceMappingURL=traverse.js.map

package/dist/esm/traverse.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/traverse.ts"],"names":["collectBoundNames","root","names","Set","collect","node","Array","isArray","n","type","add","name","declarations","id","elements","left","properties","value","argument","from","containsExpression","some","computed","collectScopedDeclarations","options","nextOptions","var","Number","topLevel","push","kind","consequent","body","alternate","init","cases","block","handler","finalizer"],"mappings":"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","sourcesContent":["import { FunctionDeclaration, VariableDeclaration } from \"@babel/types\";\nimport { EstreeNode, NodeWithBoundNames } from \"./interfaces\";\n\ntype InternalCollect<T = void, O = unknown> = (\n  node: EstreeNode | EstreeNode[],\n  options?: O\n) => T;\ntype InternalCollectWithOptions<T = void, O = unknown> = (\n  node: EstreeNode | EstreeNode[],\n  options: O\n) => T;\n\nexport function collectBoundNames(\n  root: NodeWithBoundNames | NodeWithBoundNames[]\n): string[] {\n  const names = new Set<string>();\n  const collect: InternalCollect = (node) => {\n    if (Array.isArray(node)) {\n      for (const n of node) {\n        collect(n);\n      }\n    } else if (node) {\n      // `node` maybe `null` in some cases.\n      switch (node.type) {\n        case \"Identifier\":\n          names.add(node.name);\n          return;\n        case \"VariableDeclaration\":\n          return collect(node.declarations);\n        case \"VariableDeclarator\":\n          return collect(node.id);\n        case \"ArrayPattern\":\n          return collect(node.elements);\n        case \"AssignmentPattern\":\n          return collect(node.left);\n        case \"ObjectPattern\":\n          return collect(node.properties);\n        case \"Property\":\n          return collect(node.value);\n        case \"RestElement\":\n          return collect(node.argument);\n        case \"FunctionDeclaration\":\n          return collect(node.id);\n      }\n    }\n  };\n  collect(root);\n  return Array.from(names);\n}\n\nexport function containsExpression(root: EstreeNode | EstreeNode[]): boolean {\n  const collect: InternalCollect<boolean> = (node) => {\n    if (Array.isArray(node)) {\n      return node.some(collect);\n    } else if (node) {\n      // `node` maybe `null` in some cases.\n      switch (node.type) {\n        case \"ArrayPattern\":\n          return collect(node.elements);\n        case \"AssignmentPattern\":\n          return true;\n        case \"ObjectPattern\":\n          return collect(node.properties);\n        case \"Property\":\n          return node.computed || collect(node.value);\n        case \"RestElement\":\n          return collect(node.argument);\n      }\n    }\n  };\n  return collect(root);\n}\n\ninterface ScopedDeclarationOptions {\n  var?: boolean;\n  topLevel?: boolean;\n}\n\ntype ScopedDeclaration = VariableDeclaration | FunctionDeclaration;\n\nexport function collectScopedDeclarations(\n  root: EstreeNode | EstreeNode[],\n  options: ScopedDeclarationOptions\n): ScopedDeclaration[] {\n  const declarations: ScopedDeclaration[] = [];\n  const nextOptions = { var: options.var };\n  const collect: InternalCollectWithOptions<void, ScopedDeclarationOptions> = (\n    node,\n    options\n  ): void => {\n    if (Array.isArray(node)) {\n      for (const n of node) {\n        collect(n, options);\n      }\n    } else if (node) {\n      // `node` maybe `null` in some cases.\n      switch (node.type) {\n        case \"FunctionDeclaration\":\n          // At the top level of a function, or script, function declarations are\n          // treated like var declarations rather than like lexical declarations.\n          // See https://tc39.es/ecma262/#sec-static-semantics-toplevellexicallydeclarednames\n          if (Number(!options.var) ^ Number(options.topLevel)) {\n            declarations.push(node);\n          }\n          return;\n        case \"VariableDeclaration\":\n          if (Number(!options.var) ^ Number(node.kind === \"var\")) {\n            declarations.push(node);\n          }\n          return;\n        case \"SwitchCase\":\n          collect(node.consequent, nextOptions);\n          return;\n        case \"CatchClause\":\n          collect(node.body, nextOptions);\n          return;\n      }\n      if (options.var) {\n        switch (node.type) {\n          case \"BlockStatement\":\n            collect(node.body, nextOptions);\n            return;\n          case \"IfStatement\":\n            collect(node.consequent, nextOptions);\n            collect(node.alternate, nextOptions);\n            return;\n          case \"DoWhileStatement\":\n          case \"WhileStatement\":\n            collect(node.body, nextOptions);\n            return;\n          case \"ForStatement\":\n            collect(node.init, nextOptions);\n            collect(node.body, nextOptions);\n            return;\n          case \"ForInStatement\":\n          case \"ForOfStatement\":\n            collect(node.left, nextOptions);\n            collect(node.body, nextOptions);\n            return;\n          case \"SwitchStatement\":\n            collect(node.cases, nextOptions);\n            return;\n          case \"TryStatement\":\n            collect(node.block, nextOptions);\n            collect(node.handler, nextOptions);\n            collect(node.finalizer, nextOptions);\n            return;\n        }\n      }\n    }\n  };\n  collect(root, options);\n  return declarations;\n}\n"],"file":"traverse.js"}

package/dist/types/AnalysisContext.d.ts

@@ -0,0 +1,17 @@
+import { Expression, FunctionDeclaration, Statement } from "@babel/types";
+export declare class AnalysisContext {
+    VariableEnvironment: AnalysisEnvironment;
+    LexicalEnvironment: AnalysisEnvironment;
+}
+export declare class AnalysisEnvironment {
+    readonly OuterEnv: AnalysisEnvironment;
+    private readonly bindingSet;
+    constructor(outer: AnalysisEnvironment);
+    HasBinding(name: string): boolean;
+    CreateBinding(name: string): void;
+}
+export interface AnalysisFunctionObject {
+    FormalParameters: FunctionDeclaration["params"];
+    ECMAScriptCode: Statement[] | Expression;
+    Environment: AnalysisEnvironment;
+}

package/dist/types/ExecutionContext.d.ts

@@ -0,0 +1,79 @@
+import { Expression, FunctionDeclaration, Statement } from "@babel/types";
+export declare class ExecutionContext {
+    VariableEnvironment: EnvironmentRecord;
+    LexicalEnvironment: EnvironmentRecord;
+    Function: FunctionObject;
+}
+export declare type EnvironmentRecordType = "function" | "declarative";
+export declare class EnvironmentRecord {
+    readonly OuterEnv: EnvironmentRecord;
+    private readonly bindingMap;
+    constructor(outer: EnvironmentRecord);
+    HasBinding(name: string): boolean;
+    CreateMutableBinding(name: string, deletable: boolean): CompletionRecord;
+    /**
+     * Create an immutable binding.
+     *
+     * @param name - The binding name.
+     * @param strict - For named function expressions, strict is false, otherwise it's true.
+     * @returns CompletionRecord.
+     */
+    CreateImmutableBinding(name: string, strict: boolean): CompletionRecord;
+    InitializeBinding(name: string, value: unknown): CompletionRecord;
+    /**
+     * Update a mutable binding value, including function declarations.
+     *
+     * @param name - The binding name.
+     * @param value - The binding value.
+     * @param strict - For functions, strict is always false, otherwise it depends on strict-mode.
+     * @returns
+     */
+    SetMutableBinding(name: string, value: unknown, strict: boolean): CompletionRecord;
+    GetBindingValue(name: string, strict: boolean): unknown;
+}
+export declare class DeclarativeEnvironment extends EnvironmentRecord {
+}
+export declare class FunctionEnvironment extends EnvironmentRecord {
+}
+export interface BindingState {
+    initialized?: boolean;
+    value?: unknown;
+    mutable?: boolean;
+    /** This is used for mutable bindings only. */
+    deletable?: boolean;
+    /**
+     * This is used for immutable bindings only.
+     * For named function expressions, `strict` is false,
+     * otherwise it's true.
+     */
+    strict?: boolean;
+}
+export declare const FormalParameters: unique symbol;
+export declare const ECMAScriptCode: unique symbol;
+export declare const Environment: unique symbol;
+export declare const IsConstructor: unique symbol;
+export interface FunctionObject {
+    (...args: unknown[]): unknown;
+    [FormalParameters]: FunctionDeclaration["params"];
+    [ECMAScriptCode]: Statement[] | Expression;
+    [Environment]: EnvironmentRecord;
+    [IsConstructor]: boolean;
+}
+export declare class ReferenceRecord {
+    readonly Base?: Record<PropertyKey, unknown> | EnvironmentRecord | "unresolvable";
+    readonly ReferenceName?: PropertyKey;
+    /** Whether the reference is in strict mode. */
+    readonly Strict?: boolean;
+    constructor(base: Record<PropertyKey, unknown> | EnvironmentRecord | "unresolvable", referenceName: PropertyKey, strict: boolean);
+}
+export declare class CompletionRecord {
+    readonly Type: CompletionRecordType;
+    readonly Value: unknown;
+    constructor(type: CompletionRecordType, value: unknown);
+}
+export declare type CompletionRecordType = "normal" | "break" | "continue" | "return" | "throw";
+export declare function NormalCompletion(value: unknown): CompletionRecord;
+export declare const Empty: unique symbol;
+export interface OptionalChainRef {
+    skipped?: boolean;
+}

package/dist/types/context-free.d.ts

@@ -0,0 +1,19 @@
+import { BinaryExpression, UnaryExpression, VariableDeclaration } from "@babel/types";
+import { CompletionRecord, EnvironmentRecord, ReferenceRecord } from "./ExecutionContext";
+export declare function IsPropertyReference(V: ReferenceRecord): boolean;
+export declare function InitializeReferencedBinding(V: ReferenceRecord, W: unknown): CompletionRecord;
+export declare function CopyDataProperties(target: Record<PropertyKey, unknown>, source: unknown, excludedItems: Set<PropertyKey>): Record<PropertyKey, unknown>;
+export declare function ForDeclarationBindingInstantiation(forDeclaration: VariableDeclaration, env: EnvironmentRecord): void;
+export declare function LoopContinues(completion: CompletionRecord): boolean;
+export declare function UpdateEmpty(completion: CompletionRecord, value: unknown): CompletionRecord;
+export declare function GetValue(V: unknown): unknown;
+export declare function ToPropertyKey(arg: unknown): string | symbol;
+export declare function GetV(V: unknown, P: PropertyKey): unknown;
+export declare function PutValue(V: ReferenceRecord, W: unknown): CompletionRecord;
+export declare function CreateListIteratorRecord(args: Iterable<unknown>): Iterator<unknown>;
+export declare function RequireObjectCoercible(arg: unknown): void;
+export declare function GetIdentifierReference(env: EnvironmentRecord, name: string, strict: boolean): ReferenceRecord;
+export declare function ApplyStringOrNumericBinaryOperator(leftValue: number, operator: BinaryExpression["operator"] | "|>", rightValue: number): unknown;
+export declare function ApplyStringOrNumericAssignment(leftValue: string | number, operator: string, rightValue: string | number): unknown;
+export declare function ApplyUnaryOperator(target: unknown, operator: UnaryExpression["operator"]): unknown;
+export declare function isIterable(cooked: unknown): boolean;

package/dist/types/cook.d.ts

@@ -0,0 +1,12 @@
+import { Expression, FunctionDeclaration } from "@babel/types";
+import { CookRules } from "./interfaces";
+export interface CookOptions {
+    rules?: CookRules;
+    globalVariables?: Record<string, unknown>;
+}
+export interface CookContext {
+    source: string;
+    attemptToVisitGlobals: Set<string>;
+}
+/** For next-core internal usage only. */
+export declare function cook(rootAst: FunctionDeclaration | Expression, codeSource: string, { rules, globalVariables }?: CookOptions): unknown;

package/dist/types/cook.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/hasOwnProperty.d.ts

@@ -0,0 +1 @@
+export declare function hasOwnProperty(object: unknown, property: string | number | symbol): boolean;

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./cook";
+export * from "./lint";
+export * from "./precookFunction";
+export * from "./preevaluate";

package/dist/types/interfaces.d.ts

@@ -0,0 +1,33 @@
+import { Expression, FunctionDeclaration, LVal, Node, ObjectExpression, ObjectPattern, ObjectProperty, RestElement, SourceLocation, SpreadElement, VariableDeclaration } from "@babel/types";
+export declare type EstreeNode = Node | EstreeObjectExpression | EstreeObjectPattern | EstreeProperty | EstreeChainExpression | EstreeLiteral;
+export declare type EstreeLVal = LVal | EstreeObjectPattern;
+export declare type EstreeObjectExpression = Omit<ObjectExpression, "properties"> & {
+    properties: (EstreeProperty | SpreadElement)[];
+};
+export declare type EstreeObjectPattern = Omit<ObjectPattern, "properties"> & {
+    properties: (EstreeProperty | RestElement)[];
+};
+export declare type EstreeProperty = Omit<ObjectProperty, "type"> & {
+    type: "Property";
+    kind: "init" | "get" | "set";
+};
+export interface EstreeChainExpression {
+    type: "ChainExpression";
+    expression: Expression;
+    loc: SourceLocation;
+}
+export interface EstreeLiteral {
+    type: "Literal";
+    value: unknown;
+    raw: string;
+    regex?: {
+        flags: string;
+    };
+    loc: SourceLocation;
+}
+export declare type NodeWithBoundNames = LVal | VariableDeclaration | FunctionDeclaration;
+export declare type EstreeVisitors = Record<string, EstreeVisitorFn>;
+export declare type EstreeVisitorFn = (node: any) => void;
+export interface CookRules {
+    noVar?: boolean;
+}

package/dist/types/lint.d.ts

@@ -0,0 +1,13 @@
+import { SourceLocation } from "@babel/types";
+import { CookRules } from "./interfaces";
+export interface LintOptions {
+    typescript?: boolean;
+    rules?: CookRules;
+}
+export interface LintError {
+    type: "SyntaxError" | "TypeError";
+    message: string;
+    loc: SourceLocation;
+}
+/** For next-core internal or devtools usage only. */
+export declare function lint(source: string, { typescript, rules }?: LintOptions): LintError[];

package/dist/types/lint.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/parse.d.ts

@@ -0,0 +1,6 @@
+import { Expression, FunctionDeclaration } from "@babel/types";
+export declare function parseAsEstreeExpression(source: string): Expression;
+export interface ParseEstreeOptions {
+    typescript?: boolean;
+}
+export declare function parseAsEstree(source: string, { typescript }?: ParseEstreeOptions): FunctionDeclaration;

package/dist/types/precook.d.ts

@@ -0,0 +1,14 @@
+import { Expression, FunctionDeclaration } from "@babel/types";
+import { EstreeVisitors } from "./interfaces";
+export interface PrecookOptions {
+    expressionOnly?: boolean;
+    visitors?: EstreeVisitors;
+}
+/**
+ * Analysis an AST of a storyboard function or an evaluation expression.
+ *
+ * @param rootAst - The root AST.
+ * @param options - Analysis options.
+ * @returns A set of global variables the root AST attempts to access.
+ */
+export declare function precook(rootAst: Expression | FunctionDeclaration, { expressionOnly, visitors }?: PrecookOptions): Set<string>;

package/dist/types/precook.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/precookFunction.d.ts

@@ -0,0 +1,10 @@
+import { FunctionDeclaration } from "@babel/types";
+import { PrecookOptions } from "./precook";
+export interface PrecookFunctionOptions extends PrecookOptions {
+    typescript?: boolean;
+}
+export interface PrecookFunctionResult {
+    function: FunctionDeclaration;
+    attemptToVisitGlobals: Set<string>;
+}
+export declare function precookFunction(source: string, { typescript, ...restOptions }?: PrecookFunctionOptions): PrecookFunctionResult;

package/dist/types/precookFunction.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/preevaluate.d.ts

@@ -0,0 +1,13 @@
+import { Expression } from "@babel/types";
+import { EstreeVisitors } from "./interfaces";
+export interface PreevaluateOptions {
+    visitors?: EstreeVisitors;
+}
+export interface PreevaluateResult {
+    expression: Expression;
+    attemptToVisitGlobals: Set<string>;
+    source: string;
+}
+export declare function preevaluate(raw: string, options?: PreevaluateOptions): PreevaluateResult;
+export declare function isEvaluable(raw: string): boolean;
+export declare function shouldAllowRecursiveEvaluations(raw: string): boolean;

package/dist/types/preevaluate.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/sanitize.d.ts

@@ -0,0 +1,2 @@
+export declare function sanitize(cooked: unknown): void;
+export declare function isAllowedConstructor(constructor: unknown): boolean;

package/dist/types/traverse.d.ts

@@ -0,0 +1,11 @@
+import { FunctionDeclaration, VariableDeclaration } from "@babel/types";
+import { EstreeNode, NodeWithBoundNames } from "./interfaces";
+export declare function collectBoundNames(root: NodeWithBoundNames | NodeWithBoundNames[]): string[];
+export declare function containsExpression(root: EstreeNode | EstreeNode[]): boolean;
+interface ScopedDeclarationOptions {
+    var?: boolean;
+    topLevel?: boolean;
+}
+declare type ScopedDeclaration = VariableDeclaration | FunctionDeclaration;
+export declare function collectScopedDeclarations(root: EstreeNode | EstreeNode[], options: ScopedDeclarationOptions): ScopedDeclaration[];
+export {};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@next-core/cook",
+  "version": "1.0.1",
+  "description": "Cook expressions and storyboard functions",
+  "homepage": "https://github.com/easyops-cn/next-core/tree/master/packages/cook",
+  "license": "GPL-3.0",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:easyops-cn/next-core.git"
+  },
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "typings": "dist/types/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "clean": "rimraf dist",
+    "prestart": "npm run clean",
+    "start": "concurrently -k -n types,main \"npm run start:types\" \"npm run start:main\"",
+    "start:main": "cross-env NODE_ENV=development build-next-libs --watch",
+    "start:types": "tsc --watch --emitDeclarationOnly --declaration --declarationDir dist/types",
+    "prebuild": "npm run clean",
+    "build": "npm run build:types && npm run build:main",
+    "build:main": "cross-env NODE_ENV=production build-next-libs",
+    "build:types": "tsc --emitDeclarationOnly --declaration --declarationDir dist/types",
+    "test": "cross-env NODE_ENV='test' jest",
+    "test:ci": "cross-env NODE_ENV='test' CI=true jest"
+  },
+  "sideEffects": false,
+  "dependencies": {
+    "@babel/parser": "^7.15.5",
+    "@next-core/brick-types": "^2.39.1"
+  },
+  "devDependencies": {
+    "@next-core/supply": "^1.0.1",
+    "lodash": "^4.17.21"
+  },
+  "gitHead": "41bff386009ac26450dd768b5e1a1d1c9ee17636"
+}