@supernova-studio/client 0.36.0 → 0.36.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supernova-studio/client",
-  "version": "0.36.0",
+  "version": "0.36.2",
   "description": "Supernova Data Models",
   "source": "src/index.ts",
   "main": "dist/index.js",

package/src/api/conversion/design-system/index.ts

@@ -0,0 +1 @@
+export * from "./version-to-dto";

package/src/api/conversion/design-system/version-to-dto.ts

@@ -0,0 +1,17 @@
+import { DTODesignSystemVersion } from "../../dto";
+import { DesignSystemVersion } from "@supernova-studio/model";
+
+export function designSystemVersionToDto(version: DesignSystemVersion): DTODesignSystemVersion {
+  return {
+    id: version.id,
+    designSystemId: version.designSystemId,
+    createdAt: version.createdAt,
+    meta: {
+      name: version.name,
+      description: version.comment,
+    },
+    version: version.version,
+    changeLog: version.changeLog,
+    isReadonly: version.isReadonly,
+  };
+}

package/src/api/conversion/design-systems/brand.ts

@@ -0,0 +1,14 @@
+import { DTOBrand } from "../../dto";
+import { Brand } from "@supernova-studio/model";
+
+export function designSystemBrandToDto(brand: Brand): DTOBrand {
+  return {
+    id: brand.id,
+    designSystemVersionId: brand.designSystemVersionId,
+    persistentId: brand.persistentId,
+    meta: {
+      name: brand.name,
+      description: brand.description,
+    },
+  };
+}

package/src/api/conversion/design-systems/elements/index.ts

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

package/src/api/conversion/design-systems/elements/properties/index.ts

@@ -0,0 +1,2 @@
+export * from "./property-definition";
+export * from "./property-value";

package/src/api/conversion/design-systems/elements/properties/property-definition.ts

@@ -0,0 +1,21 @@
+import { ElementPropertyDefinition } from "@supernova-studio/model";
+import { DTOElementPropertyDefinition } from "packages/client/src/api/dto/elements/properties/property-definitions";
+
+export function elementPropertyDefinitionToDto(
+  elementProperyDefinition: ElementPropertyDefinition
+): DTOElementPropertyDefinition {
+  return {
+    id: elementProperyDefinition.id,
+    designSystemVersionId: elementProperyDefinition.designSystemVersionId,
+    meta: {
+      name: elementProperyDefinition.name,
+      description: elementProperyDefinition.description,
+    },
+    persistentId: elementProperyDefinition.persistentId,
+    type: elementProperyDefinition.type,
+    targetElementType: elementProperyDefinition.targetElementType,
+    codeName: elementProperyDefinition.codeName,
+    options: elementProperyDefinition.options,
+    linkElementType: elementProperyDefinition.linkElementType,
+  };
+}

package/src/api/conversion/design-systems/elements/properties/property-value.ts

@@ -0,0 +1,28 @@
+import { ElementPropertyValue, SupernovaException } from "@supernova-studio/model";
+import { DTOElementPropertyValue } from "packages/client/src/api/dto/elements/properties/property-values";
+
+export function elementPropertyValueToDto(elementPropertyValue: ElementPropertyValue): DTOElementPropertyValue {
+  let value: string | number | boolean | undefined;
+  let valuePreview;
+
+  if (elementPropertyValue.stringValue) {
+    value = elementPropertyValue.stringValue;
+  } else if (elementPropertyValue.numberValue) {
+    value = elementPropertyValue.numberValue;
+  } else if (typeof elementPropertyValue.booleanValue === "boolean") {
+    value = elementPropertyValue.booleanValue;
+  } else if (elementPropertyValue.referenceValue) {
+    value = elementPropertyValue.referenceValue;
+    valuePreview = elementPropertyValue.referenceValuePreview;
+  } else {
+    throw SupernovaException.shouldNotHappen(`Invalid element property value, id: ${elementPropertyValue.id}`);
+  }
+  return {
+    id: elementPropertyValue.id,
+    designSystemVersionId: elementPropertyValue.designSystemVersionId,
+    definitionId: elementPropertyValue.definitionPersistentId,
+    targetElementId: elementPropertyValue.targetElementPersistentId,
+    value,
+    valuePreview,
+  };
+}

