@supernova-studio/model 0.35.0 → 0.37.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supernova-studio/model",
-  "version": "0.35.0",
+  "version": "0.37.0",
   "description": "Supernova Data Models",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/billing/product.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
 
-export const ProductCodeSchema = z.enum(["free", "team", "team_test", "company", "enterprise"]);
+export const ProductCodeSchema = z.enum(["free", "team", "company", "enterprise"]);
 export type ProductCode = z.infer<typeof ProductCodeSchema>;
 export const ProductCode = ProductCodeSchema.enum;

package/src/dsm/brand.ts

@@ -1,7 +1,11 @@
-export type Brand = {
-  id: string;
-  designSystemVersionId: string;
-  persistentId: string;
-  name: string;
-  description: string;
-};
+import { z } from "zod";
+
+export const Brand = z.object({
+  id: z.string(),
+  designSystemVersionId: z.string(),
+  persistentId: z.string(),
+  name: z.string(),
+  description: z.string(),
+});
+
+export type Brand = z.infer<typeof Brand>;

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

@@ -1,6 +1,6 @@
 import { z } from "zod";
-import { PageBlockCalloutType, PageBlockCodeLanguage, PageBlockText } from "./documentation-block-v1";
 import { DesignTokenType } from "../raw-element";
+import { PageBlockCalloutType, PageBlockCodeLanguage, PageBlockText } from "./documentation-block-v1";
 
 //
 // Enums
