@webstudio-is/sdk 0.191.4 → 0.192.0

package/lib/runtime.js

@@ -0,0 +1,101 @@
+// src/resource-loader.ts
+var LOCAL_RESOURCE_PREFIX = "$resources";
+var isLocalResource = (pathname, resourceName) => {
+  const segments = pathname.split("/").filter(Boolean);
+  if (resourceName === void 0) {
+    return segments[0] === LOCAL_RESOURCE_PREFIX;
+  }
+  return segments.join("/") === `${LOCAL_RESOURCE_PREFIX}/${resourceName}`;
+};
+var sitemapResourceUrl = `/${LOCAL_RESOURCE_PREFIX}/sitemap.xml`;
+var loadResource = async (customFetch, resourceRequest) => {
+  const { url, method, headers, body } = resourceRequest;
+  const requestHeaders = new Headers(
+    headers.map(({ name, value }) => [name, value])
+  );
+  const requestInit = {
+    method,
+    headers: requestHeaders
+  };
+  if (method !== "get" && body !== void 0) {
+    if (typeof body === "string") {
+      requestInit.body = body;
+    }
+    if (typeof body === "object") {
+      requestInit.body = JSON.stringify(body);
+    }
+  }
+  try {
+    const response = await customFetch(url.trim(), requestInit);
+    let data = await response.text();
+    try {
+      data = JSON.parse(data);
+    } catch {
+    }
+    if (!response.ok) {
+      console.error(
+        `Failed to load resource: ${url} - ${response.status}: ${JSON.stringify(data).slice(0, 300)}`
+      );
+    }
+    return {
+      ok: response.ok,
+      data,
+      status: response.status,
+      statusText: response.statusText
+    };
+  } catch (error) {
+    console.error(error);
+    const message = error.message;
+    return {
+      ok: false,
+      data: void 0,
+      status: 500,
+      statusText: message
+    };
+  }
+};
+var loadResources = async (customFetch, requests) => {
+  return Object.fromEntries(
+    await Promise.all(
+      Array.from(
+        requests,
+        async ([name, request]) => [name, await loadResource(customFetch, request)]
+      )
+    )
+  );
+};
+
+// src/to-string.ts
+var createJsonStringifyProxy = (target) => {
+  return new Proxy(target, {
+    get(target2, prop, receiver) {
+      if (prop === "toString") {
+        return function() {
+          return JSON.stringify(target2);
+        };
+      }
+      const value = Reflect.get(target2, prop, receiver);
+      if (typeof value === "object" && value !== null) {
+        return createJsonStringifyProxy(value);
+      }
+      return value;
+    }
+  });
+};
+var isPlainObject = (value) => {
+  return Object.prototype.toString.call(value) === "[object Object]" && (Object.getPrototypeOf(value) === null || Object.getPrototypeOf(value) === Object.prototype);
+};
+
+// src/form-fields.ts
+var formIdFieldName = `ws--form-id`;
+var formBotFieldName = `ws--form-bot`;
+export {
+  createJsonStringifyProxy,
+  formBotFieldName,
+  formIdFieldName,
+  isLocalResource,
+  isPlainObject,
+  loadResource,
+  loadResources,
+  sitemapResourceUrl
+};

package/lib/types/__generated__/normalize.css.d.ts