package/src/api/conversion/design-systems/index.ts

@@ -0,0 +1,3 @@
+export * from "./brand";
+export * from "./elements";
+export * from "./view";

package/src/api/conversion/design-systems/view.ts

@@ -0,0 +1,18 @@
+import { ElementView, ElementViewColumn } from "@supernova-studio/model";
+import { DTOElementView } from "../../dto";
+
+export function elementViewToDto(elementView: ElementView, columns: ElementViewColumn[]): DTOElementView {
+  columns.sort((lhs, rhs) => lhs.sortPosition - rhs.sortPosition);
+
+  return {
+    id: elementView.id,
+    persistentId: elementView.persistentId,
+    targetElementType: elementView.targetElementType,
+    isDefault: elementView.isDefault,
+    meta: {
+      name: elementView.name,
+      description: elementView.description,
+    },
+    columns,
+  };
+}

package/src/api/conversion/index.ts

@@ -1 +1,3 @@
+export * from "./design-systems";
 export * from "./documentation";
+export * from "./design-system";

package/src/api/dto/design-systems/brand.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+import { ObjectMeta } from "@supernova-studio/model";
+
+export const DTOBrand = z.object({
+  id: z.string(),
+  designSystemVersionId: z.string(),
+  persistentId: z.string(),
+  meta: ObjectMeta,
+});
+
+export const DTOBrandGetResponse = z.object({ brand: DTOBrand });
+
+export const DTOBrandsListResponse = z.object({ brands: z.array(DTOBrand) });
+
+export type DTOBrand = z.infer<typeof DTOBrand>;
+export type DTOBrandGetResponse = z.infer<typeof DTOBrandGetResponse>;
+export type DTOBrandsListResponse = z.infer<typeof DTOBrandsListResponse>;

package/src/api/dto/design-systems/index.ts

@@ -1 +1,4 @@
 export * from "./design-system";
+export * from "./brand";
+export * from "./view";
+export * from "./version";

package/src/api/dto/design-systems/version.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { ObjectMeta } from "@supernova-studio/model";
+
+export const DTODesignSystemVersion = z.object({
+  id: z.string(),
+  createdAt: z.date(),
+  meta: ObjectMeta,
+  version: z.string(),
+  isReadonly: z.boolean(),
+  changeLog: z.string(),
+  designSystemId: z.string(),
+});
+
+export const DTODesignSystemVersionsListResponse = z.object({
+  designSystemVersions: z.array(DTODesignSystemVersion),
+});
+
+export const DTODesignSystemVersionGetResponse = z.object({
+  designSystemVersion: DTODesignSystemVersion,
+});
+
+export type DTODesignSystemVersion = z.infer<typeof DTODesignSystemVersion>;
+export type DTODesignSystemVersionsListResponse = z.infer<typeof DTODesignSystemVersionsListResponse>;
+export type DTODesignSystemVersionGetResponse = z.infer<typeof DTODesignSystemVersionGetResponse>;