@@ -112,17 +112,19 @@ export const PageBlockItemAssetValue = z.object({
   showSearch: z.boolean().optional(),
   previewContainerSize: PageBlockPreviewContainerSize.optional(),
   backgroundColor: PageBlockColorV2.optional(),
-  value: z.array(
-    z.object({
-      entityId: z.string(),
-      entityType: z.enum(["Asset", "AssetGroup"]),
-      entityMeta: PageBlockAssetEntityMeta.optional(),
-    })
-  ),
+  value: z
+    .array(
+      z.object({
+        entityId: z.string(),
+        entityType: z.enum(["Asset", "AssetGroup"]),
+        entityMeta: PageBlockAssetEntityMeta.optional(),
+      })
+    )
+    .default([]),
 });
 
 export const PageBlockItemAssetPropertyValue = z.object({
-  value: z.array(z.string()),
+  value: z.array(z.string()).default([]),
 });
 
 export const PageBlockItemBooleanValue = z.object({
@@ -148,12 +150,14 @@ export const PageBlockItemColorValue = z.record(z.any());
 
 export const PageBlockItemComponentValue = z.object({
   selectedPropertyIds: z.array(z.string()).optional(),
-  value: z.array(
-    z.object({
-      entityId: z.string(),
-      entityType: z.enum(["Component", "ComponentGroup"]),
-    })
-  ),
+  value: z
+    .array(
+      z.object({
+        entityId: z.string(),
+        entityType: z.enum(["Component", "ComponentGroup"]),
+      })
+    )
+    .default([]),
 });
 
 export const PageBlockItemComponentPropertyValue = z.object({
@@ -180,12 +184,14 @@ export const PageBlockItemFigmaNodeValue = z.object({
   previewContainerSize: PageBlockPreviewContainerSize.optional(),
   backgroundColor: PageBlockColorV2.optional(),
   showFrameDetails: z.boolean().optional(),
-  value: z.array(
-    z.object({
-      entityId: z.string(),
-      entityMeta: PageBlockFigmaNodeEntityMeta.optional(),
-    })
-  ),
+  value: z
+    .array(
+      z.object({
+        entityId: z.string(),
+        entityMeta: PageBlockFigmaNodeEntityMeta.optional(),
+      })
+    )
+    .default([]),
 });
 
 export const PageBlockItemImageValue = z.object({
@@ -204,7 +210,7 @@ export const PageBlockItemMultiRichTextValue = z.object({
 });
 
 export const PageBlockItemMultiSelectValue = z.object({
-  value: z.array(z.string()),
+  value: z.array(z.string()).default([]),
 });
 
 export const PageBlockItemNumberValue = z.object({
@@ -223,8 +229,8 @@ export const PageBlockItemSingleSelectValue = z.object({
 export const PageBlockItemStorybookValue = z.object({
   caption: z.string().optional(),
   height: z.number().optional(),
-  showAddons: z.boolean().optional(),
-  value: z.string(),
+  embedUrl: z.string().optional(),
+  value: z.string().optional(),
 });
 
 export const PageBlockItemTextValue = z.object({
@@ -235,27 +241,29 @@ export const PageBlockItemTokenValue = z.object({
   selectedPropertyIds: z.array(z.string()).optional(),
   selectedThemeIds: z.array(z.string()).optional(),
   themeDisplayMode: PageBlockThemeDisplayMode.optional(),
-  value: z.array(
-    z.object({
-      entityId: z.string(),
-      entityType: z.enum(["Token", "TokenGroup"]),
-      entityMeta: z
-        .object({
-          showNestedGroups: z.boolean().optional(),
-        })
-        .optional(),
-    })
-  ),
+  value: z
+    .array(
+      z.object({
+        entityId: z.string(),
+        entityType: z.enum(["Token", "TokenGroup"]),
+        entityMeta: z
+          .object({
+            showNestedGroups: z.boolean().optional(),
+          })
+          .optional(),
+      })
+    )
+    .default([]),
 });
 
 export const PageBlockItemTokenPropertyValue = z.object({
   selectedPropertyIds: z.array(z.string()).optional(),
   selectedThemeIds: z.array(z.string()).optional(),
-  value: z.array(z.string()),
+  value: z.array(z.string()).default([]),
 });
 
 export const PageBlockItemTokenTypeValue = z.object({
-  value: z.array(DesignTokenType),
+  value: z.array(DesignTokenType).default([]),
 });
 
 export const PageBlockItemUrlValue = z.object({
@@ -330,7 +338,7 @@ export const PageBlockItemTableValue = z.object({
   highlightHeaderColumn: z.boolean().optional(),
   highlightHeaderRow: z.boolean().optional(),
   showBorder: z.boolean().optional(),
-  value: z.array(PageBlockItemTableRow),
+  value: z.array(PageBlockItemTableRow).default([]),
 });
 
 export type PageBlockItemTableRichTextNode = z.infer<typeof PageBlockItemTableRichTextNode>;

package/src/dsm/elements/index.ts

@@ -11,3 +11,4 @@ export * from "./page-block-v2";
 export * from "./raw-element";
 export * from "./theme";
 export * from "./tokens";
+export * from "./utils";

package/src/dsm/elements/utils.ts

@@ -0,0 +1,114 @@
+import { DocumentationPageContentItem, PageBlockDefinition, PageBlockDefinitionProperty } from "../documentation";
+import { PageBlockItemUntypedValue, PageBlockItemV2 } from "./data";
+import { PageBlockEditorModelV2 } from "./page-block-v2";
+
+//
+// Traverse
+//
+
+/**
+ * Pay attention to correct types!
+ */
+export function mapPageBlockItemValuesV2(
+  pageItems: DocumentationPageContentItem[],
+  definitionsMap: PageBlockDefinitionsMap,
+  fn: (
+    block: PageBlockEditorModelV2,
+    item: PageBlockItemV2,
+    property: PageBlockDefinitionProperty,
+    value: PageBlockItemUntypedValue
+  ) => PageBlockItemUntypedValue
+) {
+  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);
+    });
+  });
+}
+
+export function traversePageBlockItemValuesV2(
+  pageItems: DocumentationPageContentItem[],
+  definitionsMap: PageBlockDefinitionsMap,
+  fn: (
+    block: PageBlockEditorModelV2,
+    item: PageBlockItemV2,
+    property: PageBlockDefinitionProperty,
+    value: PageBlockItemUntypedValue
+  ) => void
+) {
+  traversePageBlockItemsV2(pageItems, (block, item) => {
+    Object.entries(item.props).forEach(([propKey, value]) => {
+      const property = definitionsMap.getDefinitionProperty(block.data.packageId, propKey);
+      if (!property) return;
+
+      fn(block, item, property, value);
+    });
+  });
+}
+
+export function traversePageBlockItemsV2(
+  pageItems: DocumentationPageContentItem[],
+  fn: (block: PageBlockEditorModelV2, item: PageBlockItemV2) => void
+) {
+  traversePageItemsV2(pageItems, block => {
+    block.data.items.forEach(item => {
+      fn(block, item);
+    });
+  });
+}
+
+export function traversePageItemsV2(
+  pageItems: DocumentationPageContentItem[],
+  fn: (item: PageBlockEditorModelV2) => void
+): void {
+  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;
+    }
+  }
+}
+
+//
+// Definitions map
+//
+
+export class PageBlockDefinitionsMap {
+  private definitionsMap = new Map<string, PageBlockDefinition>();
+  private propertiesMap = new Map<string, PageBlockDefinitionProperty>();
+
+  constructor(definitions: PageBlockDefinition[]) {
+    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: string): PageBlockDefinition | undefined {
+    return this.definitionsMap.get(id);
+  }
+
+  getDefinitionProperty(defId: string, propId: string): PageBlockDefinitionProperty | undefined {
+    return this.propertiesMap.get(this.propertyKey(defId, propId));
+  }
+
+  private propertyKey(defId: string, propId: string): string {
+    return `${defId}.${propId}`;
+  }
+}

package/src/dsm/properties/property-definition.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { DbCreateInputOmit, DbUpdate } from "../../helpers";
 
-export const ElementPropertyType = z.enum(["Text", "Number", "Boolean", "Select", "Generic", "Link", "URL"]);
+export const ElementPropertyTypeSchema = z.enum(["Text", "Number", "Boolean", "Select", "Generic", "Link", "URL"]);
 export const ElementPropertyTargetType = z.enum(["Token", "Component", "DocumentationPage"]);
 export const ElementPropertyLinkType = z.enum(["FigmaComponent", "DocumentationPage"]);
 
@@ -22,13 +22,15 @@ export const ElementPropertyDefinition = z.object({
   name: z.string(),
   codeName: z.string(),
   description: z.string(),
-  type: ElementPropertyType,
+  type: ElementPropertyTypeSchema,
   targetElementType: ElementPropertyTargetType,
-  options: z.array(ElementPropertyDefinitionOption).nullish(),
-  linkElementType: ElementPropertyLinkType.nullish(),
+  options: z.array(ElementPropertyDefinitionOption).optional(),
+  linkElementType: ElementPropertyLinkType.optional(),
 });
 
-export type ElementPropertyType = z.infer<typeof ElementPropertyType>;
+export type ElementPropertyType = z.infer<typeof ElementPropertyTypeSchema>;
+export const ElementPropertyType = ElementPropertyTypeSchema.enum;
+
 export type ElementPropertyTargetType = z.infer<typeof ElementPropertyTargetType>;
 export type ElementPropertyLinkType = z.infer<typeof ElementPropertyLinkType>;
 export type ColorTokenInlineData = z.infer<typeof ColorTokenInlineData>;

package/src/dsm/properties/property-value.ts

@@ -11,7 +11,7 @@ export const ElementPropertyValue = z.object({
   numberValue: z.number().nullish(),
   booleanValue: z.boolean().nullish(),
   referenceValue: z.string().nullish(),
-  referenceValuePreview: z.string().nullish(),
+  referenceValuePreview: z.string().optional(),
 });
 
 export type ElementPropertyValue = z.infer<typeof ElementPropertyValue>;

package/src/dsm/version.ts

@@ -1,14 +1,24 @@
-export type DesignSystemVersion = {
-  id: string;
-  version: string;
-  createdAt: Date;
-  designSystemId: string;
-  name: string;
-  comment: string;
-  isReadonly: boolean;
-  parentId: string | null;
-  changeLog: string;
-
-  // TODO Artem
-  // customProperties: Prisma.JsonValue | null;
-};
+import { z } from "zod";
+import { OmitStrict } from "../utils";
+import { DbCreateInputOmit, DbUpdate } from "../helpers";
+
+export const DesignSystemVersion = z.object({
+  id: z.string(),
+  version: z.string(),
+  createdAt: z.date(),
+  designSystemId: z.string(),
+  name: z.string(),
+  comment: z.string(),
+  isReadonly: z.boolean(),
+  changeLog: z.string(),
+  parentId: z.string().optional(),
+});
+
+export type DesignSystemVersion = z.infer<typeof DesignSystemVersion>;
+
+export type CreateDesignSystemVersion = DbCreateInputOmit<DesignSystemVersion>;
+
+export type UpdateDesignSystemVersion = OmitStrict<
+  DbUpdate<DesignSystemVersion>,
+  "designSystemId" | "isReadonly" | "version" | "parentId"
+>;

package/src/dsm/views/column.ts

@@ -1,37 +1,51 @@
 import { DbCreateInputOmit, DbUpdate } from "../../helpers";
 import { OmitStrict } from "../../utils";
-
-export type ElementViewBaseColumnType = "Name" | "Description" | "Value" | "UpdatedAt";
-
-export type ElementViewColumn =
-  | ElementViewBasePropertyColumn
-  | ElementViewPropertyDefinitionColumn
-  | ElementViewThemeColumn;
-
-export type ElementViewBasePropertyColumn = ElementViewColumnSharedAttributes & {
-  type: "BaseProperty";
-  basePropertyType: ElementViewBaseColumnType;
-};
-
-export type ElementViewPropertyDefinitionColumn = ElementViewColumnSharedAttributes & {
-  type: "PropertyDefinition";
-  propertyDefinitionId: string;
-};
-
-export type ElementViewThemeColumn = ElementViewColumnSharedAttributes & {
-  type: "Theme";
-  themeId: string;
-};
-
-export type ElementViewColumnSharedAttributes = {
-  id: string;
-  persistentId: string;
-  elementDataViewId: string;
-  sortPosition: number;
-  width: number;
-};
-
-export type ElementViewColumnType = ElementViewColumn["type"];
+import { z } from "zod";
+
+export const ElementViewBaseColumnType = z.enum(["Name", "Description", "Value", "UpdatedAt"]);
+
+export const ElementViewColumnType = z.union([
+  z.literal("BaseProperty"),
+  z.literal("PropertyDefinition"),
+  z.literal("Theme"),
+]);
+
+export const ElementViewColumnSharedAttributes = z.object({
+  id: z.string(),
+  persistentId: z.string(),
+  elementDataViewId: z.string(),
+  sortPosition: z.number(),
+  width: z.number(),
+});
+
+export const ElementViewBasePropertyColumn = ElementViewColumnSharedAttributes.extend({
+  type: z.literal("BaseProperty"),
+  basePropertyType: ElementViewBaseColumnType,
+});
+
+export const ElementViewPropertyDefinitionColumn = ElementViewColumnSharedAttributes.extend({
+  type: z.literal("PropertyDefinition"),
+  propertyDefinitionId: z.string(),
+});
+
+export const ElementViewThemeColumn = ElementViewColumnSharedAttributes.extend({
+  type: z.literal("Theme"),
+  themeId: z.string(),
+});
+
+export const ElementViewColumn = z.discriminatedUnion("type", [
+  ElementViewBasePropertyColumn,
+  ElementViewPropertyDefinitionColumn,
+  ElementViewThemeColumn,
+]);
+
+export type ElementViewBaseColumnType = z.infer<typeof ElementViewBaseColumnType>;
+export type ElementViewBasePropertyColumn = z.infer<typeof ElementViewBasePropertyColumn>;
+export type ElementViewPropertyDefinitionColumn = z.infer<typeof ElementViewPropertyDefinitionColumn>;
+export type ElementViewThemeColumn = z.infer<typeof ElementViewThemeColumn>;
+export type ElementViewColumn = z.infer<typeof ElementViewColumn>;
+export type ElementViewColumnSharedAttributes = z.infer<typeof ElementViewColumnSharedAttributes>;
+export type ElementViewColumnType = z.infer<typeof ElementViewColumn>["type"];
 
 export type CreateElementViewColumn =
   | DbCreateInputOmit<ElementViewBasePropertyColumn>

package/src/dsm/views/view.ts

@@ -1,11 +1,14 @@
 import { ElementPropertyTargetType } from "../properties";
+import { z } from "zod";
 
-export type ElementView = {
-  id: string;
-  persistentId: string;
-  designSystemVersionId: string;
-  name: string;
-  description: string;
-  targetElementType: ElementPropertyTargetType;
-  isDefault: boolean;
-};
+export const ElementView = z.object({
+  id: z.string(),
+  persistentId: z.string(),
+  designSystemVersionId: z.string(),
+  name: z.string(),
+  description: z.string(),
+  targetElementType: ElementPropertyTargetType,
+  isDefault: z.boolean(),
+});
+
+export type ElementView = z.infer<typeof ElementView>;