@webstudio-is/sdk 0.125.0 → 0.126.0

package/lib/index.js

@@ -35,14 +35,14 @@ 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 FolderSlug = z2.string().refine((slug) => slug !== "", "Can't be empty").refine((slug) => slug.includes("/") === false, "Can't contain a /").refine(
+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: z2.string(),
+  slug: Slug,
   children: z2.array(z2.union([FolderId, PageId]))
 });
 var PageName = z2.string().refine((value) => value.trim() !== "", "Can't be empty");
@@ -127,12 +127,13 @@ 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([IdChild, TextChild, ExpressionChild]))
+  children: z3.array(InstanceChild)
 });
 var Instances = z3.map(InstanceId, Instance);
 
@@ -363,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);
@@ -408,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, "");
@@ -484,13 +548,13 @@ export {
   ExpressionChild,
   Folder,
   FolderName,
-  FolderSlug,
   FontAsset,
   HomePagePath,
   IdChild,
   ImageAsset,
   ImageMeta,
   Instance,
+  InstanceChild,
   Instances,
   PageName,
   PagePath,
@@ -498,6 +562,7 @@ export {
   Pages,
   Prop,
   Props,
+  ROOT_FOLDER_ID,
   Resource,
   Resources,
   StyleDecl,
@@ -507,11 +572,16 @@ export {
   StyleSources,
   Styles,
   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/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

@@ -32,6 +32,34 @@ export declare const ExpressionChild: z.ZodObject<{
     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;

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

@@ -1,10 +1,9 @@
 import { z } from "zod";
 export declare const FolderName: z.ZodEffects<z.ZodString, string, string>;
-export declare const FolderSlug: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>;
 export declare const Folder: z.ZodObject<{
     id: z.ZodString;
     name: z.ZodEffects<z.ZodString, string, string>;
-    slug: z.ZodString;
+    slug: z.ZodEffects<z.ZodString, string, string>;
     children: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodString]>, "many">;
 }, "strip", z.ZodTypeAny, {
     name: string;
@@ -323,7 +322,7 @@ export declare const Pages: z.ZodObject<{
     folders: z.ZodEffects<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         name: z.ZodEffects<z.ZodString, string, string>;
-        slug: z.ZodString;
+        slug: z.ZodEffects<z.ZodString, string, string>;
         children: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodString]>, "many">;
     }, "strip", z.ZodTypeAny, {
         name: string;