@webstudio-is/react-sdk 0.95.0 → 0.97.0

package/lib/expression.js

@@ -1,330 +0,0 @@
-"use strict";
-import jsep from "jsep";
-import jsepAssignment from "@jsep-plugin/assignment";
-jsep.plugins.register(jsepAssignment);
-const generateCode = (node, failOnForbidden, effectful, transformIdentifier) => {
-  if (node.type === "Identifier") {
-    return transformIdentifier(node.name, false);
-  }
-  if (node.type === "MemberExpression") {
-    if (failOnForbidden) {
-      const object2 = generateCode(
-        node.object,
-        false,
-        effectful,
-        transformIdentifier
-      );
-      const property2 = generateCode(
-        node.property,
-        false,
-        effectful,
-        transformIdentifier
-      );
-      throw Error(`Cannot access "${property2}" of "${object2}"`);
-    }
-    const object = generateCode(
-      node.object,
-      failOnForbidden,
-      effectful,
-      transformIdentifier
-    );
-    const property = generateCode(
-      node.property,
-      failOnForbidden,
-      effectful,
-      transformIdentifier
-    );
-    return `${object}.${property}`;
-  }
-  if (node.type === "Literal") {
-    return node.raw;
-  }
-  if (node.type === "UnaryExpression") {
-    const arg = generateCode(
-      node.argument,
-      failOnForbidden,
-      effectful,
-      transformIdentifier
-    );
-    return `${node.operator}${arg}`;
-  }
-  if (node.type === "BinaryExpression") {
-    const left = generateCode(
-      node.left,
-      failOnForbidden,
-      effectful,
-      transformIdentifier
-    );
-    const right = generateCode(
-      node.right,
-      failOnForbidden,
-      effectful,
-      transformIdentifier
-    );
-    return `${left} ${node.operator} ${right}`;
-  }
-  if (node.type === "ArrayExpression") {
-    const elements = node.elements.map(
-      (element) => generateCode(
-        element,
-        failOnForbidden,
-        effectful,
-        transformIdentifier
-      )
-    );
-    return `[${elements.join(", ")}]`;
-  }
-  if (node.type === "CallExpression") {
-    if (failOnForbidden) {
-      const callee2 = generateCode(
-        node.callee,
-        false,
-        effectful,
-        transformIdentifier
-      );
-      throw Error(`Cannot call "${callee2}"`);
-    }
-    const callee = generateCode(
-      node.callee,
-      failOnForbidden,
-      effectful,
-      transformIdentifier
-    );
-    const args = node.arguments.map(
-      (arg) => generateCode(arg, failOnForbidden, effectful, transformIdentifier)
-    );
-    return `${callee}(${args.join(", ")})`;
-  }
-  if (node.type === "ThisExpression") {
-    if (failOnForbidden) {
-      throw Error(`"this" is not supported`);
-    }
-    return "this";
-  }
-  if (node.type === "ConditionalExpression") {
-    throw Error("Ternary operator is not supported");
-  }
-  if (node.type === "Compound") {
-    throw Error("Cannot use multiple expressions");
-  }
-  if (node.type === "AssignmentExpression") {
-    if (node.operator !== "=") {
-      throw Error(`Only "=" assignment operator is supported`);
-    }
-    if (effectful === false) {
-      throw Error(`Cannot use assignment in this expression`);
-    }
-    const left = generateCode(
-      node.left,
-      failOnForbidden,
-      effectful,
-      // override and mark all identifiers inside of left expression as assignee
-      (id) => transformIdentifier(id, true)
-    );
-    const right = generateCode(
-      node.right,
-      failOnForbidden,
-      effectful,
-      transformIdentifier
-    );
-    return `${left} ${node.operator} ${right}`;
-  }
-  if (node.type === "UpdateExpression") {
-    throw Error(`"${node.operator}" operator is not supported`);
-  }
-  node;
-  return "";
-};
-export const validateExpression = (code, options) => {
-  const { effectful = false, transformIdentifier = (id) => id } = options ?? {};
-  const expression = jsep(code);
-  return generateCode(expression, true, effectful, transformIdentifier);
-};
-const sortTopologically = (list, depsById, explored = /* @__PURE__ */ new Set(), sorted = []) => {
-  for (const id of list) {
-    if (explored.has(id)) {
-      continue;
-    }
-    explored.add(id);
-    const deps = depsById.get(id);
-    if (deps) {
-      sortTopologically(deps, depsById, explored, sorted);
-    }
-    sorted.push(id);
-  }
-  return sorted;
-};
-export const generateComputingExpressions = (expressions, allowedVariables) => {
-  const depsById = /* @__PURE__ */ new Map();
-  const inputVariables = /* @__PURE__ */ new Set();
-  for (const [id, code] of expressions) {
-    const deps = /* @__PURE__ */ new Set();
-    validateExpression(code, {
-      transformIdentifier: (identifier) => {
-        if (allowedVariables.has(identifier)) {
-          inputVariables.add(identifier);
-          return identifier;
-        }
-        if (expressions.has(identifier)) {
-          deps.add(identifier);
-          return identifier;
-        }
-        throw Error(`Unknown dependency "${identifier}"`);
-      }
-    });
-    depsById.set(id, deps);
-  }
-  const sortedExpressions = sortTopologically(
-    new Set(expressions.keys()),
-    depsById
-  );
-  let generatedCode = "";
-  for (const id of inputVariables) {
-    generatedCode += `const ${id} = _variables.get('${id}');
-`;
-  }
-  for (const id of sortedExpressions) {
-    const code = expressions.get(id);
-    if (code === void 0) {
-      continue;
-    }
-    generatedCode += `const ${id} = (${code});
-`;
-  }
-  generatedCode += `return new Map([
-`;
-  for (const id of sortedExpressions) {
-    generatedCode += `  ['${id}', ${id}],
-`;
-  }
-  generatedCode += `]);`;
-  return generatedCode;
-};
-export const executeComputingExpressions = (expressions, variables) => {
-  const generatedCode = generateComputingExpressions(
-    expressions,
-    new Set(variables.keys())
-  );
-  const executeFn = new Function("_variables", generatedCode);
-  const values = executeFn(variables);
-  return values;
-};
-export const generateEffectfulExpression = (code, args, allowedVariables) => {
-  const inputVariables = /* @__PURE__ */ new Set();
-  const outputVariables = /* @__PURE__ */ new Set();
-  validateExpression(code, {
-    effectful: true,
-    transformIdentifier: (identifier, assignee) => {
-      if (args.has(identifier)) {
-        return identifier;
-      }
-      if (allowedVariables.has(identifier)) {
-        if (assignee) {
-          outputVariables.add(identifier);
-        } else {
-          inputVariables.add(identifier);
-        }
-        return identifier;
-      }
-      throw Error(`Unknown dependency "${identifier}"`);
-    }
-  });
-  let generatedCode = "";
-  for (const id of args) {
-    generatedCode += `let ${id} = _args.get('${id}');
-`;
-  }
-  for (const id of inputVariables) {
-    generatedCode += `let ${id} = _variables.get('${id}');
-`;
-  }
-  for (const id of outputVariables) {
-    if (inputVariables.has(id) === false) {
-      generatedCode += `let ${id};
-`;
-    }
-  }
-  generatedCode += `${code};
-`;
-  generatedCode += `return new Map([
-`;
-  for (const id of outputVariables) {
-    generatedCode += `  ['${id}', ${id}],
-`;
-  }
-  generatedCode += `]);`;
-  return generatedCode;
-};
-export const executeEffectfulExpression = (code, args, variables) => {
-  const generatedCode = generateEffectfulExpression(
-    code,
-    new Set(args.keys()),
-    new Set(variables.keys())
-  );
-  const executeFn = new Function("_variables", "_args", generatedCode);
-  const values = executeFn(variables, args);
-  return values;
-};
-const computeExpressionDependencies = (expressions, expressionId, dependencies) => {
-  const depsById = dependencies.get(expressionId);
-  if (depsById) {
-    return depsById;
-  }
-  const parentDeps = /* @__PURE__ */ new Set();
-  const code = expressions.get(expressionId);
-  if (code === void 0) {
-    return parentDeps;
-  }
-  dependencies.set(expressionId, parentDeps);
-  validateExpression(code, {
-    transformIdentifier: (id) => {
-      parentDeps.add(id);
-      const childDeps = computeExpressionDependencies(
-        expressions,
-        id,
-        dependencies
-      );
-      for (const depId of childDeps) {
-        parentDeps.add(depId);
-      }
-      return id;
-    }
-  });
-  return parentDeps;
-};
-export const computeExpressionsDependencies = (expressions) => {
-  const dependencies = /* @__PURE__ */ new Map();
-  for (const id of expressions.keys()) {
-    computeExpressionDependencies(expressions, id, dependencies);
-  }
-  return dependencies;
-};
-const dataSourceVariablePrefix = "$ws$dataSource$";
-export const encodeDataSourceVariable = (id) => {
-  const encoded = id.replaceAll("-", "__DASH__");
-  return `${dataSourceVariablePrefix}${encoded}`;
-};
-export const encodeVariablesMap = (values) => {
-  const encodedValues = /* @__PURE__ */ new Map();
-  for (const [id, value] of values) {
-    encodedValues.set(encodeDataSourceVariable(id), value);
-  }
-  return encodedValues;
-};
-export const decodeDataSourceVariable = (name) => {
-  if (name.startsWith(dataSourceVariablePrefix)) {
-    const encoded = name.slice(dataSourceVariablePrefix.length);
-    return encoded.replaceAll("__DASH__", "-");
-  }
-  return;
-};
-export const decodeVariablesMap = (values) => {
-  const decodedValues = /* @__PURE__ */ new Map();
-  for (const [name, value] of values) {
-    const id = decodeDataSourceVariable(name);
-    if (id !== void 0) {
-      decodedValues.set(id, value);
-    }
-  }
-  return decodedValues;
-};