@@ -0,0 +1,57 @@
+import type { StyleProperty, StyleValue } from "@webstudio-is/css-engine";
+type StyleDecl = {
+    state?: string;
+    property: StyleProperty;
+    value: StyleValue;
+};
+export declare const div: StyleDecl[];
+export declare const address: StyleDecl[];
+export declare const article: StyleDecl[];
+export declare const aside: StyleDecl[];
+export declare const figure: StyleDecl[];
+export declare const footer: StyleDecl[];
+export declare const header: StyleDecl[];
+export declare const main: StyleDecl[];
+export declare const nav: StyleDecl[];
+export declare const section: StyleDecl[];
+export declare const form: StyleDecl[];
+export declare const label: StyleDecl[];
+export declare const time: StyleDecl[];
+export declare const h1: StyleDecl[];
+export declare const h2: StyleDecl[];
+export declare const h3: StyleDecl[];
+export declare const h4: StyleDecl[];
+export declare const h5: StyleDecl[];
+export declare const h6: StyleDecl[];
+export declare const i: StyleDecl[];
+export declare const img: StyleDecl[];
+export declare const a: StyleDecl[];
+export declare const li: StyleDecl[];
+export declare const ul: StyleDecl[];
+export declare const ol: StyleDecl[];
+export declare const p: StyleDecl[];
+export declare const span: StyleDecl[];
+export declare const html: StyleDecl[];
+export declare const body: StyleDecl[];
+export declare const hr: StyleDecl[];
+export declare const b: StyleDecl[];
+export declare const strong: StyleDecl[];
+export declare const code: StyleDecl[];
+export declare const kbd: StyleDecl[];
+export declare const samp: StyleDecl[];
+export declare const pre: StyleDecl[];
+export declare const small: StyleDecl[];
+export declare const sub: StyleDecl[];
+export declare const sup: StyleDecl[];
+export declare const table: StyleDecl[];
+export declare const input: StyleDecl[];
+export declare const textarea: StyleDecl[];
+export declare const optgroup: StyleDecl[];
+export declare const radio: StyleDecl[];
+export declare const checkbox: StyleDecl[];
+export declare const button: StyleDecl[];
+export declare const select: StyleDecl[];
+export declare const legend: StyleDecl[];
+export declare const progress: StyleDecl[];
+export declare const summary: StyleDecl[];
+export {};

package/lib/types/expression.d.ts

@@ -0,0 +1,53 @@
+import { type Identifier } from "acorn";
+import type { DataSources } from "./schema/data-sources";
+import type { Scope } from "./scope";
+export type Diagnostic = {
+    from: number;
+    to: number;
+    severity: "error" | "hint" | "info" | "warning";
+    message: string;
+};
+export declare const lintExpression: ({ expression, availableVariables, allowAssignment, }: {
+    expression: string;
+    availableVariables?: Set<Identifier["name"]>;
+    allowAssignment?: boolean;
+}) => Diagnostic[];
+/**
+ * check whether provided expression is a literal value
+ * like "", 0 or { param: "value" }
+ * which does not depends on any variable
+ */
+export declare const isLiteralExpression: (expression: string) => boolean;
+export declare const getExpressionIdentifiers: (expression: string) => Set<string>;
+/**
+ * transpile expression into executable one
+ *
+ * add optional chaining operator to every member expression
+ * to access any field without runtime errors
+ *
+ * replace variable names if necessary
+ */
+export declare const transpileExpression: ({ expression, executable, replaceVariable, }: {
+    expression: string;
+    executable?: boolean;
+    replaceVariable?: (identifier: string, assignee: boolean) => string | undefined | void;
+}) => string;
+/**
+ * parse object expression into key value map
+ * where each value is expression
+ */
+export declare const parseObjectExpression: (expression: string) => Map<string, string>;
+/**
+ * generate key value map into object expression
+ * after updating individual value expressions
+ */
+export declare const generateObjectExpression: (map: Map<string, string>) => string;
+export declare const encodeDataSourceVariable: (id: string) => string;
+export declare const decodeDataSourceVariable: (name: string) => string | undefined;
+export declare const generateExpression: ({ expression, dataSources, usedDataSources, scope, }: {
+    expression: string;
+    dataSources: DataSources;
+    usedDataSources: DataSources;
+    scope: Scope;
+}) => string;
+export declare const executeExpression: (expression: undefined | string) => any;

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

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

package/lib/types/form-fields.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Used to identify form inside server handler
+ */
+export declare const formIdFieldName = "ws--form-id";
+/**
+ * Used for simlpe protection against non js bots
+ */
+export declare const formBotFieldName = "ws--form-bot";

package/lib/types/index.d.ts

@@ -0,0 +1,19 @@
+export * from "./schema/assets";
+export * from "./schema/pages";
+export * from "./schema/instances";
+export * from "./schema/data-sources";
+export * from "./schema/resources";
+export * from "./schema/props";
+export * from "./schema/breakpoints";
+export * from "./schema/style-sources";
+export * from "./schema/style-source-selections";
+export * from "./schema/styles";
+export * from "./schema/deployment";
+export * from "./schema/webstudio";
+export * from "./instances-utils";
+export * from "./page-utils";
+export * from "./scope";
+export * from "./expression";
+export * from "./resources-generator";
+export * from "./page-meta-generator";
+export * from "./url-pattern";

