@supernova-studio/model 0.48.27 → 0.48.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supernova-studio/model",
-  "version": "0.48.27",
+  "version": "0.48.29",
   "description": "Supernova Data Models",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -32,9 +32,11 @@
   "dependencies": {
     "@sindresorhus/slugify": "1.1.2",
     "ip-cidr": "3.1.0",
-    "zod": "3.23.6"
+    "zod": "3.23.6",
+    "deep-equal": "2.2.3"
   },
   "devDependencies": {
+    "@types/deep-equal": "1.0.4",
     "fs": "0.0.1-security",
     "tsup": "8.0.2",
     "typescript": "5.0.4"

package/src/dsm/elements/data/documentation-block-v1.ts

@@ -1,5 +1,7 @@
+import deepEqual from "deep-equal";
 import { z } from "zod";
 import { nullishToOptional } from "../../../helpers";
+import { mapByUnique } from "../../../utils";
 import { ColorTokenInlineData } from "../../properties";
 import { Size } from "../primitives";
 import { DesignTokenType } from "../raw-element";
@@ -210,14 +212,20 @@ export const PageBlockTableProperties = z.object({
   columns: z.array(PageBlockTableColumn),
 });
 
-export const PageBlockTextSpanAttributeType = z.enum(["Bold", "Italic", "Link", "Strikethrough", "Code"]);
+export const PageBlockTextSpanAttributeType = z.enum(["Bold", "Italic", "Link", "Strikethrough", "Code", "Comment"]);
 
 export const PageBlockTextSpanAttribute = z.object({
   type: PageBlockTextSpanAttributeType,
+
+  // Link attributes
   link: nullishToOptional(z.string()),
   documentationItemId: nullishToOptional(z.string()),
   openInNewWindow: nullishToOptional(z.boolean()), // deprecated. use openInNewTab
   openInNewTab: nullishToOptional(z.boolean()),
+
+  // Comment attributes
+  commentHighlightId: nullishToOptional(z.string()),
+  commentIsResolved: nullishToOptional(z.boolean()),
 });
 
 export const PageBlockTextSpan = z.object({
@@ -353,3 +361,109 @@ export function traversePageBlocksV1(blocks: PageBlockV1[], action: (block: Page
     traversePageBlocksV1(block.children, action);
   }
 }
+
+export function removeCommentSpans(text: PageBlockText): PageBlockText {
+  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);
+}
+
+export function joinRepeatingSpans(text: PageBlockText): PageBlockText {
+  if (text.spans.length < 2) return text;
+
+  // Make sure spans are clean before comparing them
+  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: PageBlockTextSpanAttribute[], rhs: PageBlockTextSpanAttribute[]) {
+  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: PageBlockText): PageBlockText {
+  const { spans, ...rest } = text;
+
+  return {
+    ...rest,
+    spans: spans.map(s => {
+      const { attributes, ...rest } = s;
+
+      return {
+        ...rest,
+        attributes: attributes.map(sanitizeSpanAttribute),
+      };
+    }),
+  };
+}
+
+function sanitizeSpanAttribute(attribute: PageBlockTextSpanAttribute): PageBlockTextSpanAttribute {
+  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 !== undefined && commentIsResolved !== null;
+
+      return {
+        type: "Comment",
+        ...(isCommentIsResolvedDefined && { commentIsResolved }),
+        ...(commentHighlightId && { commentHighlightId }),
+      };
+    case "Link":
+      const { documentationItemId, link, openInNewTab, openInNewWindow } = attribute;
+      const isOpenInNewTabDefined = openInNewTab !== undefined && openInNewTab !== null;
+      const isOpenInNewWindowDefined = openInNewWindow !== undefined && openInNewWindow !== null;
+
+      return {
+        type: "Link",
+        ...(isOpenInNewTabDefined && { openInNewTab }),
+        ...(isOpenInNewWindowDefined && { openInNewWindow }),
+        ...(documentationItemId && { documentationItemId }),
+        ...(link && { link }),
+      };
+  }
+}