package/lib/expression.test.js

@@ -1,281 +0,0 @@
-"use strict";
-import { expect, test } from "@jest/globals";
-import {
-  decodeDataSourceVariable,
-  encodeDataSourceVariable,
-  executeComputingExpressions,
-  executeEffectfulExpression,
-  computeExpressionsDependencies,
-  generateComputingExpressions,
-  generateEffectfulExpression,
-  validateExpression
-} from "./expression";
-test("allow literals and array expressions", () => {
-  expect(
-    validateExpression(`["", '', 0, true, false, null, undefined]`)
-  ).toEqual(`["", '', 0, true, false, null, undefined]`);
-});
-test("allow unary and binary expressions", () => {
-  expect(validateExpression(`[-1, 1 + 1]`)).toEqual(`[-1, 1 + 1]`);
-});
-test("optionally allow assignment expressions", () => {
-  expect(() => {
-    validateExpression(`a = 2`);
-  }).toThrowError(/Cannot use assignment in this expression/);
-  expect(validateExpression(`a = 2`, { effectful: true })).toEqual(`a = 2`);
-});
-test("forbid member expressions", () => {
-  expect(() => {
-    validateExpression("var1 + obj.param");
-  }).toThrowError(/Cannot access "param" of "obj"/);
-});
-test("forbid this expressions", () => {
-  expect(() => {
-    validateExpression("var1 + this");
-  }).toThrowError(/"this" is not supported/);
-});
-test("forbid call expressions", () => {
-  expect(() => {
-    validateExpression("var1 + fn1()");
-  }).toThrowError(/Cannot call "fn1"/);
-  expect(() => {
-    validateExpression("var1 + this.fn1()");
-  }).toThrowError(/Cannot call "this.fn1"/);
-});
-test("forbid ternary", () => {
-  expect(() => {
-    validateExpression("var1 ? var2 : var3");
-  }).toThrowError(/Ternary operator is not supported/);
-});
-test("forbid increment and decrement", () => {
-  expect(() => {
-    validateExpression("++var1");
-  }).toThrowError(/"\+\+" operator is not supported/);
-  expect(() => {
-    validateExpression("var1++");
-  }).toThrowError(/"\+\+" operator is not supported/);
-  expect(() => {
-    validateExpression("--var1");
-  }).toThrowError(/"--" operator is not supported/);
-  expect(() => {
-    validateExpression("var1--");
-  }).toThrowError(/"--" operator is not supported/);
-});
-test("forbid multiple expressions", () => {
-  expect(() => {
-    validateExpression("a b");
-  }).toThrowError(/Cannot use multiple expressions/);
-  expect(() => {
-    validateExpression("a, b");
-  }).toThrowError(/Cannot use multiple expressions/);
-  expect(() => {
-    validateExpression("a; b");
-  }).toThrowError(/Cannot use multiple expressions/);
-});
-test("transform identifiers", () => {
-  expect(
-    validateExpression(`a + b`, {
-      transformIdentifier: (id) => `$ws$${id}`
-    })
-  ).toEqual(`$ws$a + $ws$b`);
-});
-test("generate computing expressions", () => {
-  const variables = /* @__PURE__ */ new Set(["var0"]);
-  const expressions = /* @__PURE__ */ new Map([
-    ["exp3", "exp2 + exp1"],
-    ["exp1", "var0"],
-    ["exp2", "exp1"],
-    ["exp4", "exp2"]
-  ]);
-  expect(generateComputingExpressions(expressions, variables)).toMatchInlineSnapshot(`
-    "const var0 = _variables.get('var0');
-    const exp1 = (var0);
-    const exp2 = (exp1);
-    const exp3 = (exp2 + exp1);
-    const exp4 = (exp2);
-    return new Map([
-      ['exp1', exp1],
-      ['exp2', exp2],
-      ['exp3', exp3],
-      ['exp4', exp4],
-    ]);"
-  `);
-});
-test("add only used variables in computing expression", () => {
-  const expressions = /* @__PURE__ */ new Map([["exp1", "var0"]]);
-  expect(generateComputingExpressions(expressions, /* @__PURE__ */ new Set(["var0", "var1"]))).toMatchInlineSnapshot(`
-    "const var0 = _variables.get('var0');
-    const exp1 = (var0);
-    return new Map([
-      ['exp1', exp1],
-    ]);"
-  `);
-});
-test("execute expression", () => {
-  const variables = /* @__PURE__ */ new Map();
-  const expressions = /* @__PURE__ */ new Map([["exp1", "1 + 1"]]);
-  expect(executeComputingExpressions(expressions, variables)).toEqual(
-    /* @__PURE__ */ new Map([["exp1", 2]])
-  );
-});
-test("execute expression dependent on variables", () => {
-  const variables = /* @__PURE__ */ new Map([["var1", 5]]);
-  const expressions = /* @__PURE__ */ new Map([["exp1", "var1 + 1"]]);
-  expect(executeComputingExpressions(expressions, variables)).toEqual(
-    /* @__PURE__ */ new Map([["exp1", 6]])
-  );
-});
-test("execute expression dependent on another expressions", () => {
-  const variables = /* @__PURE__ */ new Map([["var1", 3]]);
-  const expressions = /* @__PURE__ */ new Map([
-    ["exp1", "exp0 + 1"],
-    ["exp0", "var1 + 2"]
-  ]);
-  expect(executeComputingExpressions(expressions, variables)).toEqual(
-    /* @__PURE__ */ new Map([
-      ["exp1", 6],
-      ["exp0", 5]
-    ])
-  );
-});
-test("forbid circular expressions", () => {
-  const variables = /* @__PURE__ */ new Map([["var1", 3]]);
-  const expressions = /* @__PURE__ */ new Map([
-    ["exp0", "exp2 + 1"],
-    ["exp1", "exp0 + 2"],
-    ["exp2", "exp1 + 3"]
-  ]);
-  expect(() => {
-    executeComputingExpressions(expressions, variables);
-  }).toThrowError(/Cannot access 'exp0' before initialization/);
-});
-test("make sure dependency exists", () => {
-  const variables = /* @__PURE__ */ new Map();
-  const expressions = /* @__PURE__ */ new Map([["exp1", "var1 + 1"]]);
-  expect(() => {
-    executeComputingExpressions(expressions, variables);
-  }).toThrowError(/Unknown dependency "var1"/);
-});
-test("encode/decode variable names", () => {
-  expect(encodeDataSourceVariable("my--id")).toEqual(
-    "$ws$dataSource$my__DASH____DASH__id"
-  );
-  expect(decodeDataSourceVariable(encodeDataSourceVariable("my--id"))).toEqual(
-    "my--id"
-  );
-  expect(decodeDataSourceVariable("myVarName")).toEqual(void 0);
-});
-test("generate effectful expression", () => {
-  expect(
-    generateEffectfulExpression(
-      `var0 = var0 + var1`,
-      /* @__PURE__ */ new Set(),
-      /* @__PURE__ */ new Set(["var0", "var1"])
-    )
-  ).toMatchInlineSnapshot(`
-    "let var0 = _variables.get('var0');
-    let var1 = _variables.get('var1');
-    var0 = var0 + var1;
-    return new Map([
-      ['var0', var0],
-    ]);"
-  `);
-  expect(
-    generateEffectfulExpression(
-      `var0 = var1 + 1`,
-      /* @__PURE__ */ new Set(),
-      /* @__PURE__ */ new Set(["var0", "var1"])
-    )
-  ).toMatchInlineSnapshot(`
-    "let var1 = _variables.get('var1');
-    let var0;
-    var0 = var1 + 1;
-    return new Map([
-      ['var0', var0],
-    ]);"
-  `);
-});
-test("add only used variables in effectful expression", () => {
-  expect(
-    generateEffectfulExpression(
-      `var0 = var1 + 1`,
-      /* @__PURE__ */ new Set(),
-      /* @__PURE__ */ new Set(["var0", "var1", "var2"])
-    )
-  ).toMatchInlineSnapshot(`
-    "let var1 = _variables.get('var1');
-    let var0;
-    var0 = var1 + 1;
-    return new Map([
-      ['var0', var0],
-    ]);"
-  `);
-});
-test("support effectful expression arguments", () => {
-  expect(
-    generateEffectfulExpression(
-      `var0 = arg0 + 1`,
-      /* @__PURE__ */ new Set(["arg0"]),
-      /* @__PURE__ */ new Set(["var0"])
-    )
-  ).toMatchInlineSnapshot(`
-    "let arg0 = _args.get('arg0');
-    let var0;
-    var0 = arg0 + 1;
-    return new Map([
-      ['var0', var0],
-    ]);"
-  `);
-});
-test("forbid not allowed variables or arguments in effectful expression", () => {
-  expect(() => {
-    generateEffectfulExpression(
-      `var0 = var0 + var1`,
-      /* @__PURE__ */ new Set(),
-      /* @__PURE__ */ new Set(["var0"])
-    );
-  }).toThrowError(/Unknown dependency "var1"/);
-  expect(() => {
-    generateEffectfulExpression(`var0 = arg0`, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set(["var0"]));
-  }).toThrowError(/Unknown dependency "arg0"/);
-});
-test("execute effectful expression", () => {
-  const variables = /* @__PURE__ */ new Map([
-    ["var0", 2],
-    ["var1", 3]
-  ]);
-  expect(
-    executeEffectfulExpression(`var0 = var0 + var1`, /* @__PURE__ */ new Map(), variables)
-  ).toEqual(/* @__PURE__ */ new Map([["var0", 5]]));
-  expect(
-    executeEffectfulExpression(`arg0 = 5`, /* @__PURE__ */ new Map([["arg0", 0]]), /* @__PURE__ */ new Map())
-  ).toEqual(/* @__PURE__ */ new Map());
-});
-test("compute expressions dependencies", () => {
-  const expressions = /* @__PURE__ */ new Map([
-    ["exp1", `var1`],
-    ["exp2", `exp1 + exp1`],
-    ["exp3", `exp1 + exp2`],
-    ["exp4", `var1 + exp1`]
-  ]);
-  expect(computeExpressionsDependencies(expressions)).toEqual(
-    /* @__PURE__ */ new Map([
-      ["exp4", /* @__PURE__ */ new Set(["var1", "exp1"])],
-      ["exp3", /* @__PURE__ */ new Set(["var1", "exp1", "exp2"])],
-      ["exp2", /* @__PURE__ */ new Set(["var1", "exp1"])],
-      ["exp1", /* @__PURE__ */ new Set(["var1"])]
-    ])
-  );
-});
-test("handle cyclic dependencies", () => {
-  const expressions = /* @__PURE__ */ new Map([
-    ["exp1", `exp2 + var1`],
-    ["exp2", `exp1 + var1`]
-  ]);
-  expect(computeExpressionsDependencies(expressions)).toEqual(
-    /* @__PURE__ */ new Map([
-      ["exp2", /* @__PURE__ */ new Set(["var1", "exp1", "exp2"])],
-      ["exp1", /* @__PURE__ */ new Set(["var1", "exp1", "exp2"])]
-    ])
-  );
-});