@webstudio-is/react-sdk 0.91.0 → 0.92.0

package/lib/expression.js

@@ -1,3 +1,4 @@
+"use strict";
 import jsep from "jsep";
 import jsepAssignment from "@jsep-plugin/assignment";
 jsep.plugins.register(jsepAssignment);
@@ -134,7 +135,7 @@ const generateCode = (node, failOnForbidden, effectful, transformIdentifier) =>
   node;
   return "";
 };
-const validateExpression = (code, options) => {
+export const validateExpression = (code, options) => {
   const { effectful = false, transformIdentifier = (id) => id } = options ?? {};
   const expression = jsep(code);
   return generateCode(expression, true, effectful, transformIdentifier);
@@ -153,7 +154,7 @@ const sortTopologically = (list, depsById, explored = /* @__PURE__ */ new Set(),
   }
   return sorted;
 };
-const generateComputingExpressions = (expressions, allowedVariables) => {
+export const generateComputingExpressions = (expressions, allowedVariables) => {
   const depsById = /* @__PURE__ */ new Map();
   const inputVariables = /* @__PURE__ */ new Set();
   for (const [id, code] of expressions) {
@@ -199,7 +200,7 @@ const generateComputingExpressions = (expressions, allowedVariables) => {
   generatedCode += `]);`;
   return generatedCode;
 };
-const executeComputingExpressions = (expressions, variables) => {
+export const executeComputingExpressions = (expressions, variables) => {
   const generatedCode = generateComputingExpressions(
     expressions,
     new Set(variables.keys())
@@ -208,7 +209,7 @@ const executeComputingExpressions = (expressions, variables) => {
   const values = executeFn(variables);
   return values;
 };
-const generateEffectfulExpression = (code, args, allowedVariables) => {
+export const generateEffectfulExpression = (code, args, allowedVariables) => {
   const inputVariables = /* @__PURE__ */ new Set();
   const outputVariables = /* @__PURE__ */ new Set();
   validateExpression(code, {
@@ -254,7 +255,7 @@ const generateEffectfulExpression = (code, args, allowedVariables) => {
   generatedCode += `]);`;
   return generatedCode;
 };
-const executeEffectfulExpression = (code, args, variables) => {
+export const executeEffectfulExpression = (code, args, variables) => {
   const generatedCode = generateEffectfulExpression(
     code,
     new Set(args.keys()),
@@ -291,7 +292,7 @@ const computeExpressionDependencies = (expressions, expressionId, dependencies)
   });
   return parentDeps;
 };
-const computeExpressionsDependencies = (expressions) => {
+export const computeExpressionsDependencies = (expressions) => {
   const dependencies = /* @__PURE__ */ new Map();
   for (const id of expressions.keys()) {
     computeExpressionDependencies(expressions, id, dependencies);
@@ -299,25 +300,25 @@ const computeExpressionsDependencies = (expressions) => {
   return dependencies;
 };
 const dataSourceVariablePrefix = "$ws$dataSource$";
-const encodeDataSourceVariable = (id) => {
+export const encodeDataSourceVariable = (id) => {
   const encoded = id.replaceAll("-", "__DASH__");
   return `${dataSourceVariablePrefix}${encoded}`;
 };
-const encodeVariablesMap = (values) => {
+export const encodeVariablesMap = (values) => {
   const encodedValues = /* @__PURE__ */ new Map();
   for (const [id, value] of values) {
     encodedValues.set(encodeDataSourceVariable(id), value);
   }
   return encodedValues;
 };
-const decodeDataSourceVariable = (name) => {
+export const decodeDataSourceVariable = (name) => {
   if (name.startsWith(dataSourceVariablePrefix)) {
     const encoded = name.slice(dataSourceVariablePrefix.length);
     return encoded.replaceAll("__DASH__", "-");
   }
   return;
 };
-const decodeVariablesMap = (values) => {
+export const decodeVariablesMap = (values) => {
   const decodedValues = /* @__PURE__ */ new Map();
   for (const [name, value] of values) {
     const id = decodeDataSourceVariable(name);
@@ -327,15 +328,3 @@ const decodeVariablesMap = (values) => {
   }
   return decodedValues;
 };
-export {
-  computeExpressionsDependencies,
-  decodeDataSourceVariable,
-  decodeVariablesMap,
-  encodeDataSourceVariable,
-  encodeVariablesMap,
-  executeComputingExpressions,
-  executeEffectfulExpression,
-  generateComputingExpressions,
-  generateEffectfulExpression,
-  validateExpression
-};

package/{src/expression.test.ts → lib/expression.test.js}

@@ -1,3 +1,4 @@
+"use strict";
 import { expect, test } from "@jest/globals";
 import {
   decodeDataSourceVariable,
@@ -7,38 +8,32 @@ import {
   computeExpressionsDependencies,
   generateComputingExpressions,
   generateEffectfulExpression,
-  validateExpression,
+  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()");
@@ -47,13 +42,11 @@ test("forbid call expressions", () => {
     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");
@@ -68,7 +61,6 @@ test("forbid increment and decrement", () => {
     validateExpression("var1--");
   }).toThrowError(/"--" operator is not supported/);
 });
-
 test("forbid multiple expressions", () => {
   expect(() => {
     validateExpression("a b");
@@ -80,25 +72,22 @@ test("forbid multiple expressions", () => {
     validateExpression("a; b");
   }).toThrowError(/Cannot use multiple expressions/);
 });
-
 test("transform identifiers", () => {
   expect(
     validateExpression(`a + b`, {
-      transformIdentifier: (id) => `$ws$${id}`,
+      transformIdentifier: (id) => `$ws$${id}`
     })
   ).toEqual(`$ws$a + $ws$b`);
 });
-
 test("generate computing expressions", () => {
-  const variables = new Set(["var0"]);
-  const expressions = new Map([
+  const variables = /* @__PURE__ */ new Set(["var0"]);
+  const expressions = /* @__PURE__ */ new Map([
     ["exp3", "exp2 + exp1"],
     ["exp1", "var0"],
     ["exp2", "exp1"],
-    ["exp4", "exp2"],
+    ["exp4", "exp2"]
   ]);
-  expect(generateComputingExpressions(expressions, variables))
-    .toMatchInlineSnapshot(`
+  expect(generateComputingExpressions(expressions, variables)).toMatchInlineSnapshot(`
     "const var0 = _variables.get('var0');
     const exp1 = (var0);
     const exp2 = (exp1);
@@ -112,11 +101,9 @@ test("generate computing expressions", () => {
     ]);"
   `);
 });
-
 test("add only used variables in computing expression", () => {
-  const expressions = new Map([["exp1", "var0"]]);
-  expect(generateComputingExpressions(expressions, new Set(["var0", "var1"])))
-    .toMatchInlineSnapshot(`
+  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([
@@ -124,57 +111,51 @@ test("add only used variables in computing expression", () => {
     ]);"
   `);
 });
-
 test("execute expression", () => {
-  const variables = new Map();
-  const expressions = new Map([["exp1", "1 + 1"]]);
+  const variables = /* @__PURE__ */ new Map();
+  const expressions = /* @__PURE__ */ new Map([["exp1", "1 + 1"]]);
   expect(executeComputingExpressions(expressions, variables)).toEqual(
-    new Map([["exp1", 2]])
+    /* @__PURE__ */ new Map([["exp1", 2]])
   );
 });
-
 test("execute expression dependent on variables", () => {
-  const variables = new Map([["var1", 5]]);
-  const expressions = new Map([["exp1", "var1 + 1"]]);
+  const variables = /* @__PURE__ */ new Map([["var1", 5]]);
+  const expressions = /* @__PURE__ */ new Map([["exp1", "var1 + 1"]]);
   expect(executeComputingExpressions(expressions, variables)).toEqual(
-    new Map([["exp1", 6]])
+    /* @__PURE__ */ new Map([["exp1", 6]])
   );
 });
-
 test("execute expression dependent on another expressions", () => {
-  const variables = new Map([["var1", 3]]);
-  const expressions = new Map([
+  const variables = /* @__PURE__ */ new Map([["var1", 3]]);
+  const expressions = /* @__PURE__ */ new Map([
     ["exp1", "exp0 + 1"],
-    ["exp0", "var1 + 2"],
+    ["exp0", "var1 + 2"]
   ]);
   expect(executeComputingExpressions(expressions, variables)).toEqual(
-    new Map([
+    /* @__PURE__ */ new Map([
       ["exp1", 6],
-      ["exp0", 5],
+      ["exp0", 5]
     ])
   );
 });
-
 test("forbid circular expressions", () => {
-  const variables = new Map([["var1", 3]]);
-  const expressions = new Map([
+  const variables = /* @__PURE__ */ new Map([["var1", 3]]);
+  const expressions = /* @__PURE__ */ new Map([
     ["exp0", "exp2 + 1"],
     ["exp1", "exp0 + 2"],
-    ["exp2", "exp1 + 3"],
+    ["exp2", "exp1 + 3"]
   ]);
   expect(() => {
     executeComputingExpressions(expressions, variables);
   }).toThrowError(/Cannot access 'exp0' before initialization/);
 });
-
 test("make sure dependency exists", () => {
-  const variables = new Map();
-  const expressions = new Map([["exp1", "var1 + 1"]]);
+  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"
@@ -182,15 +163,14 @@ test("encode/decode variable names", () => {
   expect(decodeDataSourceVariable(encodeDataSourceVariable("my--id"))).toEqual(
     "my--id"
   );
-  expect(decodeDataSourceVariable("myVarName")).toEqual(undefined);
+  expect(decodeDataSourceVariable("myVarName")).toEqual(void 0);
 });
-
 test("generate effectful expression", () => {
   expect(
     generateEffectfulExpression(
       `var0 = var0 + var1`,
-      new Set(),
-      new Set(["var0", "var1"])
+      /* @__PURE__ */ new Set(),
+      /* @__PURE__ */ new Set(["var0", "var1"])
     )
   ).toMatchInlineSnapshot(`
     "let var0 = _variables.get('var0');
@@ -200,12 +180,11 @@ test("generate effectful expression", () => {
       ['var0', var0],
     ]);"
   `);
-
   expect(
     generateEffectfulExpression(
       `var0 = var1 + 1`,
-      new Set(),
-      new Set(["var0", "var1"])
+      /* @__PURE__ */ new Set(),
+      /* @__PURE__ */ new Set(["var0", "var1"])
     )
   ).toMatchInlineSnapshot(`
     "let var1 = _variables.get('var1');
@@ -216,13 +195,12 @@ test("generate effectful expression", () => {
     ]);"
   `);
 });
-
 test("add only used variables in effectful expression", () => {
   expect(
     generateEffectfulExpression(
       `var0 = var1 + 1`,
-      new Set(),
-      new Set(["var0", "var1", "var2"])
+      /* @__PURE__ */ new Set(),
+      /* @__PURE__ */ new Set(["var0", "var1", "var2"])
     )
   ).toMatchInlineSnapshot(`
     "let var1 = _variables.get('var1');
@@ -233,13 +211,12 @@ test("add only used variables in effectful expression", () => {
     ]);"
   `);
 });
-
 test("support effectful expression arguments", () => {
   expect(
     generateEffectfulExpression(
       `var0 = arg0 + 1`,
-      new Set(["arg0"]),
-      new Set(["var0"])
+      /* @__PURE__ */ new Set(["arg0"]),
+      /* @__PURE__ */ new Set(["var0"])
     )
   ).toMatchInlineSnapshot(`
     "let arg0 = _args.get('arg0');
@@ -250,60 +227,55 @@ test("support effectful expression arguments", () => {
     ]);"
   `);
 });
-
 test("forbid not allowed variables or arguments in effectful expression", () => {
   expect(() => {
     generateEffectfulExpression(
       `var0 = var0 + var1`,
-      new Set(),
-      new Set(["var0"])
+      /* @__PURE__ */ new Set(),
+      /* @__PURE__ */ new Set(["var0"])
     );
   }).toThrowError(/Unknown dependency "var1"/);
   expect(() => {
-    generateEffectfulExpression(`var0 = arg0`, new Set(), new Set(["var0"]));
+    generateEffectfulExpression(`var0 = arg0`, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set(["var0"]));
   }).toThrowError(/Unknown dependency "arg0"/);
 });
-
 test("execute effectful expression", () => {
-  const variables = new Map([
+  const variables = /* @__PURE__ */ new Map([
     ["var0", 2],
-    ["var1", 3],
+    ["var1", 3]
   ]);
   expect(
-    executeEffectfulExpression(`var0 = var0 + var1`, new Map(), variables)
-  ).toEqual(new Map([["var0", 5]]));
-
+    executeEffectfulExpression(`var0 = var0 + var1`, /* @__PURE__ */ new Map(), variables)
+  ).toEqual(/* @__PURE__ */ new Map([["var0", 5]]));
   expect(
-    executeEffectfulExpression(`arg0 = 5`, new Map([["arg0", 0]]), new Map())
-  ).toEqual(new Map());
+    executeEffectfulExpression(`arg0 = 5`, /* @__PURE__ */ new Map([["arg0", 0]]), /* @__PURE__ */ new Map())
+  ).toEqual(/* @__PURE__ */ new Map());
 });
-
 test("compute expressions dependencies", () => {
-  const expressions = new Map([
+  const expressions = /* @__PURE__ */ new Map([
     ["exp1", `var1`],
     ["exp2", `exp1 + exp1`],
     ["exp3", `exp1 + exp2`],
-    ["exp4", `var1 + exp1`],
+    ["exp4", `var1 + exp1`]
   ]);
   expect(computeExpressionsDependencies(expressions)).toEqual(
-    new Map([
-      ["exp4", new Set(["var1", "exp1"])],
-      ["exp3", new Set(["var1", "exp1", "exp2"])],
-      ["exp2", new Set(["var1", "exp1"])],
-      ["exp1", new Set(["var1"])],
+    /* @__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 = new Map([
+  const expressions = /* @__PURE__ */ new Map([
     ["exp1", `exp2 + var1`],
-    ["exp2", `exp1 + var1`],
+    ["exp2", `exp1 + var1`]
   ]);
   expect(computeExpressionsDependencies(expressions)).toEqual(
-    new Map([
-      ["exp2", new Set(["var1", "exp1", "exp2"])],
-      ["exp1", new Set(["var1", "exp1", "exp2"])],
+    /* @__PURE__ */ new Map([
+      ["exp2", /* @__PURE__ */ new Set(["var1", "exp1", "exp2"])],
+      ["exp1", /* @__PURE__ */ new Set(["var1", "exp1", "exp2"])]
     ])
   );
 });

package/lib/generator.js

@@ -1,3 +1,4 @@
+"use strict";
 import {
   getIndexesWithinAncestors
 } from "./instance-utils";
@@ -6,7 +7,7 @@ import {
   generateComputingExpressions,
   generateEffectfulExpression
 } from "./expression";
-const generateUtilsExport = (siteData) => {
+export const generateUtilsExport = (siteData) => {
   const indexesWithinAncestors = getIndexesWithinAncestors(
     siteData.metas,
     siteData.instances,
@@ -109,6 +110,3 @@ const generateUtilsExport = (siteData) => {
   /* eslint-enable */
   `;
 };
-export {
-  generateUtilsExport
-};

package/{src/generator.test.ts → lib/generator.test.js}

@@ -1,6 +1,6 @@
+"use strict";
 import { expect, test } from "@jest/globals";
 import { generateUtilsExport } from "./generator";
-
 test("generates utils", () => {
   expect(
     generateUtilsExport({
@@ -10,9 +10,9 @@ test("generates utils", () => {
         name: "",
         title: "",
         meta: {},
-        rootInstanceId: "tabs",
+        rootInstanceId: "tabs"
       },
-      metas: new Map([
+      metas: /* @__PURE__ */ new Map([
         ["Tabs", { type: "container", label: "", icon: "" }],
         [
           "TabsContent",
@@ -20,11 +20,11 @@ test("generates utils", () => {
             type: "container",
             label: "",
             icon: "",
-            indexWithinAncestor: "Tabs",
-          },
-        ],
+            indexWithinAncestor: "Tabs"
+          }
+        ]
       ]),
-      instances: new Map([
+      instances: /* @__PURE__ */ new Map([
         [
           "tabs",
           {
@@ -33,32 +33,30 @@ test("generates utils", () => {
             component: "Tabs",
             children: [
               { type: "id", value: "content1" },
-              { type: "id", value: "content2" },
-            ],
-          },
+              { type: "id", value: "content2" }
+            ]
+          }
         ],
-
         [
           "content1",
           {
             id: "content1",
             type: "instance",
             component: "TabsContent",
-            children: [],
-          },
+            children: []
+          }
         ],
-
         [
           "content2",
           {
             id: "content2",
             type: "instance",
             component: "TabsContent",
-            children: [],
-          },
-        ],
+            children: []
+          }
+        ]
       ]),
-      props: new Map([
+      props: /* @__PURE__ */ new Map([
         [
           "open",
           {
@@ -66,10 +64,9 @@ test("generates utils", () => {
             id: "open",
             instanceId: "tabs",
             name: "open",
-            value: "tabsOpen",
-          },
+            value: "tabsOpen"
+          }
         ],
-
         [
           "onOpenChange",
           {
@@ -81,13 +78,13 @@ test("generates utils", () => {
               {
                 type: "execute",
                 args: ["open"],
-                code: `$ws$dataSource$tabsOpen = open`,
-              },
-            ],
-          },
-        ],
+                code: `$ws$dataSource$tabsOpen = open`
+              }
+            ]
+          }
+        ]
       ]),
-      dataSources: new Map([
+      dataSources: /* @__PURE__ */ new Map([
         [
           "tabsOpen",
           {
@@ -95,10 +92,10 @@ test("generates utils", () => {
             name: "tabsOpen",
             scopeInstanceId: "tabs",
             type: "variable",
-            value: { type: "string", value: "0" },
-          },
-        ],
-      ]),
+            value: { type: "string", value: "0" }
+          }
+        ]
+      ])
     })
   ).toMatchInlineSnapshot(`
 "

package/lib/hook.js

@@ -1,4 +1,5 @@
-const getClosestInstance = (instancePath, currentInstance, closestComponent) => {
+"use strict";
+export const getClosestInstance = (instancePath, currentInstance, closestComponent) => {
   let matched = false;
   for (const instance of instancePath) {
     if (currentInstance === instance) {
@@ -9,6 +10,3 @@ const getClosestInstance = (instancePath, currentInstance, closestComponent) =>
     }
   }
 };
-export {
-  getClosestInstance
-};

package/{src/hook.test.ts → lib/hook.test.js}

@@ -1,13 +1,13 @@
+"use strict";
 import { expect, test } from "@jest/globals";
-import { getClosestInstance, type InstancePath } from ".";
-
+import { getClosestInstance } from ".";
 test("get closest instance", () => {
-  const instancePath: InstancePath = [
+  const instancePath = [
     { type: "instance", id: "4", component: "Content", children: [] },
     { type: "instance", id: "3", component: "Tabs", children: [] },
     { type: "instance", id: "2", component: "Content", children: [] },
     { type: "instance", id: "1", component: "Tabs", children: [] },
-    { type: "instance", id: "0", component: "Body", children: [] },
+    { type: "instance", id: "0", component: "Body", children: [] }
   ];
   const [content2, tabs2, content1, tabs1, _body] = instancePath;
   expect(getClosestInstance(instancePath, content2, "Tabs")).toBe(tabs2);

package/lib/index.js

@@ -1,23 +1,25 @@
+"use strict";
 export * from "./css";
 export * from "./tree";
 export * from "./pubsub";
 export * from "./app";
 export * from "./components/components-utils";
-import {
+export { PropMeta } from "./prop-meta";
+export {
   componentCategories,
   stateCategories,
   defaultStates
 } from "./components/component-meta";
 export * from "./embed-template";
-import {
+export {
   useInstanceProps,
   usePropUrl,
   usePropAsset,
   getInstanceIdFromComponentProps,
   getIndexWithinAncestorFromComponentProps
 } from "./props";
-import { ReactSdkContext } from "./context";
-import {
+export { ReactSdkContext } from "./context";
+export {
   validateExpression,
   generateComputingExpressions,
   executeComputingExpressions,
@@ -29,31 +31,7 @@ import {
   decodeDataSourceVariable,
   decodeVariablesMap
 } from "./expression";
-import { renderComponentTemplate } from "./component-renderer";
-import { getIndexesWithinAncestors } from "./instance-utils";
+export { renderComponentTemplate } from "./component-renderer";
+export { getIndexesWithinAncestors } from "./instance-utils";
 export * from "./hook";
-import { generateUtilsExport } from "./generator";
-export {
-  ReactSdkContext,
-  componentCategories,
-  computeExpressionsDependencies,
-  decodeDataSourceVariable,
-  decodeVariablesMap,
-  defaultStates,
-  encodeDataSourceVariable,
-  encodeVariablesMap,
-  executeComputingExpressions,
-  executeEffectfulExpression,
-  generateComputingExpressions,
-  generateEffectfulExpression,
-  generateUtilsExport,
-  getIndexWithinAncestorFromComponentProps,
-  getIndexesWithinAncestors,
-  getInstanceIdFromComponentProps,
-  renderComponentTemplate,
-  stateCategories,
-  useInstanceProps,
-  usePropAsset,
-  usePropUrl,
-  validateExpression
-};
+export { generateUtilsExport } from "./generator";