@supernova-studio/client 0.48.29 → 0.48.30

package/dist/index.mjs

@@ -177,6 +177,12 @@ import { z as z164 } from "zod";
 import { z as z165 } from "zod";
 import { z as z166 } from "zod";
 import { z as z167 } from "zod";
+var __defProp2 = Object.defineProperty;
+var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField2 = (obj, key, value) => {
+  __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 var AssetDeleteScheduleStatus = z.enum(["InProgress", "Pending"]);
 var AssetDeleteSchedule = z.object({
   id: z.string(),
@@ -1789,6 +1795,96 @@ var PageBlockV1 = PageBlockBaseV1.extend({
     () => PageBlockV1.array().nullish().transform((t) => t ?? [])
   )
 });
+function removeCommentSpans(text) {
+  const { spans, ...rest } = text;
+  const newSpans = spans.map((s) => {
+    return {
+      ...s,
+      attributes: s.attributes.filter((a) => a.type !== "Comment")
+    };
+  });
+  const updatedRichText = {
+    ...rest,
+    spans: newSpans
+  };
+  return joinRepeatingSpans(updatedRichText);
+}
+function joinRepeatingSpans(text) {
+  if (text.spans.length < 2)
+    return text;
+  text = sanitizeSpans(text);
+  const { spans, ...rest } = text;
+  let previousSpan = { ...spans[0] };
+  const newSpans = [previousSpan];
+  for (let i = 1; i < spans.length; i++) {
+    const span = spans[i];
+    if (areAttributesEqual(span.attributes, previousSpan.attributes)) {
+      previousSpan.text += span.text;
+    } else {
+      previousSpan = { ...span };
+      newSpans.push(previousSpan);
+    }
+  }
+  return {
+    ...rest,
+    spans: newSpans
+  };
+}
+function areAttributesEqual(lhs, rhs) {
+  if (lhs.length !== rhs.length)
+    return false;
+  const lhsMap = mapByUnique(lhs, (i) => i.type);
+  for (const rhsAttribute of rhs) {
+    const lhsAttribute = lhsMap.get(rhsAttribute.type);
+    if (!deepEqual(lhsAttribute, rhsAttribute))
+      return false;
+  }
+  return true;
+}
+function sanitizeSpans(text) {
+  const { spans, ...rest } = text;
+  return {
+    ...rest,
+    spans: spans.map((s) => {
+      const { attributes, ...rest2 } = s;
+      return {
+        ...rest2,
+        attributes: attributes.map(sanitizeSpanAttribute)
+      };
+    })
+  };
+}
+function sanitizeSpanAttribute(attribute) {
+  switch (attribute.type) {
+    case "Bold":
+      return { type: "Bold" };
+    case "Code":
+      return { type: "Code" };
+    case "Strikethrough":
+      return { type: "Strikethrough" };
+    case "Italic":
+      return { type: "Italic" };
+    case "Comment":
+      const { commentHighlightId, commentIsResolved } = attribute;
+      const isCommentIsResolvedDefined = commentIsResolved !== void 0 && commentIsResolved !== null;
+      return {
+        type: "Comment",
+        ...isCommentIsResolvedDefined && { commentIsResolved },
+        ...commentHighlightId && { commentHighlightId }
+      };
+    case "Link":
+      const { documentationItemId, link, openInNewTab, openInNewWindow } = attribute;
+      const isOpenInNewTabDefined = openInNewTab !== void 0 && openInNewTab !== null;
+      const isOpenInNewWindowDefined = openInNewWindow !== void 0 && openInNewWindow !== null;
+      return {
+        type: "Link",
+        ...isOpenInNewTabDefined && { openInNewTab },
+        ...isOpenInNewWindowDefined && { openInNewWindow },
+        ...documentationItemId && { documentationItemId },
+        ...link && { link }
+      };
+  }
+}
 var PageBlockLinkType = z40.enum(["DocumentationItem", "PageHeading", "Url"]);
 var PageBlockImageType = z40.enum(["Resource", "FigmaNode"]);
 var PageBlockImageAlignment = z40.enum(["Left", "Center", "Stretch"]);
@@ -2614,6 +2710,60 @@ var Theme = DesignElementBase.extend(DesignElementBrandedPart.shape).extend({
   overrides: z82.array(ThemeOverride),
   codeName: z82.string()
 });
+function mapPageBlockItemValuesV2(pageItems, definitionsMap, fn) {
+  traversePageBlockItemsV2(pageItems, (block, item) => {
+    Object.entries(item.props).forEach(([propKey, value]) => {
+      const property = definitionsMap.getDefinitionProperty(block.data.packageId, propKey);
+      if (!property)
+        return;
+      item.props[propKey] = fn(block, item, property, value);
+    });
+  });
+}
+function traversePageBlockItemsV2(pageItems, fn) {
+  traversePageItemsV2(pageItems, (block) => {
+    block.data.items.forEach((item) => {
+      fn(block, item);
+    });
+  });
+}
+function traversePageItemsV2(pageItems, fn) {
+  for (const item of pageItems) {
+    switch (item.type) {
+      case "Block":
+        fn(item);
+        break;
+      case "Section":
+        item.items.forEach((i) => {
+          i.columns.forEach((c) => {
+            traversePageItemsV2(c.blocks, fn);
+          });
+        });
+        break;
+    }
+  }
+}
+var PageBlockDefinitionsMap = class {
+  constructor(definitions) {
+    __publicField2(this, "definitionsMap", /* @__PURE__ */ new Map());
+    __publicField2(this, "propertiesMap", /* @__PURE__ */ new Map());
+    definitions.forEach((d) => {
+      this.definitionsMap.set(d.id, d);
+      d.item.properties.forEach((p) => {
+        this.propertiesMap.set(this.propertyKey(d.id, p.id), p);
+      });
+    });
+  }
+  getDefinition(id) {
+    return this.definitionsMap.get(id);
+  }
+  getDefinitionProperty(defId, propId) {
+    return this.propertiesMap.get(this.propertyKey(defId, propId));
+  }
+  propertyKey(defId, propId) {
+    return `${defId}.${propId}`;
+  }
+};
 var FileStructureStats = z83.object({
   frames: zeroNumberByDefault(),
   components: zeroNumberByDefault(),
@@ -6195,9 +6345,10 @@ var VersionRoomBaseYDoc = class {
 };
 
 // src/yjs/version-room/utils.ts
-function generatePageContentHash(content, debug = false) {
+function generatePageContentHash(content, definitions, debug = false) {
   let sanitizedContent = content;
-  if (isPageContentEmpty(content)) {
+  sanitizedContent = removeCommentSpansFromPage(content, definitions);
+  if (isPageContentEmpty(sanitizedContent)) {
     sanitizedContent = { blocks: [] };
   }
   return generateHash(sanitizedContent, debug);
@@ -6217,6 +6368,27 @@ function isPageContentEmpty(content) {
   const textValue = singleItem.props["text"];
   return !textValue.value.spans.length;
 }
+function removeCommentSpansFromPage(content, definitions) {
+  const defMap = new PageBlockDefinitionsMap(definitions);
+  mapPageBlockItemValuesV2(content.blocks, defMap, (block, item, prop, value) => {
+    if (prop.type === "RichText") {
+      const richTextValue = value;
+      return {
+        ...richTextValue,
+        value: removeCommentSpans(richTextValue.value)
+      };
+    }
+    if (prop.type === "MultiRichText") {
+      const multiRichTextValue = value;
+      return {
+        ...multiRichTextValue,
+        value: multiRichTextValue.value.map(removeCommentSpans)
+      };
+    }
+    return value;
+  });
+  return content;
+}
 
 // src/yjs/version-room/frontend.ts
 var FrontendVersionRoomYDoc = class {
@@ -6454,8 +6626,8 @@ var FrontendVersionRoomYDoc = class {
   //
   // Update page content hash
   //
-  notifyDocumentationPageContentUpdated(pageId, content) {
-    const pageContentHash = generatePageContentHash(content, this.debug);
+  notifyDocumentationPageContentUpdated(pageId, content, definitions) {
+    const pageContentHash = generatePageContentHash(content, definitions, this.debug);
     if (this.debug) {
       console.log(`Will set page content hash: '${pageId}' : '${pageContentHash}'`);
     }