package/src/api/dto/design-systems/view.ts

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import { ElementPropertyTargetType, ElementViewBaseColumnType, ObjectMeta } from "@supernova-studio/model";
+
+export const DTOElementViewColumnSharedAttributes = z.object({
+  id: z.string(),
+  persistentId: z.string(),
+  width: z.number(),
+});
+
+export const DTOElementViewBasePropertyColumn = DTOElementViewColumnSharedAttributes.extend({
+  type: z.literal("BaseProperty"),
+  basePropertyType: ElementViewBaseColumnType,
+});
+
+export const DTOElementViewPropertyDefinitionColumn = DTOElementViewColumnSharedAttributes.extend({
+  type: z.literal("PropertyDefinition"),
+  propertyDefinitionId: z.string(),
+});
+
+export const DTOElementViewThemeColumn = DTOElementViewColumnSharedAttributes.extend({
+  type: z.literal("Theme"),
+  themeId: z.string(),
+});
+
+export const DTOElementViewColumn = z.discriminatedUnion("type", [
+  DTOElementViewBasePropertyColumn,
+  DTOElementViewPropertyDefinitionColumn,
+  DTOElementViewThemeColumn,
+]);
+
+export const DTOElementView = z.object({
+  meta: ObjectMeta,
+  persistentId: z.string(),
+  targetElementType: ElementPropertyTargetType,
+  id: z.string(),
+  isDefault: z.boolean(),
+  columns: z.array(DTOElementViewColumn),
+});
+
+export const DTOElementViewsListResponse = z.object({
+  elementDataViews: z.array(DTOElementView),
+});
+
+export type DTOElementView = z.infer<typeof DTOElementView>;
+export type DTOElementViewsListResponse = z.infer<typeof DTOElementViewsListResponse>;

package/src/api/dto/elements/index.ts

@@ -1,4 +1,5 @@
 export * from "./documentation";
 export * from "./figma-nodes";
+export * from "./properties";
 export * from "./elements-action-v2";
 export * from "./get-elements-v2";

package/src/api/dto/elements/properties/index.ts

@@ -0,0 +1,2 @@
+export * from "./property-definitions";
+export * from "./property-values";

package/src/api/dto/elements/properties/property-definitions.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+import {
+  ElementPropertyDefinitionOption,
+  ElementPropertyLinkType,
+  ElementPropertyTargetType,
+  ElementPropertyTypeSchema,
+  ObjectMeta,
+} from "@supernova-studio/model";
+
+export const DTOElementPropertyDefinition = z.object({
+  id: z.string(),
+  designSystemVersionId: z.string(),
+  meta: ObjectMeta,
+  persistentId: z.string(),
+  type: ElementPropertyTypeSchema,
+  targetElementType: ElementPropertyTargetType,
+  codeName: z.string(),
+  options: z.array(ElementPropertyDefinitionOption).optional(),
+  linkElementType: ElementPropertyLinkType.optional(),
+});
+
+export const DTOElementPropertyDefinitionsGetResponse = z.object({
+  definitions: z.array(DTOElementPropertyDefinition),
+});
+
+export type DTOElementPropertyDefinition = z.infer<typeof DTOElementPropertyDefinition>;
+export type DTOElementPropertyDefinitionsGetResponse = z.infer<typeof DTOElementPropertyDefinitionsGetResponse>;

package/src/api/dto/elements/properties/property-values.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+
+export const DTOElementPropertyValue = z.object({
+  id: z.string(),
+  designSystemVersionId: z.string(),
+  definitionId: z.string(),
+  targetElementId: z.string(),
+  value: z.union([z.string(), z.number(), z.boolean()]).optional(),
+  valuePreview: z.string().optional(),
+});
+
+export const DTOElementPropertyValuesGetResponse = z.object({
+  values: z.array(DTOElementPropertyValue),
+});
+
+export type DTOElementPropertyValue = z.infer<typeof DTOElementPropertyValue>;
+export type DTOElementPropertyValuesGetResponse = z.infer<typeof DTOElementPropertyValuesGetResponse>;

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

