@webstudio-is/react-sdk 0.86.0 → 0.87.0

package/lib/cjs/component-renderer.js

@@ -31,19 +31,32 @@ var import_instance_utils = require("./instance-utils");
 const renderComponentTemplate = ({
   name,
   metas: metasRecord,
-  components
+  components,
+  props
 }) => {
   const metas = new Map(Object.entries(metasRecord));
-  const data = (0, import_embed_template.generateDataFromEmbedTemplate)(
-    metas.get(name)?.template ?? [
-      {
-        type: "instance",
-        component: name,
-        children: []
+  const template = metas.get(name)?.template ?? [
+    {
+      type: "instance",
+      component: name,
+      children: []
+    }
+  ];
+  if (template[0].type === "instance" && props !== void 0) {
+    template[0].props = Object.entries(props).map(([prop, value]) => {
+      if (typeof value === "string") {
+        return { type: "string", name: prop, value };
       }
-    ],
-    "base"
-  );
+      if (typeof value === "number") {
+        return { type: "number", name: prop, value };
+      }
+      if (typeof value === "boolean") {
+        return { type: "boolean", name: prop, value };
+      }
+      throw new Error(`Unsupported prop ${props} with value ${value}`);
+    });
+  }
+  const data = (0, import_embed_template.generateDataFromEmbedTemplate)(template, "base");
   const instances = [
     [
       "root",
@@ -95,30 +108,35 @@ const renderComponentTemplate = ({
             ])
           }
         },
-        executeComputingExpressions: (values) => {
-          const expressions = /* @__PURE__ */ new Map();
-          for (const dataSource of data.dataSources) {
-            const name2 = (0, import_expression.encodeDataSourceVariable)(dataSource.id);
-            if (dataSource.type === "expression") {
-              expressions.set(name2, dataSource.code);
+        utils: {
+          indexesWithinAncestors: (0, import_instance_utils.getIndexesWithinAncestors)(
+            metas,
+            new Map(instances),
+            ["root"]
+          ),
+          executeComputingExpressions: (values) => {
+            const expressions = /* @__PURE__ */ new Map();
+            for (const dataSource of data.dataSources) {
+              const name2 = (0, import_expression.encodeDataSourceVariable)(dataSource.id);
+              if (dataSource.type === "expression") {
+                expressions.set(name2, dataSource.code);
+              }
             }
+            return (0, import_expression.decodeVariablesMap)(
+              (0, import_expression.executeComputingExpressions)(
+                expressions,
+                (0, import_expression.encodeVariablesMap)(values)
+              )
+            );
+          },
+          executeEffectfulExpression: (code, args, values) => {
+            return (0, import_expression.decodeVariablesMap)(
+              (0, import_expression.executeEffectfulExpression)(code, args, (0, import_expression.encodeVariablesMap)(values))
+            );
           }
-          return (0, import_expression.decodeVariablesMap)(
-            (0, import_expression.executeComputingExpressions)(expressions, (0, import_expression.encodeVariablesMap)(values))
-          );
-        },
-        executeEffectfulExpression: (code, args, values) => {
-          return (0, import_expression.decodeVariablesMap)(
-            (0, import_expression.executeEffectfulExpression)(code, args, (0, import_expression.encodeVariablesMap)(values))
-          );
         },
         Component: import_tree.WebstudioComponent,
-        components: new Map(Object.entries(components)),
-        indexesWithinAncestors: (0, import_instance_utils.getIndexesWithinAncestors)(
-          metas,
-          new Map(instances),
-          ["root"]
-        )
+        components: new Map(Object.entries(components))
       }
     )
   ] });

package/lib/cjs/components/component-meta.js

