@webstudio-is/sdk 0.124.0 → 0.126.0

package/lib/index.js

@@ -32,13 +32,26 @@ var Assets = z.map(AssetId, Asset);
 // src/schema/pages.ts
 import { z as z2 } from "zod";
 var MIN_TITLE_LENGTH = 2;
+var PageId = z2.string();
+var FolderId = z2.string();
+var FolderName = z2.string().refine((value) => value.trim() !== "", "Can't be empty");
+var Slug = z2.string().refine(
+  (path) => /^[-a-z0-9]*$/.test(path),
+  "Only a-z, 0-9 and - are allowed"
+);
+var Folder = z2.object({
+  id: FolderId,
+  name: FolderName,
+  slug: Slug,
+  children: z2.array(z2.union([FolderId, PageId]))
+});
 var PageName = z2.string().refine((value) => value.trim() !== "", "Can't be empty");
 var PageTitle = z2.string().refine(
   (val) => val.length >= MIN_TITLE_LENGTH,
   `Minimum ${MIN_TITLE_LENGTH} characters required`
 );
 var commonPageFields = {
-  id: z2.string(),
+  id: PageId,
   name: PageName,
   title: PageTitle,
   meta: z2.object({
@@ -95,26 +108,32 @@ var Pages = z2.object({
   pages: z2.array(Page).refine(
     (array) => new Set(array.map((page) => page.path)).size === array.length,
     "All paths must be unique"
-  )
+  ),
+  folders: z2.array(Folder).refine((folders) => folders.length > 0, "Folders can't be empty")
 });
 
 // src/schema/instances.ts
 import { z as z3 } from "zod";
-var Text = z3.object({
+var TextChild = z3.object({
   type: z3.literal("text"),
   value: z3.string()
 });
 var InstanceId = z3.string();
-var Id = z3.object({
+var IdChild = z3.object({
   type: z3.literal("id"),
   value: InstanceId
 });
+var ExpressionChild = z3.object({
+  type: z3.literal("expression"),
+  value: z3.string()
+});
+var InstanceChild = z3.union([IdChild, TextChild, ExpressionChild]);
 var Instance = z3.object({
   type: z3.literal("instance"),
   id: InstanceId,
   component: z3.string(),
   label: z3.string().optional(),
-  children: z3.array(z3.union([Id, Text]))
+  children: z3.array(InstanceChild)
 });
 var Instances = z3.map(InstanceId, Instance);
 
@@ -345,6 +364,21 @@ var Deployment = z11.object({
   projectDomain: z11.string()
 });
 
+// src/schema/webstudio.ts
+import { z as z12 } from "zod";
+var WebstudioFragment = z12.object({
+  children: z12.array(InstanceChild),
+  instances: z12.array(Instance),
+  assets: z12.array(Asset),
+  dataSources: z12.array(DataSource),
+  resources: z12.array(Resource),
+  props: z12.array(Prop),
+  breakpoints: z12.array(Breakpoint),
+  styleSourceSelections: z12.array(StyleSourceSelection),
+  styleSources: z12.array(StyleSource),
+  styles: z12.array(StyleDecl)
+});
+
 // src/instances-utils.ts
 var traverseInstances = (instances, instanceId, callback) => {
   const instance = instances.get(instanceId);
@@ -390,6 +424,54 @@ var parseComponentName = (componentName) => {
   return [namespace, name];
 };
 
+// src/page-utils.ts
+var ROOT_FOLDER_ID = "root";
+var isRoot = (folder) => folder.id === ROOT_FOLDER_ID;
+var findPageByIdOrPath = (idOrPath, pages) => {
+  if (idOrPath === "" || idOrPath === "/" || idOrPath === pages.homePage.id) {
+    return pages.homePage;
+  }
+  return pages.pages.find(
+    (page) => page.id === idOrPath || getPagePath(page.id, pages) === idOrPath
+  );
+};
+var findParentFolderByChildId = (id, folders) => {
+  for (const folder of folders) {
+    if (folder.children.includes(id)) {
+      return folder;
+    }
+  }
+};
+var getPagePath = (id, pages) => {
+  const foldersMap = /* @__PURE__ */ new Map();
+  const childParentMap = /* @__PURE__ */ new Map();
+  for (const folder of pages.folders) {
+    foldersMap.set(folder.id, folder);
+    for (const childId of folder.children) {
+      childParentMap.set(childId, folder.id);
+    }
+  }
+  const paths = [];
+  let currentId = id;
+  const allPages = [pages.homePage, ...pages.pages];
+  for (const page of allPages) {
+    if (page.id === id) {
+      paths.push(page.path);
+      currentId = childParentMap.get(page.id);
+      break;
+    }
+  }
+  while (currentId) {
+    const folder = foldersMap.get(currentId);
+    if (folder === void 0) {
+      break;
+    }
+    paths.push(folder.slug);
+    currentId = childParentMap.get(currentId);
+  }
+  return paths.reverse().join("/").replace(/\/+/g, "/");
+};
+
 // src/scope.ts
 var normalizeName = (name) => {
   name = name.replaceAll(/[^\w$]/g, "");
@@ -463,12 +545,16 @@ export {
   DataSourceVariableValue,
   DataSources,
   Deployment,
+  ExpressionChild,
+  Folder,
+  FolderName,
   FontAsset,
   HomePagePath,
-  Id,
+  IdChild,
   ImageAsset,
   ImageMeta,
   Instance,
+  InstanceChild,
   Instances,
   PageName,
   PagePath,
@@ -476,6 +562,7 @@ export {
   Pages,
   Prop,
   Props,
+  ROOT_FOLDER_ID,
   Resource,
   Resources,
   StyleDecl,
@@ -484,12 +571,17 @@ export {
   StyleSourceSelections,
   StyleSources,
   Styles,
-  Text,
+  TextChild,
+  WebstudioFragment,
   createScope,
+  findPageByIdOrPath,
+  findParentFolderByChildId,
   findTreeInstanceIds,
   findTreeInstanceIdsExcludingSlotDescendants,
+  getPagePath,
   getStyleDeclKey,
   initialBreakpoints,
+  isRoot,
   loadResource,
   parseComponentName
 };

package/lib/types/index.d.ts

@@ -9,6 +9,8 @@ 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 "./resource-loader";

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

@@ -2,27 +2,33 @@ import type { Instance } from "./schema/instances";
 export declare const findTreeInstanceIds: (instances: Map<string, {
     type: "instance";
     id: string;
-    component: string;
     children: ({
         value: string;
         type: "text";
     } | {
         value: string;
         type: "id";
+    } | {
+        value: string;
+        type: "expression";
     })[];
+    component: string;
     label?: string | undefined;
 }>, rootInstanceId: Instance["id"]) => Set<string>;
 export declare const findTreeInstanceIdsExcludingSlotDescendants: (instances: Map<string, {
     type: "instance";
     id: string;
-    component: string;
     children: ({
         value: string;
         type: "text";
     } | {
         value: string;
         type: "id";
+    } | {
+        value: string;
+        type: "expression";
     })[];
+    component: string;
     label?: string | undefined;
 }>, rootInstanceId: Instance["id"]) => Set<string>;
 export declare const parseComponentName: (componentName: string) => readonly [string | undefined, string];

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

@@ -0,0 +1,18 @@
+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 isRoot: (folder: Folder) => 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;

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

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

package/lib/types/schema/instances.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-export declare const Text: z.ZodObject<{
+export declare const TextChild: z.ZodObject<{
     type: z.ZodLiteral<"text">;
     value: z.ZodString;
 }, "strip", z.ZodTypeAny, {
@@ -9,8 +9,8 @@ export declare const Text: z.ZodObject<{
     value: string;
     type: "text";
 }>;
-export type Text = z.infer<typeof Text>;
-export declare const Id: z.ZodObject<{
+export type TextChild = z.infer<typeof TextChild>;
+export declare const IdChild: z.ZodObject<{
     type: z.ZodLiteral<"id">;
     value: z.ZodString;
 }, "strip", z.ZodTypeAny, {
@@ -20,7 +20,46 @@ export declare const Id: z.ZodObject<{
     value: string;
     type: "id";
 }>;
-export type Id = z.infer<typeof Id>;
+export type IdChild = z.infer<typeof IdChild>;
+export declare const ExpressionChild: z.ZodObject<{
+    type: z.ZodLiteral<"expression">;
+    value: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    type: "expression";
+}, {
+    value: string;
+    type: "expression";
+}>;
+export type ExpressionChild = z.infer<typeof ExpressionChild>;
+export declare const InstanceChild: z.ZodUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"id">;
+    value: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    type: "id";
+}, {
+    value: string;
+    type: "id";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    value: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    type: "text";
+}, {
+    value: string;
+    type: "text";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"expression">;
+    value: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    type: "expression";
+}, {
+    value: string;
+    type: "expression";
+}>]>;
 export declare const Instance: z.ZodObject<{
     type: z.ZodLiteral<"instance">;
     id: z.ZodString;
@@ -44,30 +83,45 @@ export declare const Instance: z.ZodObject<{
     }, {
         value: string;
         type: "text";
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"expression">;
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        type: "expression";
+    }, {
+        value: string;
+        type: "expression";
     }>]>, "many">;
 }, "strip", z.ZodTypeAny, {
     type: "instance";
     id: string;
-    component: string;
     children: ({
         value: string;
         type: "text";
     } | {
         value: string;
         type: "id";
+    } | {
+        value: string;
+        type: "expression";
     })[];
+    component: string;
     label?: string | undefined;
 }, {
     type: "instance";
     id: string;
-    component: string;
     children: ({
         value: string;
         type: "text";
     } | {
         value: string;
         type: "id";
+    } | {
+        value: string;
+        type: "expression";
     })[];
+    component: string;
     label?: string | undefined;
 }>;
 export type Instance = z.infer<typeof Instance>;
@@ -94,30 +148,45 @@ export declare const Instances: z.ZodMap<z.ZodString, z.ZodObject<{
     }, {
         value: string;
         type: "text";
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"expression">;
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        type: "expression";
+    }, {
+        value: string;
+        type: "expression";
     }>]>, "many">;
 }, "strip", z.ZodTypeAny, {
     type: "instance";
     id: string;
-    component: string;
     children: ({
         value: string;
         type: "text";
     } | {
         value: string;
         type: "id";
+    } | {
+        value: string;
+        type: "expression";
     })[];
+    component: string;
     label?: string | undefined;
 }, {
     type: "instance";
     id: string;
-    component: string;
     children: ({
         value: string;
         type: "text";
     } | {
         value: string;
         type: "id";
+    } | {
+        value: string;
+        type: "expression";
     })[];
+    component: string;
     label?: string | undefined;
 }>>;
 export type Instances = z.infer<typeof Instances>;

package/lib/types/schema/pages.d.ts

@@ -1,4 +1,22 @@
 import { z } from "zod";
+export declare const FolderName: z.ZodEffects<z.ZodString, string, string>;
+export declare const Folder: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodEffects<z.ZodString, string, string>;
+    slug: z.ZodEffects<z.ZodString, string, string>;
+    children: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodString]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    id: string;
+    slug: string;
+    children: string[];
+}, {
+    name: string;
+    id: string;
+    slug: string;
+    children: string[];
+}>;
+export type Folder = z.infer<typeof Folder>;
 export declare const PageName: z.ZodEffects<z.ZodString, string, string>;
 export declare const PageTitle: z.ZodEffects<z.ZodString, string, string>;
 export declare const HomePagePath: z.ZodEffects<z.ZodString, string, string>;
@@ -301,6 +319,32 @@ export declare const Pages: z.ZodObject<{
         rootInstanceId: string;
         pathVariableId?: string | undefined;
     }[]>;
+    folders: z.ZodEffects<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodEffects<z.ZodString, string, string>;
+        slug: z.ZodEffects<z.ZodString, string, string>;
+        children: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodString]>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        id: string;
+        slug: string;
+        children: string[];
+    }, {
+        name: string;
+        id: string;
+        slug: string;
+        children: string[];
+    }>, "many">, {
+        name: string;
+        id: string;
+        slug: string;
+        children: string[];
+    }[], {
+        name: string;
+        id: string;
+        slug: string;
+        children: string[];
+    }[]>;
 }, "strip", z.ZodTypeAny, {
     homePage: {
         path: string;
@@ -338,6 +382,12 @@ export declare const Pages: z.ZodObject<{
         rootInstanceId: string;
         pathVariableId?: string | undefined;
     }[];
+    folders: {
+        name: string;
+        id: string;
+        slug: string;
+        children: string[];
+    }[];
     meta?: {
         siteName?: string | undefined;
         faviconAssetId?: string | undefined;
@@ -383,6 +433,12 @@ export declare const Pages: z.ZodObject<{
         rootInstanceId: string;
         pathVariableId?: string | undefined;
     }[];
+    folders: {
+        name: string;
+        id: string;
+        slug: string;
+        children: string[];
+    }[];
     meta?: {
         siteName?: string | undefined;
         faviconAssetId?: string | undefined;