@supernova-studio/model 1.0.0 → 1.0.2

package/src/dsm/elements/group.ts

@@ -1,40 +0,0 @@
-import { z } from "zod";
-import { DbCreateInputOmit, DbUpdate } from "../../helpers";
-import { OmitStrict } from "../../utils";
-import { DesignElementBase, DesignElementBrandedPart, DesignElementGroupablePart, DesignElementSlugPart } from "./base";
-import { ElementGroupDataV2 } from "./data";
-import { DesignElementType } from "./raw-element";
-
-export const ElementGroup = DesignElementBase.extend(DesignElementGroupablePart.shape)
-  .extend(DesignElementSlugPart.shape)
-  .extend(DesignElementBrandedPart.partial().shape)
-  .extend({
-    shortPersistentId: z.string().optional(),
-    childType: DesignElementType,
-    data: ElementGroupDataV2.optional(),
-  });
-
-export const BrandedElementGroup = ElementGroup.extend(DesignElementBrandedPart.shape);
-
-export type ElementGroup = z.infer<typeof ElementGroup>;
-export type BrandedElementGroup = z.infer<typeof BrandedElementGroup>;
-
-export type CreateElementGroup = OmitStrict<DbCreateInputOmit<ElementGroup>, "parentPersistentId"> & {
-  parentPersistentId: string;
-};
-
-export type UpdateElementGroup = DbUpdate<
-  OmitStrict<ElementGroup, "brandPersistentId" | "childType" | "designSystemVersionId" | "parentPersistentId"> & {
-    parentPersistentId: string;
-  }
->;
-
-export type RestoreElementGroup = OmitStrict<ElementGroup, "parentPersistentId"> & {
-  parentPersistentId: string;
-};
-
-export type ElementGroupsDiff = {
-  toCreate: CreateElementGroup[];
-  toUpdate: UpdateElementGroup[];
-  toDelete: ElementGroup["id"][];
-};

package/src/dsm/elements/index.ts

@@ -1,15 +0,0 @@
-export * from "./data";
-export * from "./primitives";
-export * from "./base";
-export * from "./component-properties";
-export * from "./documentation-page-v1";
-export * from "./documentation-page-v2";
-export * from "./figma-component";
-export * from "./figma-file-structures";
-export * from "./figma-node-reference";
-export * from "./group";
-export * from "./page-block-v2";
-export * from "./raw-element";
-export * from "./theme";
-export * from "./tokens";
-export * from "./utils";

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

@@ -1,25 +0,0 @@
-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(),
-  type: z.literal("Block"),
-  data: PageBlockDataV2,
-});
-
-export type PageBlockEditorModelV2 = z.infer<typeof PageBlockEditorModelV2>;

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

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

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

@@ -1,8 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,164 +0,0 @@
-import { z } from "zod";
-import { ObjectMeta } from "../../common";
-import { DbCreateInputOmit, DbUpdate } from "../../helpers";
-import { OmitStrict } from "../../utils";
-
-export type CreateDesignElement = DbCreateInputOmit<DesignElement>;
-export type UpdateDesignElement = OmitStrict<
-  DbUpdate<DesignElement>,
-  "brandPersistentId" | "childType" | "designSystemVersionId" | "shortPersistentId"
->;
-
-//
-// Token types
-//
-
-export const DesignTokenType = z.enum([
-  "Color",
-  "Border",
-  "Gradient",
-  "Shadow",
-  "Dimension",
-  "Duration",
-  "Size",
-  "Space",
-  "Opacity",
-  "FontSize",
-  "LineHeight",
-  "LetterSpacing",
-  "ParagraphSpacing",
-  "BorderWidth",
-  "BorderRadius",
-  "ZIndex",
-  "Image",
-  "String",
-  "ProductCopy",
-  "FontFamily",
-  "FontWeight",
-  "TextDecoration",
-  "TextCase",
-  "Visibility",
-  "Typography",
-  "Blur",
-  "Font",
-]);
-
-export const tokenElementTypes: 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;
-}
-
-const numberTokenTypes: Set<DesignTokenType> = new Set([
-  "Dimension",
-  "Duration",
-  "Size",
-  "Space",
-  "Opacity",
-  "FontSize",
-  "LineHeight",
-  "LetterSpacing",
-  "ParagraphSpacing",
-  "BorderWidth",
-  "BorderRadius",
-  "ZIndex",
-] satisfies DesignTokenType[]);
-
-const stringTokenTypes: Set<DesignTokenType> = new Set([
-  "String",
-  "ProductCopy",
-  "FontFamily",
-  "FontWeight",
-] satisfies DesignTokenType[]);
-
-export function areTokenTypesCompatible(lhs: DesignTokenType, rhs: DesignTokenType): boolean {
-  if (lhs === rhs) return true;
-  if (numberTokenTypes.has(lhs) && numberTokenTypes.has(rhs)) return true;
-  if (stringTokenTypes.has(lhs) && stringTokenTypes.has(rhs)) return true;
-
-  return false;
-}
-
-//
-// 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(),
-  collectionPersistentId: z.string().optional(),
-  parentPersistentId: z.string().optional(),
-  shortPersistentId: z.string().optional(),
-  childType: DesignElementType.optional(),
-  sortOrder: z.number(),
-  origin: z.record(z.any()).optional(),
-  createdAt: z.coerce.date(),
-  updatedAt: z.coerce.date(),
-});
-
-export const DesignElement = ShallowDesignElement.extend({
-  meta: ObjectMeta,
-  slug: z.string().optional(),
-  userSlug: z.string().optional(),
-  exportProperties: DesignSystemElementExportProps.optional(),
-  data: z.record(z.any()),
-  origin: z.record(z.any()).optional(),
-});
-
-export type ShallowDesignElement = z.infer<typeof ShallowDesignElement>;
-export type DesignElement = z.infer<typeof DesignElement>;
-
-export const HierarchicalElements = DesignTokenType.or(
-  z.enum(["Component", "DesignSystemComponent", "DocumentationPage"])
-);
-
-export type HierarchicalElements = z.infer<typeof HierarchicalElements>;

