@supernova-studio/model 0.0.4

package/src/dsm/elements/page-block-v2.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { DesignElementBase, DesignElementGroupableRequiredPart } from "./base";
+import { PageBlockDataV2 } from "./data";
+
+//
+// Element
+//
+
+export const PageBlockV2 = DesignElementBase.extend(DesignElementGroupableRequiredPart.shape).extend({
+  data: PageBlockDataV2,
+});
+
+export type PageBlockV2 = z.infer<typeof PageBlockV2>;
+
+//
+// Editor Model
+//
+
+export const PageBlockEditorModelV2 = z.object({
+  id: z.string(),
+  data: PageBlockDataV2,
+});
+
+export type PageBlockEditorModelV2 = z.infer<typeof PageBlockEditorModelV2>;

package/src/dsm/elements/primitives/index.ts

@@ -0,0 +1,2 @@
+export * from "./point";
+export * from "./size";

package/src/dsm/elements/primitives/point.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+
+export const Point2D = z.object({
+  x: z.number(),
+  y: z.number(),
+});
+
+export type Point2D = z.infer<typeof Point2D>;

package/src/dsm/elements/primitives/size.ts

@@ -0,0 +1,28 @@
+import { z } from "zod";
+
+const nullSize = { height: -1, width: -1 };
+
+function isNullSize(size: Size): boolean {
+  return size.height === nullSize.height && size.width === nullSize.width;
+}
+
+export const Size = z.object({
+  width: z
+    .number()
+    .nullish()
+    .transform(v => v ?? nullSize.width),
+
+  height: z
+    .number()
+    .nullish()
+    .transform(v => v ?? nullSize.height),
+});
+
+export const SizeOrUndefined = Size.optional().transform(v => {
+  if (!v) return undefined;
+  if (isNullSize(v)) return undefined;
+
+  return v;
+});
+
+export type Size = z.infer<typeof Size>;

package/src/dsm/elements/raw-element.ts

@@ -0,0 +1,126 @@
+import { z } from "zod";
+import { DbCreateInputOmit, DbUpdate, OmitStrict } from "../../helpers";
+import { ObjectMeta } from "../../common";
+
+export type CreateDesignElement = DbCreateInputOmit<DesignElement>;
+export type UpdateDesignElement = OmitStrict<
+  DbUpdate<DesignElement>,
+  "brandPersistentId" | "childType" | "designSystemVersionId" | "shortPersistentId" | "type"
+>;
+
+//
+// Token types
+//
+
+export const DesignTokenType = z.enum([
+  "Color",
+  "Border",
+  "Gradient",
+  "Shadow",
+  "Dimension",
+  "Duration",
+  "Size",
+  "Space",
+  "Opacity",
+  "FontSize",
+  "LineHeight",
+  "LetterSpacing",
+  "ParagraphSpacing",
+  "BorderWidth",
+  "BorderRadius",
+  "Duration",
+  "ZIndex",
+  "Image",
+  "String",
+  "ProductCopy",
+  "FontFamily",
+  "FontWeight",
+  "TextDecoration",
+  "TextCase",
+  "Visibility",
+  "Typography",
+  "Blur",
+  "Font",
+]);
+
+export const tokenElementTypes: ReadonlyArray<DesignTokenType> = [...DesignTokenType.options.filter(v => v !== "Font")];
+
+export type DesignTokenType = z.infer<typeof DesignTokenType>;
+
+//
+// Non-token types
+//
+
+export const DesignElementType = DesignTokenType.or(
+  z.enum([
+    "Component",
+    "Theme",
+    "Documentation",
+    "DocumentationPage",
+    "DesignSystemComponent",
+    "ElementGroup",
+    "FigmaNodeStructure",
+    "FigmaNodeReference",
+    "PageBlock",
+  ])
+);
+
+export type DesignElementType = z.infer<typeof DesignElementType>;
+
+export function isTokenType(type: DesignElementType): type is DesignTokenType {
+  return DesignTokenType.safeParse(type).success;
+}
+
+//
+// Element category
+//
+
+export const DesignElementCategory = z.enum([
+  "Token",
+  "Component",
+  "DesignSystemComponent",
+  "DocumentationPage",
+  "Theme",
+  "PageBlock",
+]);
+
+export type DesignElementCategory = z.infer<typeof DesignElementCategory>;
+
+// Elements
+
+export const DesignSystemElementExportProps = z.object({
+  isAsset: z
+    .boolean()
+    .nullish()
+    .transform(v => v ?? false),
+
+  codeName: z.string().nullish(),
+});
+
+export type DesignSystemElementExportProps = z.infer<typeof DesignSystemElementExportProps>;
+
+export const ShallowDesignElement = z.object({
+  id: z.string(),
+  persistentId: z.string(),
+  designSystemVersionId: z.string(),
+  type: DesignElementType,
+  brandPersistentId: z.string().optional(),
+  parentPersistentId: z.string().optional(),
+  shortPersistentId: z.string().optional(),
+  sortOrder: z.number(),
+});
+
+export const DesignElement = ShallowDesignElement.extend({
+  meta: ObjectMeta,
+  childType: DesignElementType.optional(),
+  slug: z.string().optional(),
+  userSlug: z.string().optional(),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+  exportProperties: DesignSystemElementExportProps.optional(),
+  data: z.any(), // TODO this should be an object, not any.
+  origin: z.any().optional(), // TODO object, not any.
+});
+
+export type ShallowDesignElement = z.infer<typeof ShallowDesignElement>;
+export type DesignElement = z.infer<typeof DesignElement>;