package/lib/types/instances-utils.d.ts

@@ -0,0 +1,5 @@
+import type { Instance, Instances } from "./schema/instances";
+export declare const ROOT_INSTANCE_ID = ":root";
+export declare const findTreeInstanceIds: (instances: Instances, rootInstanceId: Instance["id"]) => Set<string>;
+export declare const findTreeInstanceIdsExcludingSlotDescendants: (instances: Instances, rootInstanceId: Instance["id"]) => Set<string>;
+export declare const parseComponentName: (componentName: string) => readonly [string | undefined, string];

package/lib/types/instances-utils.test.d.ts

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

package/lib/types/jsx.d.ts

@@ -0,0 +1,151 @@
+import type { ReactNode } from "react";
+export declare class ExpressionValue {
+    value: string;
+    constructor(expression: string);
+}
+export declare class ParameterValue {
+    value: string;
+    constructor(dataSourceID: string);
+}
+export declare class ResourceValue {
+    value: string;
+    constructor(resourceId: string);
+}
+export declare class ActionValue {
+    value: {
+        type: "execute";
+        args: string[];
+        code: string;
+    };
+    constructor(args: string[], code: string);
+}
+export declare class AssetValue {
+    value: string;
+    constructor(assetId: string);
+}
+export declare class PageValue {
+    value: string | {
+        pageId: string;
+        instanceId: string;
+    };
+    constructor(pageId: string, instanceId?: string);
+}
+export declare const renderJsx: (root: JSX.Element) => {
+    instances: Map<string, {
+        type: "instance";
+        id: string;
+        children: ({
+            value: string;
+            type: "text";
+            placeholder?: boolean | undefined;
+        } | {
+            value: string;
+            type: "id";
+        } | {
+            value: string;
+            type: "expression";
+        })[];
+        component: string;
+        label?: string | undefined;
+    }>;
+    props: Map<string, {
+        value: number;
+        type: "number";
+        id: string;
+        name: string;
+        instanceId: string;
+        required?: boolean | undefined;
+    } | {
+        value: string;
+        type: "string";
+        id: string;
+        name: string;
+        instanceId: string;
+        required?: boolean | undefined;
+    } | {
+        value: boolean;
+        type: "boolean";
+        id: string;
+        name: string;
+        instanceId: string;
+        required?: boolean | undefined;
+    } | {
+        type: "json";
+        id: string;
+        name: string;
+        instanceId: string;
+        value?: unknown;
+        required?: boolean | undefined;
+    } | {
+        value: string;
+        type: "asset";
+        id: string;
+        name: string;
+        instanceId: string;
+        required?: boolean | undefined;
+    } | {
+        value: (string | {
+            instanceId: string;
+            pageId: string;
+        }) & (string | {
+            instanceId: string;
+            pageId: string;
+        } | undefined);
+        type: "page";
+        id: string;
+        name: string;
+        instanceId: string;
+        required?: boolean | undefined;
+    } | {
+        value: string[];
+        type: "string[]";
+        id: string;
+        name: string;
+        instanceId: string;
+        required?: boolean | undefined;
+    } | {
+        value: string;
+        type: "parameter";
+        id: string;
+        name: string;
+        instanceId: string;
+        required?: boolean | undefined;
+    } | {
+        value: string;
+        type: "resource";
+        id: string;
+        name: string;
+        instanceId: string;
+        required?: boolean | undefined;
+    } | {
+        value: string;
+        type: "expression";
+        id: string;
+        name: string;
+        instanceId: string;
+        required?: boolean | undefined;
+    } | {
+        value: {
+            code: string;
+            type: "execute";
+            args: string[];
+        }[];
+        type: "action";
+        id: string;
+        name: string;
+        instanceId: string;
+        required?: boolean | undefined;
+    }>;
+};
+type ComponentProps = Record<string, unknown> & Record<`${string}:expression`, string> & {
+    "ws:id"?: string;
+    "ws:label"?: string;
+    children?: ReactNode | ExpressionValue;
+};
+type Component = {
+    displayName: string;
+} & ((props: ComponentProps) => ReactNode);
+export declare const createProxy: (prefix: string) => Record<string, Component>;
+export declare const $: Record<string, Component>;
+export declare const ws: Record<string, Component>;
+export {};

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

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

