@supernova-studio/client 0.0.3 → 0.0.4

package/src/docs-editor/prosemirror/types.ts

@@ -0,0 +1,23 @@
+export type ProsemirrorNode = {
+  type: string;
+  text?: string;
+  attrs?: Record<string, any>;
+  marks?: ProsemirrorMark[];
+  content?: ProsemirrorNode[];
+};
+
+export type ProsemirrorMark = {
+  type: string;
+  attrs: Record<string, any>;
+};
+
+export type ProsemirrorBlockItem = {
+  properties: ProsemirrorBlockItemPropertyValue[];
+};
+
+export type ProsemirrorBlockItemPropertyValue = {
+  id: string;
+  data: {
+    value?: string;
+  };
+};

package/src/docs-editor/prosemirror-to-blocks.ts

@@ -0,0 +1,170 @@
+import * as Y from "yjs";
+import { ProsemirrorNode, ProsemirrorMark } from "./prosemirror/types";
+import {
+  PageBlockDefinition,
+  PageBlockText,
+  PageBlockTextSpan,
+  PageBlockTextSpanAttribute,
+  PageBlockDefinitionProperty,
+} from "@supernova-studio/model";
+import { PageBlockEditorModel } from "./model/block";
+import { DocumentationPageEditorModel } from "./model/page";
+import { BlockDefinitionUtils } from "./utils";
+import { yXmlFragmentToProsemirrorJSON } from "y-prosemirror";
+
+export function yXmlFragmetToPage(
+  fragment: Y.XmlFragment,
+  definitions: PageBlockDefinition[]
+): DocumentationPageEditorModel {
+  const prosemirrorJson = yXmlFragmentToProsemirrorJSON(fragment) as ProsemirrorNode;
+  return prosemirrorDocToPage(prosemirrorJson, definitions);
+}
+
+export function prosemirrorDocToPage(
+  prosemirrorDoc: ProsemirrorNode,
+  definitions: PageBlockDefinition[]
+): DocumentationPageEditorModel {
+  const definitionsById = mapByUnique(definitions, d => d.id);
+
+  return {
+    blocks: (prosemirrorDoc.content ?? [])
+      .map(prosemirrorNode => {
+        const definitionId = prosemirrorNode.attrs?.definitionId;
+        if (!definitionId) throw new Error(`Node is missing defintion id`);
+        if (typeof definitionId !== "string")
+          throw new Error(`Definition id is ${typeof definitionId}, has to be string`);
+
+        const definition = definitionsById.get(definitionId);
+        if (!definition) throw new Error(`Definition by id ${definitionId} doesn't exist`);
+
+        return prosemirrorNodeToBlock(prosemirrorNode, definition);
+      })
+      .filter(nonNullFilter),
+  };
+}
+
+export function prosemirrorNodeToBlock(
+  prosemirrorNode: ProsemirrorNode,
+  definition: PageBlockDefinition
+): PageBlockEditorModel | null {
+  const richTextProperty = BlockDefinitionUtils.firstRichTextProperty(definition);
+  if (richTextProperty) {
+    return parseAsRichText(prosemirrorNode, definition, richTextProperty);
+  }
+
+  return parseAsCustomBlock(prosemirrorNode, definition);
+}
+
+function parseAsRichText(
+  prosemirrorNode: ProsemirrorNode,
+  definition: PageBlockDefinition,
+  property: PageBlockDefinitionProperty
+): PageBlockEditorModel {
+  const id = parseProsemirrorBlockAttribute(prosemirrorNode, "id");
+  const variantId = parseProsemirrorOptionalBlockAttribute(prosemirrorNode, "variantId");
+
+  return {
+    // TODO Artem: indent
+    id: id,
+    data: {
+      packageId: definition.id,
+      indentLevel: 0,
+      variantId: variantId,
+      items: [
+        {
+          props: {
+            [property.id]: {
+              value: parseRichText(prosemirrorNode.content ?? []),
+            },
+          },
+        },
+      ],
+    },
+  };
+}
+
+function parseRichText(spans: ProsemirrorNode[]): PageBlockText {
+  return {
+    spans: spans.map(parseRichTextSpan).filter(nonNullFilter),
+  };
+}
+
+function parseRichTextSpan(span: ProsemirrorNode): PageBlockTextSpan | null {
+  if (span.type !== "text" || !span.text) return null;
+
+  const marks = span.marks ?? [];
+
+  return {
+    text: span.text,
+    attributes: marks.map(parseRichTextAttribute).filter(nonNullFilter),
+  };
+}
+
+function parseRichTextAttribute(mark: ProsemirrorMark): PageBlockTextSpanAttribute | null {
+  switch (mark.type) {
+    case "bold":
+      return { type: "Bold" };
+    case "italic":
+      return { type: "Italic" };
+    case "strikethrough":
+      return { type: "Strikethrough" };
+    case "code":
+      return { type: "Code" };
+    case "link":
+      const itemId = mark.attrs?.itemId;
+      const href = mark.attrs?.href;
+
+      return {
+        type: "Link",
+        openInNewWindow: mark.attrs?.target !== "_self",
+        documentationItemId: itemId,
+        link: href,
+      };
+  }
+
+  return null;
+}
+
+//
+// Custom block
+//
+
+function parseAsCustomBlock(
+  prosemirrorNode: ProsemirrorNode,
+  definition: PageBlockDefinition
+): PageBlockEditorModel | null {
+  return null;
+}
+
+//
+// Attributes
+//
+
+function parseProsemirrorBlockAttribute(prosemirrorNode: ProsemirrorNode, attributeName: string) {
+  const attributeValue = parseProsemirrorOptionalBlockAttribute(prosemirrorNode, attributeName); //prosemirrorNode.attrs?.[attributeName];
+  if (!attributeValue) {
+    throw new Error(`Attribute ${attributeName} was not defined`);
+  }
+
+  return attributeValue;
+}
+
+function parseProsemirrorOptionalBlockAttribute(prosemirrorNode: ProsemirrorNode, attributeName: string) {
+  return prosemirrorNode.attrs?.[attributeName] ?? undefined;
+}
+
+//
+// Utils
+//
+
+function nonNullFilter<T>(item: T | null): item is T {
+  return item !== null;
+}
+
+function mapByUnique<V, K>(items: V[], keyFn: (item: V) => K): Map<K, V> {
+  const result = new Map<K, V>();
+  for (const item of items) {
+    result.set(keyFn(item), item);
+  }
+  return result;
+}