package/src/dsm/elements/theme.ts

@@ -0,0 +1,74 @@
+import { z } from "zod";
+import { DesignTokenOrigin, DesignTokenOriginPart, DesignTokenTypedData } from "./tokens";
+import { DesignTokenType } from "./raw-element";
+import { DesignElementBase, DesignElementBrandedPart } from "./base";
+import { DbCreateInputOmit, DbUpdate, OmitStrict } from "../../helpers";
+
+//
+// Overrides
+//
+
+export const ThemeOverrideOriginPart = DesignTokenOriginPart;
+export const ThemeOverrideOrigin = DesignTokenOrigin;
+
+export const ThemeOverride = DesignTokenTypedData.and(
+  z.object({
+    tokenPersistentId: z.string(),
+    origin: ThemeOverrideOrigin.optional()
+      .nullable()
+      .transform(v => v ?? undefined),
+  })
+);
+
+export type ThemeOverride = z.infer<typeof ThemeOverride>;
+export type ThemeOverrideOfType<T extends DesignTokenType> = Extract<ThemeOverride, { type: T }>;
+
+//
+// Theme data
+//
+
+export const ThemeElementData = z.object({
+  value: z.object({
+    overrides: z.array(ThemeOverride),
+  }),
+});
+
+export type ThemeElementData = z.infer<typeof ThemeElementData>;
+
+//
+// Theme
+//
+
+export const ThemeOriginPart = z.object({});
+
+export const ThemeOriginObject = z.object({
+  id: z.string(),
+  name: z.string(),
+});
+
+export const ThemeOriginSource = z.object({
+  sourceId: z.string(),
+  sourceObjects: z.array(ThemeOriginObject),
+});
+
+export const ThemeOrigin = z.object({
+  sources: z.array(ThemeOriginSource),
+});
+
+export const Theme = DesignElementBase.extend(DesignElementBrandedPart.shape).extend({
+  origin: ThemeOrigin.optional(),
+  overrides: z.array(ThemeOverride),
+});
+
+export type Theme = z.infer<typeof Theme>;
+export type ThemeOrigin = z.infer<typeof ThemeOrigin>;
+export type ThemeOriginSource = z.infer<typeof ThemeOriginSource>;
+export type ThemeOriginObject = z.infer<typeof ThemeOriginObject>;
+
+export type CreateTheme = DbCreateInputOmit<Theme>;
+export type UpdateTheme = OmitStrict<DbUpdate<Theme>, "brandPersistentId" | "designSystemVersionId">;
+
+export type ThemeDiff = {
+  toCreate: CreateTheme[];
+  toUpdate: UpdateTheme[];
+};