package/lib/types/page-meta-generator.d.ts

@@ -0,0 +1,24 @@
+import type { Asset, Assets } from "./schema/assets";
+import type { DataSources } from "./schema/data-sources";
+import type { Page } from "./schema/pages";
+import { type Scope } from "./scope";
+export type PageMeta = {
+    title: string;
+    description?: string;
+    excludePageFromSearch?: boolean;
+    language?: string;
+    socialImageAssetName?: Asset["name"];
+    socialImageUrl?: string;
+    status?: number;
+    redirect?: string;
+    custom: Array<{
+        property: string;
+        content: string;
+    }>;
+};
+export declare const generatePageMeta: ({ globalScope, page, dataSources, assets, }: {
+    globalScope: Scope;
+    page: Page;
+    dataSources: DataSources;
+    assets: Assets;
+}) => string;

package/lib/types/page-meta-generator.test.d.ts

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

package/lib/types/page-utils.d.ts

@@ -0,0 +1,24 @@
+import type { Folder, Page, Pages } from "./schema/pages";
+export declare const ROOT_FOLDER_ID = "root";
+/**
+ * Returns true if folder is the root folder.
+ */
+export declare const isRootFolder: ({ id }: {
+    id: Folder["id"];
+}) => boolean;
+/**
+ * Find a page by id or path.
+ */
+export declare const findPageByIdOrPath: (idOrPath: string, pages: Pages) => Page | undefined;
+/**
+ * Find a folder that has has that id in the children.
+ */
+export declare const findParentFolderByChildId: (id: Folder["id"] | Page["id"], folders: Array<Folder>) => Folder | undefined;
+/**
+ * Get a path from all folder slugs from root to the current folder or page.
+ */
+export declare const getPagePath: (id: Folder["id"] | Page["id"], pages: Pages) => string;
+export declare const getStaticSiteMapXml: (pages: Pages, updatedAt: string) => {
+    path: string;
+    lastModified: string;
+}[];

package/lib/types/page-utils.test.d.ts

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

package/lib/types/resource-loader.d.ts

@@ -0,0 +1,30 @@
+import type { ResourceRequest } from "./schema/resources";
+/**
+ * Prevents fetch cycles by prefixing local resources.
+ */
+export declare const isLocalResource: (pathname: string, resourceName?: string) => boolean;
+export declare const sitemapResourceUrl = "/$resources/sitemap.xml";
+export declare const loadResource: (customFetch: typeof fetch, resourceRequest: ResourceRequest) => Promise<{
+    ok: boolean;
+    data: string;
+    status: number;
+    statusText: string;
+} | {
+    ok: boolean;
+    data: undefined;
+    status: number;
+    statusText: string;
+}>;
+export declare const loadResources: (customFetch: typeof fetch, requests: Map<string, ResourceRequest>) => Promise<{
+    [k: string]: {
+        ok: boolean;
+        data: string;
+        status: number;
+        statusText: string;
+    } | {
+        ok: boolean;
+        data: undefined;
+        status: number;
+        statusText: string;
+    };
+}>;

package/lib/types/resource-loader.test.d.ts

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

package/lib/types/resources-generator.d.ts

@@ -0,0 +1,22 @@
+import type { DataSources } from "./schema/data-sources";
+import type { Page } from "./schema/pages";
+import type { Resources } from "./schema/resources";
+import type { Props } from "./schema/props";
+import type { Instances } from "./schema/instances";
+import type { Scope } from "./scope";
+export declare const generateResources: ({ scope, page, dataSources, props, resources, }: {
+    scope: Scope;
+    page: Page;
+    dataSources: DataSources;
+    props: Props;
+    resources: Resources;
+}) => string;
+/**
+ * migrate webhook forms to resource action
+ * @todo move to client migrations eventually
+ */
+export declare const replaceFormActionsWithResources: ({ props, instances, resources, }: {
+    props: Props;
+    instances: Instances;
+    resources: Resources;
+}) => void;

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

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

package/lib/types/runtime.d.ts

@@ -0,0 +1,3 @@
+export * from "./resource-loader";
+export * from "./to-string";
+export * from "./form-fields";