package/src/docs-editor/utils.ts

@@ -0,0 +1,81 @@
+import { PageBlockEditorModel } from "./model/block";
+import {
+  PageBlockDefinition,
+  PageBlockDefinitionPropertyType,
+  PageBlockItemV2,
+  PageBlockText,
+} from "@supernova-studio/model";
+
+export const SDKBlockParsingUtils = {
+  singleBlockItem(block: PageBlockEditorModel) {
+    if (!block.data.items.length) throw new Error(`Block ${block.id} has no items`);
+    if (block.data.items.length > 1) throw new Error(`Block ${block.id} has more than 1 item`);
+
+    return block.data.items[0];
+  },
+
+  richTextPropertyValue(item: PageBlockItemV2, propertyKey: string) {
+    const objectValue = this.objectPropertyValue(item, propertyKey);
+    const richText = PageBlockText.parse(objectValue);
+
+    return richText;
+  },
+
+  objectPropertyValue(item: PageBlockItemV2, propertyKey: string) {
+    const value = this.propertyValue(item, propertyKey);
+
+    if (typeof value !== "object") {
+      throw new Error(`Value for property ${propertyKey} is expected to be an object, but instead is ${typeof value}`);
+    }
+
+    return value;
+  },
+
+  propertyValue(item: PageBlockItemV2, propertyKey: string) {
+    const value = this.safePropertyValue(item, propertyKey);
+    if (!value) throw new Error(`Property ${propertyKey} is not defined on block item`);
+
+    return value;
+  },
+
+  safePropertyValue(item: PageBlockItemV2, propertyKey: string) {
+    return item.props[propertyKey] ?? undefined;
+  },
+};
+
+export const BlockDefinitionUtils = {
+  firstRichTextProperty(definition: PageBlockDefinition) {
+    const property = definition.item.properties.find(p => p.type === PageBlockDefinitionPropertyType.richText);
+    if (property) return property;
+    return undefined;
+  },
+
+  firstTableProperty(definition: PageBlockDefinition) {
+    const property = definition.item.properties.find(p => p.type === PageBlockDefinitionPropertyType.table);
+    if (property) return property;
+    return undefined;
+  },
+
+  richTextProperty(definition: PageBlockDefinition, propertyKey: string) {
+    return this.property(definition, propertyKey, PageBlockDefinitionPropertyType.richText);
+  },
+
+  property(
+    definition: PageBlockDefinition,
+    propertyKey: string,
+    expectedPropertyType?: PageBlockDefinitionPropertyType
+  ) {
+    const property = definition.item.properties.find(p => p.id === propertyKey);
+    if (!property) {
+      throw new Error(`Definition ${definition.id} doesn't contain property ${propertyKey}`);
+    }
+
+    if (expectedPropertyType && property.type !== expectedPropertyType) {
+      throw new Error(
+        `Property ${propertyKey} of definition ${definition.id} expected to be ${expectedPropertyType} but was ${property.type}`
+      );
+    }
+
+    return property;
+  },
+};

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from "./api";
+export * from "./docs-editor";