package/src/dsm/elements/tokens.ts

@@ -0,0 +1,288 @@
+import { z } from "zod";
+import {
+  DesignElementBase,
+  DesignElementBrandedPart,
+  DesignElementGroupableRequiredPart,
+  DesignElementOrigin,
+} from "./base";
+import { DbUpdate, OmitStrict, zodCreateInputOmit, zodUpdateInputOmit } from "../../helpers";
+import { DesignTokenType } from "./raw-element";
+import {
+  TextCaseTokenData,
+  FontWeightTokenData,
+  LetterSpacingTokenData,
+  LineHeightTokenData,
+  ParagraphSpacingTokenData,
+  StringTokenData,
+  TextDecorationTokenData,
+  BorderRadiusTokenData,
+  BorderWidthTokenData,
+  BorderTokenData,
+  ProductCopyTokenData,
+  FontFamilyTokenData,
+  FontSizeTokenData,
+  DimensionTokenData,
+  TypographyTokenData,
+  ShadowTokenData,
+  OpacityTokenData,
+  GradientTokenData,
+  ColorTokenData,
+  BlurTokenData,
+  DurationTokenData,
+  ZIndexTokenData,
+  VisibilityTokenData,
+  SpaceTokenData,
+  SizeTokenData,
+} from "./data";
+
+//
+// Base
+//
+
+export const DesignTokenOriginPart = z.object({
+  referenceOriginId: z.string().optional(),
+  referencePersistentId: z.string().optional(),
+});
+
+export const DesignTokenOrigin = DesignElementOrigin.extend(DesignTokenOriginPart.shape);
+
+const DesignTokenBase = DesignElementBase.extend(DesignElementGroupableRequiredPart.shape)
+  .extend(DesignElementBrandedPart.shape)
+  .extend({
+    origin: DesignTokenOrigin.optional(),
+  });
+
+const CreateDesignTokenBase = DesignTokenBase.omit(zodCreateInputOmit());
+const UpdateDesignTokenBase = DesignTokenBase.omit({
+  ...zodUpdateInputOmit(),
+  brandPersistentId: true,
+  designSystemVersionId: true,
+});
+
+//
+// Per type
+//
+
+const BlurTokenTypedData = z.object({
+  type: z.literal("Blur"),
+  data: BlurTokenData,
+});
+
+const ColorTokenTypedData = z.object({
+  type: z.literal("Color"),
+  data: ColorTokenData,
+});
+
+const GradientTokenTypedData = z.object({
+  type: z.literal("Gradient"),
+  data: GradientTokenData,
+});
+
+const OpacityTokenTypedData = z.object({
+  type: z.literal("Opacity"),
+  data: OpacityTokenData,
+});
+
+const ShadowTokenTypedData = z.object({
+  type: z.literal("Shadow"),
+  data: ShadowTokenData,
+});
+
+const TypographyTokenTypedData = z.object({
+  type: z.literal("Typography"),
+  data: TypographyTokenData,
+});
+
+const StringTokenTypedData = z.object({
+  type: z.literal("String"),
+  data: StringTokenData,
+});
+
+const DimensionTokenTypedData = z.object({
+  type: z.literal("Dimension"),
+  data: DimensionTokenData,
+});
+
+const FontSizeTokenTypedData = z.object({
+  type: z.literal("FontSize"),
+  data: FontSizeTokenData,
+});
+
+const FontFamilyTokenTypedData = z.object({
+  type: z.literal("FontFamily"),
+  data: FontFamilyTokenData,
+});
+
+const FontWeightTokenTypedData = z.object({
+  type: z.literal("FontWeight"),
+  data: FontWeightTokenData,
+});
+
+const LetterSpacingTokenTypedData = z.object({
+  type: z.literal("LetterSpacing"),
+  data: LetterSpacingTokenData,
+});
+
+const LineHeightTokenTypedData = z.object({
+  type: z.literal("LineHeight"),
+  data: LineHeightTokenData,
+});
+
+const ParagraphSpacingTokenTypedData = z.object({
+  type: z.literal("ParagraphSpacing"),
+  data: ParagraphSpacingTokenData,
+});
+
+const TextCaseTokenTypedData = z.object({
+  type: z.literal("TextCase"),
+  data: TextCaseTokenData,
+});
+
+const TextDecorationTokenTypedData = z.object({
+  type: z.literal("TextDecoration"),
+  data: TextDecorationTokenData,
+});
+
+const BorderRadiusTokenTypedData = z.object({
+  type: z.literal("BorderRadius"),
+  data: BorderRadiusTokenData,
+});
+
+const BorderWidthTokenTypedData = z.object({
+  type: z.literal("BorderWidth"),
+  data: BorderWidthTokenData,
+});
+
+const BorderTypedData = z.object({
+  type: z.literal("Border"),
+  data: BorderTokenData,
+});
+
+const ProductCopyTypedData = z.object({
+  type: z.literal("ProductCopy"),
+  data: ProductCopyTokenData,
+});
+
+const SizeTypedData = z.object({
+  type: z.literal("Size"),
+  data: SizeTokenData,
+});
+
+const SpaceTypedData = z.object({
+  type: z.literal("Space"),
+  data: SpaceTokenData,
+});
+
+const VisibilityTypedData = z.object({
+  type: z.literal("Visibility"),
+  data: VisibilityTokenData,
+});
+
+const ZIndexTypedData = z.object({
+  type: z.literal("ZIndex"),
+  data: ZIndexTokenData,
+});
+
+const DurationTypedData = z.object({
+  type: z.literal("Duration"),
+  data: DurationTokenData,
+});
+
+const FontTypedData = z.object({
+  type: z.literal("Font"),
+  data: z.record(z.any()),
+});
+
+//
+// Global types
+//
+
+export const DesignTokenTypedData = z.discriminatedUnion("type", [
+  BlurTokenTypedData,
+  BorderRadiusTokenTypedData,
+  BorderWidthTokenTypedData,
+  BorderTypedData,
+  ColorTokenTypedData,
+
+  DimensionTokenTypedData,
+  DurationTypedData,
+  FontSizeTokenTypedData,
+  FontFamilyTokenTypedData,
+  FontWeightTokenTypedData,
+
+  GradientTokenTypedData,
+  LetterSpacingTokenTypedData,
+  LineHeightTokenTypedData,
+  OpacityTokenTypedData,
+  ParagraphSpacingTokenTypedData,
+
+  ProductCopyTypedData,
+  ShadowTokenTypedData,
+  SizeTypedData,
+  SpaceTypedData,
+  StringTokenTypedData,
+
+  TextCaseTokenTypedData,
+  TextDecorationTokenTypedData,
+  TypographyTokenTypedData,
+  VisibilityTypedData,
+  ZIndexTypedData,
+  FontTypedData,
+]);
+
+export type DesignTokenOriginPart = z.infer<typeof DesignTokenOriginPart>;
+export type DesignTokenOrigin = z.infer<typeof DesignTokenOrigin>;
+
+export type DesignTokenBase = z.infer<typeof DesignTokenBase>;
+
+export const DesignToken = DesignTokenTypedData.and(DesignTokenBase);
+export const CreateDesignToken = DesignTokenTypedData.and(CreateDesignTokenBase);
+
+export type DesignTokenTypedData = z.infer<typeof DesignTokenTypedData>;
+export type DesignTokenTypedDataOfType<T extends DesignTokenType> = Extract<DesignTokenTypedData, { type: T }>;
+
+export type DesignToken = z.infer<typeof DesignToken>;
+export type ImportedDesignToken = OmitStrict<DesignToken, "origin"> & { origin: DesignTokenOrigin };
+
+export type DesignTokenOfType<T extends DesignTokenType> = Extract<DesignToken, { type: T }>;
+export type ImportedDesignTokenOfType<T extends DesignTokenType> = Extract<ImportedDesignToken, { type: T }>;
+
+export type CreateDesignToken = z.infer<typeof CreateDesignToken>;
+export type UpdateDesignToken = OmitStrict<DbUpdate<DesignToken>, "brandPersistentId" | "designSystemVersionId">;
+
+export type DesignTokensDiff = {
+  toCreate: CreateDesignToken[];
+  toUpdate: UpdateDesignToken[];
+};
+
+//
+// Utilities
+//
+
+export function extractTokenTypedData<T extends DesignTokenType, I extends DesignTokenTypedDataOfType<T>>(
+  source: I
+): DesignTokenTypedDataOfType<T> {
+  return {
+    type: source.type,
+    data: source.data,
+  } as DesignTokenTypedDataOfType<T>;
+}
+
+export function isImportedDesignToken<T extends DesignTokenType>(
+  designToken: DesignTokenOfType<T>
+): designToken is ImportedDesignTokenOfType<T> {
+  return !!designToken.origin;
+}
+
+export function isDesignTokenOfType<T extends DesignTokenType>(
+  designToken: DesignToken,
+  type: T
+): designToken is DesignTokenOfType<T> {
+  return designToken.type === type;
+}
+
+export function designTokenTypeFilter<T extends DesignTokenType>(
+  type: T
+): (designToken: DesignToken) => designToken is DesignTokenOfType<T> {
+  return (designToken): designToken is DesignTokenOfType<T> => isDesignTokenOfType(designToken, type);
+}