@@ -1,54 +1,54 @@
-import * as Y from "yjs";
-import { ProsemirrorNode, ProsemirrorMark } from "./prosemirror/types";
 import {
+  PageBlockAppearanceV2,
+  PageBlockCalloutType,
+  PageBlockColorV2,
   PageBlockDefinition,
-  PageBlockText,
-  PageBlockTextSpan,
-  PageBlockTextSpanAttribute,
   PageBlockDefinitionProperty,
-  PageBlockCalloutType,
-  PageBlockItemEmbedValue,
-  PageBlockItemV2,
-  PageBlockItemTextValue,
-  PageBlockItemImageValue,
-  PageBlockItemRichTextValue,
   PageBlockDefinitionPropertyType,
-  PageBlockItemMultiRichTextValue,
+  PageBlockItemAssetPropertyValue,
+  PageBlockItemAssetValue,
   PageBlockItemBooleanValue,
-  PageBlockItemNumberValue,
-  PageBlockItemSingleSelectValue,
-  PageBlockItemMultiSelectValue,
-  PageBlockItemTokenValue,
-  PageBlockItemTokenTypeValue,
-  PageBlockItemTokenPropertyValue,
-  PageBlockItemComponentValue,
+  PageBlockItemCodeValue,
+  PageBlockItemColorValue,
   PageBlockItemComponentPropertyValue,
-  PageBlockItemAssetValue,
-  PageBlockItemAssetPropertyValue,
-  PageBlockItemUrlValue,
+  PageBlockItemComponentValue,
+  PageBlockItemDividerValue,
+  PageBlockItemEmbedValue,
+  PageBlockItemFigmaNodeValue,
+  PageBlockItemImageValue,
   PageBlockItemMarkdownValue,
-  PageBlockItemCodeValue,
+  PageBlockItemMultiRichTextValue,
+  PageBlockItemMultiSelectValue,
+  PageBlockItemNumberValue,
+  PageBlockItemRichTextValue,
   PageBlockItemSandboxValue,
-  PageBlockItemTableValue,
-  PageBlockItemDividerValue,
+  PageBlockItemSingleSelectValue,
   PageBlockItemStorybookValue,
-  PageBlockItemColorValue,
-  PageBlockItemUntypedValue,
-  PageBlockItemTableNode,
   PageBlockItemTableCell,
+  PageBlockItemTableNode,
+  PageBlockItemTableValue,
+  PageBlockItemTextValue,
+  PageBlockItemTokenPropertyValue,
+  PageBlockItemTokenTypeValue,
+  PageBlockItemTokenValue,
+  PageBlockItemUntypedValue,
+  PageBlockItemUrlValue,
+  PageBlockItemV2,
   PageBlockTableCellAlignment,
-  PageBlockAppearanceV2,
-  nullishToOptional,
-  PageBlockItemFigmaNodeValue,
-  PageBlockColorV2,
-  PageSectionItemV2,
+  PageBlockText,
+  PageBlockTextSpan,
+  PageBlockTextSpanAttribute,
   PageSectionColumnV2,
+  PageSectionItemV2,
+  nullishToOptional,
 } from "@supernova-studio/model";
+import { yXmlFragmentToProsemirrorJSON } from "y-prosemirror";
+import * as Y from "yjs";
+import { ZodSchema, ZodTypeDef, z } from "zod";
 import { PageBlockEditorModel, PageSectionEditorModel } from "./model/block";
 import { DocumentationPageEditorModel } from "./model/page";
+import { ProsemirrorMark, ProsemirrorNode } from "./prosemirror/types";
 import { BlockDefinitionUtils } from "./utils";
-import { yXmlFragmentToProsemirrorJSON } from "y-prosemirror";
-import { ZodSchema, ZodTypeDef, z } from "zod";
 
 export function yDocToPage(yDoc: Y.Doc, definitions: PageBlockDefinition[]): DocumentationPageEditorModel {
   return yXmlFragmentToPage(yDoc.getXmlFragment("default"), definitions);
@@ -752,7 +752,7 @@ function parseItem(rawItem: unknown, definition: PageBlockDefinition): PageBlock
     if (validationResult.success) {
       sanitizedProps[property.id] = validationResult.data;
     } else {
-      console.log(validationResult.error.flatten());
+      console.log(validationResult.error.toString());
     }
   }