package/src/dsm/elements/theme.ts

@@ -1,76 +0,0 @@
-import { z } from "zod";
-import { DbCreateInputOmit, DbUpdate } from "../../helpers";
-import { OmitStrict } from "../../utils";
-import { DesignElementBase, DesignElementBrandedPart } from "./base";
-import { DesignTokenType } from "./raw-element";
-import { DesignTokenOrigin, DesignTokenOriginPart, DesignTokenTypedData } from "./tokens";
-
-//
-// 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),
-  codeName: z.string(),
-});
-
-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

@@ -1,311 +0,0 @@
-import { z } from "zod";
-import { DbUpdate, zodCreateInputOmit, zodUpdateInputOmit } from "../../helpers";
-import { OmitStrict, SupernovaException } from "../../utils";
-import {
-  DesignElementBase,
-  DesignElementBrandedPart,
-  DesignElementGroupableRequiredPart,
-  DesignElementOrigin,
-} from "./base";
-import {
-  BlurTokenData,
-  BorderRadiusTokenData,
-  BorderTokenData,
-  BorderWidthTokenData,
-  ColorTokenData,
-  DimensionTokenData,
-  DurationTokenData,
-  FontFamilyTokenData,
-  FontSizeTokenData,
-  FontTokenData,
-  FontWeightTokenData,
-  GradientTokenData,
-  LetterSpacingTokenData,
-  LineHeightTokenData,
-  OpacityTokenData,
-  ParagraphSpacingTokenData,
-  ProductCopyTokenData,
-  ShadowTokenData,
-  SizeTokenData,
-  SpaceTokenData,
-  StringTokenData,
-  TextCaseTokenData,
-  TextDecorationTokenData,
-  TypographyTokenData,
-  VisibilityTokenData,
-  ZIndexTokenData,
-} from "./data";
-import { areTokenTypesCompatible, DesignTokenType } from "./raw-element";
-
-//
-// Base
-//
-
-export const DesignTokenOriginPart = z.object({
-  referenceOriginId: z.string().optional(),
-  referenceOriginKey: z.string().optional(),
-  referenceOriginName: z.string().optional(),
-  referenceOriginRemote: z.boolean().optional(),
-  referencePersistentId: z.string().optional(),
-  referenceResolutionFailed: z.boolean().optional(),
-  key: z.string().optional(),
-  sortOrder: z.number().optional(),
-});
-
-export const DesignTokenOrigin = DesignElementOrigin.extend(DesignTokenOriginPart.shape);
-
-const DesignTokenBase = DesignElementBase.extend(DesignElementGroupableRequiredPart.shape)
-  .extend(DesignElementBrandedPart.shape)
-  .extend({
-    origin: DesignTokenOrigin.optional(),
-    collectionPersistentId: z.string().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: FontTokenData,
-});
-
-//
-// 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 convertTokenTypedData<I extends DesignTokenType, O extends DesignTokenType>(
-  source: DesignTokenTypedDataOfType<I>,
-  type: O
-): DesignTokenTypedDataOfType<O> {
-  if (!areTokenTypesCompatible(source.type, type)) {
-    throw SupernovaException.invalidOperation(`Cannot convert token from ${source.type} to ${type}`);
-  }
-
-  return {
-    type: type,
-    data: source.data,
-  } as DesignTokenTypedDataOfType<O>;
-}
-
-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);
-}