package/src/dsm/import/asset.ts

@@ -0,0 +1,6 @@
+import { ComponentImportModelInput } from "./component";
+import { FigmaSvgRenderImportModel } from "./image";
+
+export type AssetImportModel = ComponentImportModelInput & {
+  svg: FigmaSvgRenderImportModel;
+};

package/src/dsm/import/base.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { DesignElementOrigin } from "../elements";
+import { ObjectMeta } from "../../common";
+
+export const ImportModelBase = z.object({
+  id: z.string(),
+  meta: ObjectMeta,
+  origin: DesignElementOrigin,
+  brandPersistentId: z.string(),
+  sortOrder: z.number(),
+});
+
+export type ImportModelBase = z.infer<typeof ImportModelBase>;
+
+export const ImportModelInputBase = ImportModelBase.omit({
+  brandPersistentId: true,
+  origin: true,
+  sortOrder: true,
+}).extend({
+  originId: z.string(),
+  originMetadata: z.record(z.any()),
+});
+
+export type ImportModelInputBase = z.infer<typeof ImportModelInputBase>;

package/src/dsm/import/component.ts

@@ -0,0 +1,36 @@
+import { FigmaSvgRenderImportModel, ImageImportModel } from "./image";
+import { ComponentOrigin, ComponentOriginPart } from "../elements";
+import { z } from "zod";
+import { ImportModelBase, ImportModelInputBase } from "./base";
+
+//
+// Import model
+//
+
+const ComponentImportModelPart = z.object({
+  thumbnail: ImageImportModel,
+});
+
+export const ComponentImportModel = ImportModelBase.extend(ComponentImportModelPart.shape).extend({
+  isAsset: z.boolean(),
+  svg: FigmaSvgRenderImportModel.optional(),
+  origin: ComponentOrigin,
+});
+
+export type ComponentImportModel = z.infer<typeof ComponentImportModel>;
+
+//
+// Import model input
+//
+
+export const ComponentImportModelInput = ImportModelInputBase.extend(ComponentImportModelPart.shape).extend({
+  originMetadata: ComponentOriginPart,
+});
+
+export const AssetImportModelInput = ImportModelInputBase.extend(ComponentImportModelPart.shape).extend({
+  svg: FigmaSvgRenderImportModel,
+  originMetadata: ComponentOriginPart,
+});
+
+export type ComponentImportModelInput = z.infer<typeof ComponentImportModelInput>;
+export type AssetImportModelInput = z.infer<typeof AssetImportModelInput>;

package/src/dsm/import/data-source.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+
+export const DataSourceImportModel = z.object({
+  id: z.string(),
+  fileName: z.string().optional(),
+  thumbnailUrl: z.string().optional(),
+});
+
+export type DataSourceImportModel = z.infer<typeof DataSourceImportModel>;