@webstudio-is/sdk 0.263.0 → 0.265.0

package/lib/index.js

@@ -97,10 +97,6 @@ var commonPageFields = {
   )
 };
 var HomePagePath = z2.string().refine((path) => path === "", "Home page path must be empty");
-var HomePage = z2.object({
-  ...commonPageFields,
-  path: HomePagePath
-});
 var DefaultPagePage = z2.string().refine((path) => path !== "", "Can't be empty").refine((path) => path !== "/", "Can't be just a /").refine((path) => path.endsWith("/") === false, "Can't end with a /").refine((path) => path.includes("//") === false, "Can't contain repeating /").refine(
   (path) => /^[-_a-z0-9*:?\\/.]*$/.test(path),
   "Only a-z, 0-9, -, _, /, :, ?, . and * are allowed"
@@ -133,7 +129,7 @@ var PagePath = DefaultPagePage.refine(
 );
 var Page = z2.object({
   ...commonPageFields,
-  path: PagePath
+  path: z2.union([HomePagePath, PagePath])
 });
 var ProjectMeta = z2.object({
   // All fields are optional to ensure consistency and allow for the addition of new fields without requiring migration
@@ -163,9 +159,123 @@ var Pages = z2.object({
   meta: ProjectMeta.optional(),
   compiler: CompilerSettings.optional(),
   redirects: z2.array(PageRedirect).optional(),
-  homePage: HomePage,
-  pages: z2.array(Page),
-  folders: z2.array(Folder).refine((folders) => folders.length > 0, "Folders can't be empty")
+  homePageId: PageId,
+  rootFolderId: FolderId,
+  pages: z2.map(PageId, Page),
+  folders: z2.map(FolderId, Folder).refine((folders) => folders.size > 0, "Folders can't be empty")
+}).superRefine((pages, context) => {
+  const homePage = pages.pages.get(pages.homePageId);
+  const rootFolder = pages.folders.get(pages.rootFolderId);
+  if (homePage === void 0) {
+    context.addIssue({
+      code: z2.ZodIssueCode.custom,
+      path: ["homePageId"],
+      message: "Home page must reference an existing page"
+    });
+  }
+  if (rootFolder === void 0) {
+    context.addIssue({
+      code: z2.ZodIssueCode.custom,
+      path: ["rootFolderId"],
+      message: "Root folder must reference an existing folder"
+    });
+  }
+  if (homePage !== void 0 && homePage.path !== "") {
+    context.addIssue({
+      code: z2.ZodIssueCode.custom,
+      path: ["pages", pages.homePageId, "path"],
+      message: "Home page path must be empty"
+    });
+  }
+  for (const [pageId, page] of pages.pages) {
+    if (page.id !== pageId) {
+      context.addIssue({
+        code: z2.ZodIssueCode.custom,
+        path: ["pages", pageId, "id"],
+        message: "Page id must match its record key"
+      });
+    }
+    if (pageId !== pages.homePageId && page.path === "") {
+      context.addIssue({
+        code: z2.ZodIssueCode.custom,
+        path: ["pages", pageId, "path"],
+        message: "Page path can't be empty"
+      });
+    }
+  }
+  for (const [folderId, folder] of pages.folders) {
+    if (folder.id !== folderId) {
+      context.addIssue({
+        code: z2.ZodIssueCode.custom,
+        path: ["folders", folderId, "id"],
+        message: "Folder id must match its record key"
+      });
+    }
+    for (const [index, childId] of folder.children.entries()) {
+      if (pages.pages.has(childId) === false && pages.folders.has(childId) === false) {
+        context.addIssue({
+          code: z2.ZodIssueCode.custom,
+          path: ["folders", folderId, "children", index],
+          message: "Folder child must reference an existing page or folder"
+        });
+      }
+      if (childId === pages.rootFolderId) {
+        context.addIssue({
+          code: z2.ZodIssueCode.custom,
+          path: ["folders", folderId, "children", index],
+          message: "Root folder can't be nested"
+        });
+      }
+    }
+  }
+  if (rootFolder !== void 0 && rootFolder.children[0] !== pages.homePageId) {
+    context.addIssue({
+      code: z2.ZodIssueCode.custom,
+      path: ["folders", pages.rootFolderId, "children"],
+      message: "Root folder must start with the home page"
+    });
+  }
+  const childParents = /* @__PURE__ */ new Map();
+  for (const [folderId, folder] of pages.folders) {
+    for (const [index, childId] of folder.children.entries()) {
+      const parentId = childParents.get(childId);
+      if (parentId !== void 0) {
+        context.addIssue({
+          code: z2.ZodIssueCode.custom,
+          path: ["folders", folderId, "children", index],
+          message: `Child is already registered in folder "${parentId}"`
+        });
+        continue;
+      }
+      childParents.set(childId, folderId);
+    }
+  }
+  const hasFolderCycle = (folderId, path = /* @__PURE__ */ new Set()) => {
+    if (path.has(folderId)) {
+      return true;
+    }
+    const folder = pages.folders.get(folderId);
+    if (folder === void 0) {
+      return false;
+    }
+    path.add(folderId);
+    for (const childId of folder.children) {
+      if (pages.folders.has(childId) && hasFolderCycle(childId, path)) {
+        return true;
+      }
+    }
+    path.delete(folderId);
+    return false;
+  };
+  for (const folderId of pages.folders.keys()) {
+    if (hasFolderCycle(folderId)) {
+      context.addIssue({
+        code: z2.ZodIssueCode.custom,
+        path: ["folders", folderId, "children"],
+        message: "Folders can't contain cycles"
+      });
+    }
+  }
 });
 
 // src/schema/instances.ts
@@ -700,7 +810,8 @@ import { z as z14 } from "zod";
 var common = {
   label: z14.string().optional(),
   description: z14.string().optional(),
-  required: z14.boolean()
+  required: z14.boolean(),
+  contentMode: z14.boolean().optional()
 };
 var Tag = z14.object({
   ...common,
@@ -2364,16 +2475,36 @@ var isAbsoluteUrl = (href) => {
 // src/page-utils.ts
 var ROOT_FOLDER_ID = "root";
 var isRootFolder = ({ id }) => id === ROOT_FOLDER_ID;
+var getPageById = (pages, pageId) => {
+  return pages.pages.get(pageId);
+};
+var getFolderById = (pages, folderId) => {
+  return pages.folders.get(folderId);
+};
+var getAllPages = (pages) => {
+  return Array.from(pages.pages.values());
+};
+var getAllFolders = (pages) => {
+  return Array.from(pages.folders.values());
+};
+var getHomePage = (pages) => {
+  const homePage = getPageById(pages, pages.homePageId);
+  if (homePage === void 0) {
+    throw new Error(`Home page "${pages.homePageId}" was not found.`);
+  }
+  return homePage;
+};
 var findPageByIdOrPath = (idOrPath, pages) => {
-  if (idOrPath === "" || idOrPath === "/" || idOrPath === pages.homePage.id) {
-    return pages.homePage;
+  if (idOrPath === "" || idOrPath === "/" || idOrPath === pages.homePageId) {
+    return getHomePage(pages);
   }
-  return pages.pages.find(
+  return getAllPages(pages).find(
     (page) => page.id === idOrPath || getPagePath(page.id, pages) === idOrPath
   );
 };
 var findParentFolderByChildId = (id, folders) => {
-  for (const folder of folders) {
+  const folderList = folders instanceof Map ? folders.values() : folders;
+  for (const folder of folderList) {
     if (folder.children.includes(id)) {
       return folder;
     }
@@ -2382,7 +2513,7 @@ var findParentFolderByChildId = (id, folders) => {
 var getPagePath = (id, pages) => {
   const foldersMap = /* @__PURE__ */ new Map();
   const childParentMap = /* @__PURE__ */ new Map();
-  for (const folder of pages.folders) {
+  for (const folder of getAllFolders(pages)) {
     foldersMap.set(folder.id, folder);
     for (const childId of folder.children) {
       childParentMap.set(childId, folder.id);
@@ -2390,7 +2521,7 @@ var getPagePath = (id, pages) => {
   }
   const paths = [];
   let currentId = id;
-  const allPages = [pages.homePage, ...pages.pages];
+  const allPages = getAllPages(pages);
   for (const page of allPages) {
     if (page.id === id) {
       paths.push(page.path);
@@ -2409,7 +2540,7 @@ var getPagePath = (id, pages) => {
   return paths.reverse().join("/").replace(/\/+/g, "/");
 };
 var getStaticSiteMapXml = (pages, updatedAt) => {
-  const allPages = [pages.homePage, ...pages.pages];
+  const allPages = getAllPages(pages);
   return allPages.filter((page) => (page.meta.documentType ?? "html") === "html").filter(
     (page) => executeExpression(page.meta.excludePageFromSearch) !== true
   ).filter((page) => false === isPathnamePattern(page.path)).map((page) => ({
@@ -2418,6 +2549,117 @@ var getStaticSiteMapXml = (pages, updatedAt) => {
   }));
 };
 
+// src/migrations/pages.ts
+var toMap = (items, normalizeItem = (item) => item) => {
+  if (items instanceof Map) {
+    return new Map(
+      Array.from(items, ([id, item]) => [id, normalizeItem(item)])
+    );
+  }
+  const list = Array.isArray(items) ? items : Object.values(items);
+  return new Map(list.map((item) => [item.id, normalizeItem(item)]));
+};
+var normalizePage = (page) => ({
+  ...page,
+  meta: page.meta ?? {}
+});
+var isLegacyPages = (pages) => {
+  if (typeof pages !== "object" || pages === null) {
+    return false;
+  }
+  return "homePage" in pages && Array.isArray(pages.pages);
+};
+var isSerializedPages = (pages) => {
+  if (typeof pages !== "object" || pages === null) {
+    return false;
+  }
+  const candidate = pages;
+  return typeof candidate.homePageId === "string" && typeof candidate.rootFolderId === "string" && candidate.pages !== void 0 && candidate.folders !== void 0;
+};
+var serializePages = (pages) => {
+  const parsedPages = Pages.parse(pages);
+  return {
+    meta: parsedPages.meta,
+    compiler: parsedPages.compiler,
+    redirects: parsedPages.redirects,
+    homePageId: parsedPages.homePageId,
+    rootFolderId: parsedPages.rootFolderId,
+    pages: Array.from(parsedPages.pages.values()),
+    folders: Array.from(parsedPages.folders.values())
+  };
+};
+var migratePages = (pages) => {
+  if (isSerializedPages(pages) && pages.pages instanceof Map && pages.folders instanceof Map) {
+    return pages;
+  }
+  if (isSerializedPages(pages)) {
+    return {
+      meta: pages.meta,
+      compiler: pages.compiler,
+      redirects: pages.redirects,
+      homePageId: pages.homePageId,
+      rootFolderId: pages.rootFolderId,
+      pages: toMap(pages.pages, normalizePage),
+      folders: toMap(pages.folders)
+    };
+  }
+  if (isLegacyPages(pages) === false) {
+    throw new Error("Pages data has unsupported shape.");
+  }
+  const homePage = {
+    ...normalizePage(pages.homePage),
+    path: ""
+  };
+  const nextPages = /* @__PURE__ */ new Map([[homePage.id, homePage]]);
+  for (const page of pages.pages) {
+    if (page.id === homePage.id) {
+      continue;
+    }
+    nextPages.set(page.id, normalizePage(page));
+  }
+  const nextFolders = /* @__PURE__ */ new Map();
+  for (const folder of pages.folders ?? []) {
+    nextFolders.set(folder.id, { ...folder, children: [...folder.children] });
+  }
+  const rootFolder = Array.from(nextFolders.values()).find(isRootFolder) ?? pages.folders?.[0] ?? {
+    id: ROOT_FOLDER_ID,
+    name: "Root",
+    slug: "",
+    children: []
+  };
+  if (nextFolders.has(rootFolder.id) === false) {
+    nextFolders.set(rootFolder.id, { ...rootFolder, children: [] });
+  }
+  const nextRootFolder = nextFolders.get(rootFolder.id);
+  if (nextRootFolder === void 0) {
+    throw new Error("Pages must include a root folder.");
+  }
+  for (const folder of nextFolders.values()) {
+    folder.children = folder.children.filter(
+      (childId) => childId !== homePage.id
+    );
+  }
+  nextRootFolder.children.unshift(homePage.id);
+  const referencedIds = new Set(
+    Array.from(nextFolders.values()).flatMap((folder) => folder.children)
+  );
+  for (const page of pages.pages) {
+    if (page.id !== homePage.id && referencedIds.has(page.id) === false) {
+      nextRootFolder.children.push(page.id);
+      referencedIds.add(page.id);
+    }
+  }
+  return {
+    meta: pages.meta,
+    compiler: pages.compiler,
+    redirects: pages.redirects,
+    homePageId: homePage.id,
+    rootFolderId: rootFolder.id,
+    pages: nextPages,
+    folders: nextFolders
+  };
+};
+
 // src/scope.ts
 import reservedIdentifiers from "reserved-identifiers";
 var identifiers = reservedIdentifiers({ includeGlobalProperties: true });
@@ -3008,6 +3250,7 @@ export {
   FONT_EXTENSIONS,
   FileAsset,
   Folder,
+  FolderId,
   FolderName,
   FontAsset,
   HomePagePath,
@@ -3021,6 +3264,7 @@ export {
   Instances,
   MIME_CATEGORIES,
   OldPagePath,
+  PageId,
   PageName,
   PagePath,
   PageRedirect,
@@ -3087,12 +3331,17 @@ export {
   generateObjectExpression,
   generatePageMeta,
   generateResources,
+  getAllFolders,
+  getAllPages,
   getAssetMime,
   getAssetUrl,
   getExpressionIdentifiers,
+  getFolderById,
+  getHomePage,
   getIndexesWithinAncestors,
   getMimeTypeByExtension,
   getMimeTypeByFilename,
+  getPageById,
   getPagePath,
   getStaticSiteMapXml,
   getStyleDeclKey,
@@ -3108,6 +3357,7 @@ export {
   isRootFolder,
   lintExpression,
   matchPathnameParams,
+  migratePages,
   parseComponentName,
   parseObjectExpression,
   portalComponent,
@@ -3115,6 +3365,7 @@ export {
   replaceFormActionsWithResources,
   rootComponent,
   scrollAnimationSchema,
+  serializePages,
   systemParameter,
   tags,
   toRuntimeAsset,

package/lib/migrations/webstudio-data.js

@@ -0,0 +1,163 @@
+// src/page-utils.ts
+var ROOT_FOLDER_ID = "root";
+var isRootFolder = ({ id }) => id === ROOT_FOLDER_ID;
+
+// src/migrations/pages.ts
+var toMap = (items, normalizeItem = (item) => item) => {
+  if (items instanceof Map) {
+    return new Map(
+      Array.from(items, ([id, item]) => [id, normalizeItem(item)])
+    );
+  }
+  const list = Array.isArray(items) ? items : Object.values(items);
+  return new Map(list.map((item) => [item.id, normalizeItem(item)]));
+};
+var normalizePage = (page) => ({
+  ...page,
+  meta: page.meta ?? {}
+});
+var isLegacyPages = (pages) => {
+  if (typeof pages !== "object" || pages === null) {
+    return false;
+  }
+  return "homePage" in pages && Array.isArray(pages.pages);
+};
+var isSerializedPages = (pages) => {
+  if (typeof pages !== "object" || pages === null) {
+    return false;
+  }
+  const candidate = pages;
+  return typeof candidate.homePageId === "string" && typeof candidate.rootFolderId === "string" && candidate.pages !== void 0 && candidate.folders !== void 0;
+};
+var migratePages = (pages) => {
+  if (isSerializedPages(pages) && pages.pages instanceof Map && pages.folders instanceof Map) {
+    return pages;
+  }
+  if (isSerializedPages(pages)) {
+    return {
+      meta: pages.meta,
+      compiler: pages.compiler,
+      redirects: pages.redirects,
+      homePageId: pages.homePageId,
+      rootFolderId: pages.rootFolderId,
+      pages: toMap(pages.pages, normalizePage),
+      folders: toMap(pages.folders)
+    };
+  }
+  if (isLegacyPages(pages) === false) {
+    throw new Error("Pages data has unsupported shape.");
+  }
+  const homePage = {
+    ...normalizePage(pages.homePage),
+    path: ""
+  };
+  const nextPages = /* @__PURE__ */ new Map([[homePage.id, homePage]]);
+  for (const page of pages.pages) {
+    if (page.id === homePage.id) {
+      continue;
+    }
+    nextPages.set(page.id, normalizePage(page));
+  }
+  const nextFolders = /* @__PURE__ */ new Map();
+  for (const folder of pages.folders ?? []) {
+    nextFolders.set(folder.id, { ...folder, children: [...folder.children] });
+  }
+  const rootFolder = Array.from(nextFolders.values()).find(isRootFolder) ?? pages.folders?.[0] ?? {
+    id: ROOT_FOLDER_ID,
+    name: "Root",
+    slug: "",
+    children: []
+  };
+  if (nextFolders.has(rootFolder.id) === false) {
+    nextFolders.set(rootFolder.id, { ...rootFolder, children: [] });
+  }
+  const nextRootFolder = nextFolders.get(rootFolder.id);
+  if (nextRootFolder === void 0) {
+    throw new Error("Pages must include a root folder.");
+  }
+  for (const folder of nextFolders.values()) {
+    folder.children = folder.children.filter(
+      (childId) => childId !== homePage.id
+    );
+  }
+  nextRootFolder.children.unshift(homePage.id);
+  const referencedIds = new Set(
+    Array.from(nextFolders.values()).flatMap((folder) => folder.children)
+  );
+  for (const page of pages.pages) {
+    if (page.id !== homePage.id && referencedIds.has(page.id) === false) {
+      nextRootFolder.children.push(page.id);
+      referencedIds.add(page.id);
+    }
+  }
+  return {
+    meta: pages.meta,
+    compiler: pages.compiler,
+    redirects: pages.redirects,
+    homePageId: homePage.id,
+    rootFolderId: rootFolder.id,
+    pages: nextPages,
+    folders: nextFolders
+  };
+};
+
+// src/migrations/styles.ts
+import { hyphenateProperty, toValue } from "@webstudio-is/css-engine";
+import {
+  camelCaseProperty,
+  expandShorthands,
+  parseCssValue
+} from "@webstudio-is/css-data";
+
+// src/schema/styles.ts
+import { z } from "zod";
+import { StyleValue } from "@webstudio-is/css-engine";
+var StyleDeclRaw = z.object({
+  styleSourceId: z.string(),
+  breakpointId: z.string(),
+  state: z.optional(z.string()),
+  // @todo can't figure out how to make property to be enum
+  property: z.string(),
+  value: StyleValue,
+  listed: z.boolean().optional().describe("Whether the style is from the Advanced panel")
+});
+var StyleDecl = StyleDeclRaw;
+var getStyleDeclKey = (styleDecl) => {
+  return `${styleDecl.styleSourceId}:${styleDecl.breakpointId}:${styleDecl.property}:${styleDecl.state ?? ""}`;
+};
+var Styles = z.map(z.string(), StyleDecl);
+
+// src/migrations/styles.ts
+var migratedShorthands = /* @__PURE__ */ new Set([
+  "overflow",
+  "transition",
+  "white-space",
+  "background-position"
+]);
+var migrateStylesMutable = (styles) => {
+  for (const [styleDeclKey, styleDecl] of styles) {
+    const property = hyphenateProperty(styleDecl.property);
+    if (migratedShorthands.has(property) === false) {
+      continue;
+    }
+    styles.delete(styleDeclKey);
+    const longhands = expandShorthands([[property, toValue(styleDecl.value)]]);
+    for (const [hyphenedProperty, value] of longhands) {
+      const longhandStyleDecl = {
+        ...styleDecl,
+        property: camelCaseProperty(hyphenedProperty),
+        value: parseCssValue(hyphenedProperty, value)
+      };
+      styles.set(getStyleDeclKey(longhandStyleDecl), longhandStyleDecl);
+    }
+  }
+};
+
+// src/migrations/webstudio-data.ts
+var migrateWebstudioDataMutable = (data) => {
+  data.pages = migratePages(data.pages);
+  migrateStylesMutable(data.styles);
+};
+export {
+  migrateWebstudioDataMutable
+};

package/lib/types/index.d.ts

@@ -16,6 +16,7 @@ export * from "./assets";
 export * from "./core-metas";
 export * from "./instances-utils";
 export * from "./page-utils";
+export * from "./migrations";
 export * from "./scope";
 export * from "./expression";
 export * from "./resources-generator";

package/lib/types/migrations/index.d.ts

@@ -0,0 +1 @@
+export * from "./pages";

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

@@ -0,0 +1,7 @@
+import { type Folder, type Page, type Pages } from "../schema/pages";
+export type SerializedPages = Omit<Pages, "pages" | "folders"> & {
+    pages: Page[];
+    folders: Folder[];
+};
+export declare const serializePages: (pages: Pages) => SerializedPages;
+export declare const migratePages: (pages: unknown) => Pages;

package/lib/types/migrations/styles.d.ts

@@ -0,0 +1,2 @@
+import type { Styles } from "../schema/styles";
+export declare const migrateStylesMutable: (styles: Styles) => void;

package/lib/types/migrations/webstudio-data.d.ts

@@ -0,0 +1,8 @@
+import type { WebstudioData } from "../schema/webstudio";
+/**
+ * Normalizes persisted project data after loading.
+ *
+ * This is intentionally idempotent because data can pass through multiple
+ * load boundaries before all callers stop seeing older persisted shapes.
+ */
+export declare const migrateWebstudioDataMutable: (data: WebstudioData) => void;

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

@@ -6,6 +6,11 @@ export declare const ROOT_FOLDER_ID = "root";
 export declare const isRootFolder: ({ id }: {
     id: Folder["id"];
 }) => boolean;
+export declare const getPageById: (pages: Pages, pageId: Page["id"]) => Page | undefined;
+export declare const getFolderById: (pages: Pages, folderId: Folder["id"]) => Folder | undefined;
+export declare const getAllPages: (pages: Pages) => Page[];
+export declare const getAllFolders: (pages: Pages) => Folder[];
+export declare const getHomePage: (pages: Pages) => Page;
 /**
  * Find a page by id or path.
  */
@@ -13,7 +18,7 @@ export declare const findPageByIdOrPath: (idOrPath: string, pages: Pages) => Pag
 /**
  * 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;
+export declare const findParentFolderByChildId: (id: Folder["id"] | Page["id"], folders: Iterable<Folder> | Map<Folder["id"], Folder>) => Folder | undefined;
 /**
  * Get a path from all folder slugs from root to the current folder or page.
  */