@@ -72,7 +72,7 @@ const WsComponentMeta = import_zod.z.object({
   // copied or dragged out of its parent instance
   // true by default
   detachable: import_zod.z.optional(import_zod.z.boolean()),
-  label: import_zod.z.string(),
+  label: import_zod.z.optional(import_zod.z.string()),
   description: import_zod.z.string().optional(),
   icon: import_zod.z.string(),
   presetStyle: import_zod.z.optional(import_zod.z.record(import_zod.z.string(), import_embed_template.EmbedTemplateStyleDecl)),

package/lib/cjs/generator.js

@@ -0,0 +1,128 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var generator_exports = {};
+__export(generator_exports, {
+  generateUtilsExport: () => generateUtilsExport
+});
+module.exports = __toCommonJS(generator_exports);
+var import_instance_utils = require("./instance-utils");
+var import_expression = require("./expression");
+const generateUtilsExport = (siteData) => {
+  const indexesWithinAncestors = (0, import_instance_utils.getIndexesWithinAncestors)(
+    siteData.metas,
+    siteData.instances,
+    [siteData.page.rootInstanceId]
+  );
+  let indexesWithinAncestorsEntries = "";
+  for (const [key, value] of indexesWithinAncestors) {
+    const keyString = JSON.stringify(key);
+    const valueString = JSON.stringify(value);
+    indexesWithinAncestorsEntries += `[${keyString}, ${valueString}],
+`;
+  }
+  const generatedIndexesWithinAncestors = `
+  const indexesWithinAncestors = new Map<string, number>([
+  ${indexesWithinAncestorsEntries}
+  ]);
+  `;
+  const variables = /* @__PURE__ */ new Set();
+  const expressions = /* @__PURE__ */ new Map();
+  for (const dataSource of siteData.dataSources.values()) {
+    if (dataSource.type === "variable") {
+      variables.add((0, import_expression.encodeDataSourceVariable)(dataSource.id));
+    }
+    if (dataSource.type === "expression") {
+      expressions.set((0, import_expression.encodeDataSourceVariable)(dataSource.id), dataSource.code);
+    }
+  }
+  const generatedExecuteComputingExpressions = `
+  const rawExecuteComputingExpressions = (
+    _variables: Map<string, unknown>
+  ): Map<string, unknown> => {
+    ${(0, import_expression.generateComputingExpressions)(expressions, variables)}
+  };
+  const executeComputingExpressions = (variables: Map<string, unknown>) => {
+    const encodedvariables = sdk.encodeVariablesMap(variables);
+    const encodedResult = rawExecuteComputingExpressions(encodedvariables);
+    return sdk.decodeVariablesMap(encodedResult);
+  };
+  `;
+  let effectfulExpressionsEntries = "";
+  for (const prop of siteData.props.values()) {
+    if (prop.type === "action") {
+      for (const executableValue of prop.value) {
+        const codeString = JSON.stringify(executableValue.code);
+        const generatedCode = (0, import_expression.generateEffectfulExpression)(
+          executableValue.code,
+          new Set(executableValue.args),
+          variables
+        );
+        const generatedFunction = `(_args: Map<string, any>, _variables: Map<string, any>) => { ${generatedCode} })`;
+        effectfulExpressionsEntries += `[${codeString}, ${generatedFunction}],
+`;
+      }
+    }
+  }
+  const generatedExecuteEffectfulExpression = `const generatedEffectfulExpressions = new Map<
+    string,
+    (args: Map<string, any>, variables: Map<string, any>) => Map<string, unknown>
+  >([
+  ${effectfulExpressionsEntries}
+  ]);
+
+  const rawExecuteEffectfulExpression = (
+    code: string,
+    args: Map<string, unknown>,
+    variables: Map<string, unknown>
+  ): Map<string, unknown> => {
+    if(generatedEffectfulExpressions.has(code)) {
+      return generatedEffectfulExpressions.get(code)!(args, variables);
+    }
+    console.error("Effectful expression not found", code);
+    throw new Error("Effectful expression not found");
+  };
+
+  const executeEffectfulExpression = (
+    code: string,
+    args: Map<string, unknown>,
+    variables: Map<string, unknown>
+  ) => {
+    const encodedvariables = sdk.encodeVariablesMap(variables);
+    const encodedResult = rawExecuteEffectfulExpression(code, args, encodedvariables);
+    return sdk.decodeVariablesMap(encodedResult);
+  };
+  `;
+  return `
+  /* eslint-disable */
+
+  ${generatedIndexesWithinAncestors.trim()}
+
+  ${generatedExecuteComputingExpressions.trim()}
+
+  ${generatedExecuteEffectfulExpression.trim()}
+
+  export const utils = {
+    indexesWithinAncestors,
+    executeComputingExpressions,
+    executeEffectfulExpression,
+  };
+
+  /* eslint-enable */
+  `;
+};

package/lib/cjs/hook.js

@@ -21,9 +21,9 @@ __export(hook_exports, {
   getClosestInstance: () => getClosestInstance
 });
 module.exports = __toCommonJS(hook_exports);
-const getClosestInstance = (instanceSelection, currentInstance, closestComponent) => {
+const getClosestInstance = (instancePath, currentInstance, closestComponent) => {
   let matched = false;
-  for (const instance of instanceSelection) {
+  for (const instance of instancePath) {
     if (currentInstance === instance) {
       matched = true;
     }

package/lib/cjs/index.js

@@ -31,6 +31,7 @@ __export(src_exports, {
   executeEffectfulExpression: () => import_expression.executeEffectfulExpression,
   generateComputingExpressions: () => import_expression.generateComputingExpressions,
   generateEffectfulExpression: () => import_expression.generateEffectfulExpression,
+  generateUtilsExport: () => import_generator.generateUtilsExport,
   getIndexWithinAncestorFromComponentProps: () => import_props.getIndexWithinAncestorFromComponentProps,
   getIndexesWithinAncestors: () => import_instance_utils.getIndexesWithinAncestors,
   getInstanceIdFromComponentProps: () => import_props.getInstanceIdFromComponentProps,
@@ -55,3 +56,4 @@ var import_expression = require("./expression");
 var import_component_renderer = require("./component-renderer");
 var import_instance_utils = require("./instance-utils");
 __reExport(src_exports, require("./hook"), module.exports);
+var import_generator = require("./generator");

package/lib/cjs/tree/root.js

@@ -29,13 +29,16 @@ var import_webstudio_component = require("./webstudio-component");
 var import_props = require("../props");
 const InstanceRoot = ({
   data,
-  indexesWithinAncestors,
-  executeComputingExpressions,
-  executeEffectfulExpression,
+  utils,
   Component,
   components,
   scripts
 }) => {
+  const {
+    indexesWithinAncestors,
+    executeComputingExpressions,
+    executeEffectfulExpression
+  } = utils;
   const dataSourceVariablesStoreRef = (0, import_react.useRef)(void 0);
   if (dataSourceVariablesStoreRef.current === void 0) {
     dataSourceVariablesStoreRef.current = (0, import_nanostores.atom)(/* @__PURE__ */ new Map());

package/lib/component-renderer.js

@@ -1,6 +1,9 @@
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { getStyleDeclKey } from "@webstudio-is/project-build";
-import { generateDataFromEmbedTemplate } from "./embed-template";
+import {
+  WsEmbedTemplate,
+  generateDataFromEmbedTemplate
+} from "./embed-template";
 import { generateCssText } from "./css";
 import { InstanceRoot, WebstudioComponent } from "./tree";
 import {
@@ -14,19 +17,32 @@ import { getIndexesWithinAncestors } from "./instance-utils";
 const renderComponentTemplate = ({
   name,
   metas: metasRecord,
-  components
+  components,
+  props
 }) => {
   const metas = new Map(Object.entries(metasRecord));
-  const data = generateDataFromEmbedTemplate(
-    metas.get(name)?.template ?? [
-      {
-        type: "instance",
-        component: name,
-        children: []
+  const template = metas.get(name)?.template ?? [
+    {
+      type: "instance",
+      component: name,
+      children: []
+    }
+  ];
+  if (template[0].type === "instance" && props !== void 0) {
+    template[0].props = Object.entries(props).map(([prop, value]) => {
+      if (typeof value === "string") {
+        return { type: "string", name: prop, value };
       }
-    ],
-    "base"
-  );
+      if (typeof value === "number") {
+        return { type: "number", name: prop, value };
+      }
+      if (typeof value === "boolean") {
+        return { type: "boolean", name: prop, value };
+      }
+      throw new Error(`Unsupported prop ${props} with value ${value}`);
+    });
+  }
+  const data = generateDataFromEmbedTemplate(template, "base");
   const instances = [
     [
       "root",
@@ -78,30 +94,35 @@ const renderComponentTemplate = ({
             ])
           }
         },
-        executeComputingExpressions: (values) => {
-          const expressions = /* @__PURE__ */ new Map();
-          for (const dataSource of data.dataSources) {
-            const name2 = encodeDataSourceVariable(dataSource.id);
-            if (dataSource.type === "expression") {
-              expressions.set(name2, dataSource.code);
+        utils: {
+          indexesWithinAncestors: getIndexesWithinAncestors(
+            metas,
+            new Map(instances),
+            ["root"]
+          ),
+          executeComputingExpressions: (values) => {
+            const expressions = /* @__PURE__ */ new Map();
+            for (const dataSource of data.dataSources) {
+              const name2 = encodeDataSourceVariable(dataSource.id);
+              if (dataSource.type === "expression") {
+                expressions.set(name2, dataSource.code);
+              }
             }
+            return decodeVariablesMap(
+              executeComputingExpressions(
+                expressions,
+                encodeVariablesMap(values)
+              )
+            );
+          },
+          executeEffectfulExpression: (code, args, values) => {
+            return decodeVariablesMap(
+              executeEffectfulExpression(code, args, encodeVariablesMap(values))
+            );
           }
-          return decodeVariablesMap(
-            executeComputingExpressions(expressions, encodeVariablesMap(values))
-          );
-        },
-        executeEffectfulExpression: (code, args, values) => {
-          return decodeVariablesMap(
-            executeEffectfulExpression(code, args, encodeVariablesMap(values))
-          );
         },
         Component: WebstudioComponent,
-        components: new Map(Object.entries(components)),
-        indexesWithinAncestors: getIndexesWithinAncestors(
-          metas,
-          new Map(instances),
-          ["root"]
-        )
+        components: new Map(Object.entries(components))
       }
     )
   ] });

package/lib/components/component-meta.js

@@ -46,7 +46,7 @@ const WsComponentMeta = z.object({
   // copied or dragged out of its parent instance
   // true by default
   detachable: z.optional(z.boolean()),
-  label: z.string(),
+  label: z.optional(z.string()),
   description: z.string().optional(),
   icon: z.string(),
   presetStyle: z.optional(z.record(z.string(), EmbedTemplateStyleDecl)),

package/lib/generator.js

@@ -0,0 +1,114 @@
+import {
+  getIndexesWithinAncestors
+} from "./instance-utils";
+import {
+  encodeDataSourceVariable,
+  generateComputingExpressions,
+  generateEffectfulExpression
+} from "./expression";
+const generateUtilsExport = (siteData) => {
+  const indexesWithinAncestors = getIndexesWithinAncestors(
+    siteData.metas,
+    siteData.instances,
+    [siteData.page.rootInstanceId]
+  );
+  let indexesWithinAncestorsEntries = "";
+  for (const [key, value] of indexesWithinAncestors) {
+    const keyString = JSON.stringify(key);
+    const valueString = JSON.stringify(value);
+    indexesWithinAncestorsEntries += `[${keyString}, ${valueString}],
+`;
+  }
+  const generatedIndexesWithinAncestors = `
+  const indexesWithinAncestors = new Map<string, number>([
+  ${indexesWithinAncestorsEntries}
+  ]);
+  `;
+  const variables = /* @__PURE__ */ new Set();
+  const expressions = /* @__PURE__ */ new Map();
+  for (const dataSource of siteData.dataSources.values()) {
+    if (dataSource.type === "variable") {
+      variables.add(encodeDataSourceVariable(dataSource.id));
+    }
+    if (dataSource.type === "expression") {
+      expressions.set(encodeDataSourceVariable(dataSource.id), dataSource.code);
+    }
+  }
+  const generatedExecuteComputingExpressions = `
+  const rawExecuteComputingExpressions = (
+    _variables: Map<string, unknown>
+  ): Map<string, unknown> => {
+    ${generateComputingExpressions(expressions, variables)}
+  };
+  const executeComputingExpressions = (variables: Map<string, unknown>) => {
+    const encodedvariables = sdk.encodeVariablesMap(variables);
+    const encodedResult = rawExecuteComputingExpressions(encodedvariables);
+    return sdk.decodeVariablesMap(encodedResult);
+  };
+  `;
+  let effectfulExpressionsEntries = "";
+  for (const prop of siteData.props.values()) {
+    if (prop.type === "action") {
+      for (const executableValue of prop.value) {
+        const codeString = JSON.stringify(executableValue.code);
+        const generatedCode = generateEffectfulExpression(
+          executableValue.code,
+          new Set(executableValue.args),
+          variables
+        );
+        const generatedFunction = `(_args: Map<string, any>, _variables: Map<string, any>) => { ${generatedCode} })`;
+        effectfulExpressionsEntries += `[${codeString}, ${generatedFunction}],
+`;
+      }
+    }
+  }
+  const generatedExecuteEffectfulExpression = `const generatedEffectfulExpressions = new Map<
+    string,
+    (args: Map<string, any>, variables: Map<string, any>) => Map<string, unknown>
+  >([
+  ${effectfulExpressionsEntries}
+  ]);
+
+  const rawExecuteEffectfulExpression = (
+    code: string,
+    args: Map<string, unknown>,
+    variables: Map<string, unknown>
+  ): Map<string, unknown> => {
+    if(generatedEffectfulExpressions.has(code)) {
+      return generatedEffectfulExpressions.get(code)!(args, variables);
+    }
+    console.error("Effectful expression not found", code);
+    throw new Error("Effectful expression not found");
+  };
+
+  const executeEffectfulExpression = (
+    code: string,
+    args: Map<string, unknown>,
+    variables: Map<string, unknown>
+  ) => {
+    const encodedvariables = sdk.encodeVariablesMap(variables);
+    const encodedResult = rawExecuteEffectfulExpression(code, args, encodedvariables);
+    return sdk.decodeVariablesMap(encodedResult);
+  };
+  `;
+  return `
+  /* eslint-disable */
+
+  ${generatedIndexesWithinAncestors.trim()}
+
+  ${generatedExecuteComputingExpressions.trim()}
+
+  ${generatedExecuteEffectfulExpression.trim()}
+
+  export const utils = {
+    indexesWithinAncestors,
+    executeComputingExpressions,
+    executeEffectfulExpression,
+  };
+
+  /* eslint-enable */
+  `;
+};
+export {
+  generateUtilsExport
+};

package/lib/hook.js

@@ -1,6 +1,6 @@
-const getClosestInstance = (instanceSelection, currentInstance, closestComponent) => {
+const getClosestInstance = (instancePath, currentInstance, closestComponent) => {
   let matched = false;
-  for (const instance of instanceSelection) {
+  for (const instance of instancePath) {
     if (currentInstance === instance) {
       matched = true;
     }

package/lib/index.js

@@ -32,6 +32,7 @@ import {
 import { renderComponentTemplate } from "./component-renderer";
 import { getIndexesWithinAncestors } from "./instance-utils";
 export * from "./hook";
+import { generateUtilsExport } from "./generator";
 export {
   ReactSdkContext,
   componentCategories,
@@ -45,6 +46,7 @@ export {
   executeEffectfulExpression,
   generateComputingExpressions,
   generateEffectfulExpression,
+  generateUtilsExport,
   getIndexWithinAncestorFromComponentProps,
   getIndexesWithinAncestors,
   getInstanceIdFromComponentProps,

package/lib/tree/root.js

@@ -14,13 +14,16 @@ import {
 import { getPropsByInstanceId } from "../props";
 const InstanceRoot = ({
   data,
-  indexesWithinAncestors,
-  executeComputingExpressions,
-  executeEffectfulExpression,
+  utils,
   Component,
   components,
   scripts
 }) => {
+  const {
+    indexesWithinAncestors,
+    executeComputingExpressions,
+    executeEffectfulExpression
+  } = utils;
   const dataSourceVariablesStoreRef = useRef(void 0);
   if (dataSourceVariablesStoreRef.current === void 0) {
     dataSourceVariablesStoreRef.current = atom(/* @__PURE__ */ new Map());

package/lib/types/component-renderer.d.ts

@@ -1,8 +1,9 @@
 import type { ExoticComponent } from "react";
 import type { Instance } from "@webstudio-is/project-build";
 import type { WsComponentMeta } from "./components/component-meta";
-export declare const renderComponentTemplate: ({ name, metas: metasRecord, components, }: {
+export declare const renderComponentTemplate: ({ name, metas: metasRecord, components, props, }: {
     name: Instance["component"];
     metas: Record<string, WsComponentMeta>;
+    props?: Record<string, unknown> | undefined;
     components: Record<string, ExoticComponent<any>>;
 }) => import("react/jsx-runtime").JSX.Element;

package/lib/types/components/component-meta.d.ts

@@ -678,7 +678,7 @@ declare const WsComponentMeta: z.ZodObject<{
     indexWithinAncestor: z.ZodOptional<z.ZodString>;
     stylable: z.ZodOptional<z.ZodBoolean>;
     detachable: z.ZodOptional<z.ZodBoolean>;
-    label: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodString>;
     icon: z.ZodString;
     presetStyle: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<{
@@ -1132,7 +1132,6 @@ declare const WsComponentMeta: z.ZodObject<{
     order: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     type: "embed" | "control" | "container" | "rich-text-child";
-    label: string;
     icon: string;
     category?: "text" | "hidden" | "general" | "media" | "forms" | "radix" | undefined;
     requiredAncestors?: string[] | undefined;
@@ -1140,6 +1139,7 @@ declare const WsComponentMeta: z.ZodObject<{
     indexWithinAncestor?: string | undefined;
     stylable?: boolean | undefined;
     detachable?: boolean | undefined;
+    label?: string | undefined;
     description?: string | undefined;
     presetStyle?: Record<string, {
         value: {
@@ -1366,7 +1366,6 @@ declare const WsComponentMeta: z.ZodObject<{
     order?: number | undefined;
 }, {
     type: "embed" | "control" | "container" | "rich-text-child";
-    label: string;
     icon: string;
     category?: "text" | "hidden" | "general" | "media" | "forms" | "radix" | undefined;
     requiredAncestors?: string[] | undefined;
@@ -1374,6 +1373,7 @@ declare const WsComponentMeta: z.ZodObject<{
     indexWithinAncestor?: string | undefined;
     stylable?: boolean | undefined;
     detachable?: boolean | undefined;
+    label?: string | undefined;
     description?: string | undefined;
     presetStyle?: Record<string, {
         value: {

package/lib/types/embed-template.d.ts

@@ -2539,7 +2539,7 @@ export declare const generateDataFromEmbedTemplate: (treeTemplate: ({
 export type EmbedTemplateData = ReturnType<typeof generateDataFromEmbedTemplate>;
 export declare const namespaceMeta: (meta: WsComponentMeta, namespace: string, components: Set<EmbedTemplateInstance["component"]>) => {
     type: "embed" | "control" | "container" | "rich-text-child";
-    label: string;
+    label?: string | undefined;
     order?: number | undefined;
     template?: ({
         type: "text";

package/lib/types/generator.d.ts

@@ -0,0 +1,23 @@
+import type { DataSources, Instance, Instances, Page, Props } from "@webstudio-is/project-build";
+import type { WsComponentMeta } from "./components/component-meta";
+import { type IndexesWithinAncestors } from "./instance-utils";
+import type { DataSourceValues } from "./context";
+type PageData = {
+    page: Page;
+    metas: Map<Instance["component"], WsComponentMeta>;
+    instances: Instances;
+    props: Props;
+    dataSources: DataSources;
+};
+export type GeneratedUtils = {
+    indexesWithinAncestors: IndexesWithinAncestors;
+    executeComputingExpressions: (values: DataSourceValues) => DataSourceValues;
+    executeEffectfulExpression: (expression: string, args: DataSourceValues, values: DataSourceValues) => DataSourceValues;
+};
+/**
+ * Generates data based utilities at build time
+ * Requires this import statement in scope
+ * import * as sdk from "@webstudio-is/react-sdk";
+ */
+export declare const generateUtilsExport: (siteData: PageData) => string;
+export {};

package/lib/types/generator.test.d.ts

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