Skip to content

Open source website builder and Webflow alternative. Webstudio is an advanced visual builder that connects to any headless CMS, supports all CSS properties, and can be hosted anywhere, including with us.

Add expression utilities (#1874)

Bogdan Chadkin37aed7edfaf8
diff --git a/packages/react-sdk/package.json b/packages/react-sdk/package.json
index 4b7b279449..d81cfbc45e 100644
--- a/packages/react-sdk/package.json
+++ b/packages/react-sdk/package.json
@@ -45,6 +45,7 @@
"@webstudio-is/project-build": "workspace:^",
"detect-font": "^0.1.5",
"html-tags": "^3.2.0",
+ "jsep": "^1.3.8",
"nanoevents": "^7.0.1",
"nanoid": "^3.3.6",
"nanostores": "^0.7.1"
diff --git a/packages/react-sdk/src/expression.test.ts b/packages/react-sdk/src/expression.test.ts
new file mode 100644
index 0000000000..5bf9655ccb
--- /dev/null
+++ b/packages/react-sdk/src/expression.test.ts
@@ -0,0 +1,92 @@
+import { expect, test } from "@jest/globals";
+import { executeExpression, 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("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 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`, (id) => `$ws$${id}`)).toEqual(
+ `$ws$a + $ws$b`
+ );
+});
+
+test("execute expression", () => {
+ const variables = new Map();
+ const expressions = new Map([["exp1", "1 + 1"]]);
+ expect(executeExpression("exp1", variables, expressions)).toEqual(2);
+});
+
+test("execute expression dependent on variables", () => {
+ const variables = new Map([["var1", 5]]);
+ const expressions = new Map([["exp1", "var1 + 1"]]);
+ expect(executeExpression("exp1", variables, expressions)).toEqual(6);
+});
+
+test("execute expression dependent on other expressions", () => {
+ const variables = new Map([["var1", 3]]);
+ const expressions = new Map([
+ ["exp1", "exp0 + 1"],
+ ["exp0", "var1 + 2"],
+ ]);
+ expect(executeExpression("exp1", variables, expressions)).toEqual(6);
+});
+
+test("forbid circular expressions", () => {
+ const variables = new Map([["var1", 3]]);
+ const expressions = new Map([
+ ["exp0", "exp2 + 1"],
+ ["exp1", "exp0 + 2"],
+ ["exp2", "exp1 + 3"],
+ ]);
+ expect(() => {
+ executeExpression("exp1", variables, expressions);
+ }).toThrowError(/exp2 is not defined/);
+});
+
+test("make sure dependency exists", () => {
+ const variables = new Map();
+ const expressions = new Map([["exp1", "var1 + 1"]]);
+ expect(() => {
+ executeExpression("exp1", variables, expressions);
+ }).toThrowError(/Unknown dependency "var1"/);
+});
diff --git a/packages/react-sdk/src/expression.ts b/packages/react-sdk/src/expression.ts
new file mode 100644
index 0000000000..4b5cf129bb
--- /dev/null
+++ b/packages/react-sdk/src/expression.ts
@@ -0,0 +1,160 @@
+import jsep from "jsep";
+
+type TransformIdentifier = (id: string) => string;
+
+type Node = jsep.CoreExpression;
+
+const generateCode = (
+ node: Node,
+ failOnForbidden: boolean,
+ transformIdentifier: TransformIdentifier
+): string => {
+ if (node.type === "Identifier") {
+ return transformIdentifier(node.name);
+ }
+ if (node.type === "MemberExpression") {
+ if (failOnForbidden) {
+ const object = generateCode(
+ node.object as Node,
+ false,
+ transformIdentifier
+ );
+ const property = generateCode(
+ node.property as Node,
+ false,
+ transformIdentifier
+ );
+ throw Error(`Cannot access "${property}" of "${object}"`);
+ }
+ const object = generateCode(
+ node.object as Node,
+ failOnForbidden,
+ transformIdentifier
+ );
+ const property = generateCode(
+ node.property as Node,
+ failOnForbidden,
+ transformIdentifier
+ );
+ return `${object}.${property}`;
+ }
+ if (node.type === "Literal") {
+ return node.raw;
+ }
+ if (node.type === "UnaryExpression") {
+ const arg = generateCode(
+ node.argument as Node,
+ failOnForbidden,
+ transformIdentifier
+ );
+ return `${node.operator}${arg}`;
+ }
+ if (node.type === "BinaryExpression") {
+ const left = generateCode(
+ node.left as Node,
+ failOnForbidden,
+ transformIdentifier
+ );
+ const right = generateCode(
+ node.right as Node,
+ failOnForbidden,
+ transformIdentifier
+ );
+ return `${left} ${node.operator} ${right}`;
+ }
+ if (node.type === "ArrayExpression") {
+ const elements = node.elements.map((element) =>
+ generateCode(element as Node, failOnForbidden, transformIdentifier)
+ );
+ return `[${elements.join(", ")}]`;
+ }
+ if (node.type === "CallExpression") {
+ if (failOnForbidden) {
+ const callee = generateCode(
+ node.callee as Node,
+ false,
+ transformIdentifier
+ );
+ throw Error(`Cannot call "${callee}"`);
+ }
+ const callee = generateCode(
+ node.callee as Node,
+ failOnForbidden,
+ transformIdentifier
+ );
+ const args = node.arguments.map((arg) =>
+ generateCode(arg as Node, failOnForbidden, transformIdentifier)
+ );
+ return `${callee}(${args.join(", ")})`;
+ }
+ if (node.type === "ThisExpression") {
+ if (failOnForbidden) {
+ throw Error(`"this" is not supported`);
+ }
+ return "this";
+ }
+ if (node.type === "Compound") {
+ throw Error("Cannot use multiple expressions");
+ }
+ // plugin is not added
+ node.type satisfies "ConditionalExpression";
+ return "";
+};
+
+export const validateExpression = (
+ code: string,
+ transformIdentifier: TransformIdentifier = (id) => id
+) => {
+ const expression = jsep(code) as Node;
+ return generateCode(expression, true, transformIdentifier);
+};
+
+export const executeExpression = (
+ expressionId: string,
+ variables: Map<string, unknown>,
+ expressions: Map<string, string>
+) => {
+ const depsById = new Map<string, Set<string>>();
+ for (const [id, code] of expressions) {
+ const deps = new Set<string>();
+ validateExpression(code, (identifier) => {
+ if (variables.has(identifier) || expressions.has(identifier)) {
+ deps.add(identifier);
+ return identifier;
+ }
+ throw Error(`Unknown dependency "${identifier}"`);
+ });
+ depsById.set(id, deps);
+ }
+
+ // sort topologically
+ const sortedExpressions = Array.from(expressions.keys()).sort(
+ (left, right) => {
+ if (depsById.get(left)?.has(right)) {
+ return 1;
+ }
+ if (depsById.get(right)?.has(left)) {
+ return -1;
+ }
+ return 0;
+ }
+ );
+
+ // execute chain of expressions
+ let header = "";
+ for (const [id, value] of variables) {
+ header += `const ${id} = ${JSON.stringify(value)};\n`;
+ }
+ for (const id of sortedExpressions) {
+ const code = expressions.get(id);
+ if (code === undefined) {
+ continue;
+ }
+ const executeFn = new Function(`${header}\nreturn (${code});`);
+ const value = executeFn();
+ header += `const ${id} = ${JSON.stringify(value)};\n`;
+ if (id === expressionId) {
+ return value;
+ }
+ }
+};
diff --git a/packages/react-sdk/src/index.ts b/packages/react-sdk/src/index.ts
index a05dbf6940..676b13309d 100644
--- a/packages/react-sdk/src/index.ts
+++ b/packages/react-sdk/src/index.ts
@@ -20,3 +20,4 @@ export {
getInstanceIdFromComponentProps,
} from "./props";
export { type Params, ReactSdkContext } from "./context";
+export { validateExpression, executeExpression } from "./expression";
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 762e91cdc8..39d52a807e 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -1214,6 +1214,9 @@ importers:
html-tags:
specifier: ^3.2.0
version: 3.2.0
+ jsep:
+ specifier: ^1.3.8
+ version: 1.3.8
nanoevents:
specifier: ^7.0.1
version: 7.0.1
@@ -13106,6 +13109,11 @@ packages:
transitivePeerDependencies:
- supports-color
+ resolution: {integrity: sha512-qofGylTGgYj9gZFsHuyWAN4jr35eJ66qJCK4eKDnldohuUoQFbU3iZn2zjvEbd9wOAhP9Wx5DsAAduTyE1PSWQ==}
+ engines: {node: '>= 10.16.0'}
+ dev: false
+
resolution: {integrity: sha512-uZz5UnB7u4T9LvwmFqXii7pZSouaRPorGs5who1Ip7VO0wxanFvBL7GkM6dTHlgX+jhBApRetaWpnDabOeTcnA==}
hasBin: true