@supernova-studio/model 1.0.0 → 1.0.2

package/src/dsm/elements/utils.ts

@@ -1,114 +0,0 @@
-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/exporter-property-values-collection.ts

@@ -1,31 +0,0 @@
-import { z } from "zod";
-import { ColorTokenData, PageBlockAsset, TypographyTokenData } from "./elements";
-
-export const ExporterPropertyImageValue = z.object({
-  asset: PageBlockAsset.optional(),
-  assetId: z.string().optional(),
-  assetUrl: z.string().optional(),
-});
-
-export const ExporterPropertyValue = z.object({
-  key: z.string(),
-  value: z.union([
-    z.number(),
-    z.string(),
-    z.boolean(),
-    ExporterPropertyImageValue,
-    ColorTokenData,
-    TypographyTokenData,
-  ]),
-});
-
-export const ExporterPropertyValuesCollection = z.object({
-  id: z.string(),
-  designSystemId: z.string(),
-  exporterId: z.string(),
-  values: z.array(ExporterPropertyValue),
-});
-
-export type ExporterPropertyImageValue = z.infer<typeof ExporterPropertyImageValue>;
-export type ExporterPropertyValue = z.infer<typeof ExporterPropertyValue>;
-export type ExporterPropertyValuesCollection = z.infer<typeof ExporterPropertyValuesCollection>;

package/src/dsm/import/asset.ts

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

package/src/dsm/import/base.ts

@@ -1,24 +0,0 @@
-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/collection.ts

@@ -1,16 +0,0 @@
-import { z } from "zod";
-import { CollectionOrigin } from "../collection";
-
-export const CollectionImportModelInput = z.object({
-  id: z.string(),
-  name: z.string(),
-});
-
-export const CollectionImportModel = z.object({
-  id: z.string(),
-  name: z.string(),
-  origin: CollectionOrigin,
-});
-
-export type CollectionImportModelInput = z.infer<typeof CollectionImportModelInput>;
-export type CollectionImportModel = z.infer<typeof CollectionImportModel>;

package/src/dsm/import/component.ts

@@ -1,40 +0,0 @@
-import { z } from "zod";
-import { FigmaComponentOrigin, FigmaComponentOriginPart, FigmaComponentPropertyMap } from "../elements";
-import { ImportModelBase, ImportModelInputBase } from "./base";
-import { FigmaSvgRenderImportModel, ImageImportModel } from "./image";
-
-//
-// Import model
-//
-
-const FigmaComponentImportModelPart = z.object({
-  thumbnail: ImageImportModel,
-  parentComponentId: z.string().optional(),
-  componentPropertyDefinitions: FigmaComponentPropertyMap.optional(),
-  variantPropertyValues: z.record(z.string()).optional(),
-  renderNodeId: z.string(),
-});
-
-export const FigmaComponentImportModel = ImportModelBase.extend(FigmaComponentImportModelPart.shape).extend({
-  isAsset: z.boolean(),
-  svg: FigmaSvgRenderImportModel.optional(),
-  origin: FigmaComponentOrigin,
-});
-
-export type FigmaComponentImportModel = z.infer<typeof FigmaComponentImportModel>;
-
-//
-// Import model input
-//
-
-export const FigmaComponentImportModelInput = ImportModelInputBase.extend(FigmaComponentImportModelPart.shape).extend({
-  originMetadata: FigmaComponentOriginPart,
-});
-
-export const AssetImportModelInput = ImportModelInputBase.extend(FigmaComponentImportModelPart.shape).extend({
-  svg: FigmaSvgRenderImportModel,
-  originMetadata: FigmaComponentOriginPart,
-});
-
-export type FigmaComponentImportModelInput = z.infer<typeof FigmaComponentImportModelInput>;
-export type AssetImportModelInput = z.infer<typeof AssetImportModelInput>;

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

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

package/src/dsm/import/figma-frames.ts

@@ -1,74 +0,0 @@
-import { ZodTypeDef, z } from "zod";
-import { FigmaFileStructureNodeBase, FigmaFileStructureOrigin, FigmaFileStructureStatistics } from "../elements";
-import { ImportModelBase, ImportModelInputBase } from "./base";
-import { FigmaPngRenderImportModel, FigmaSvgRenderImportModel } from "./image";
-
-//
-// Nodes Import Model
-//
-
-const FigmaFileStructureNodeImportModelBase = FigmaFileStructureNodeBase.extend({
-  png: FigmaPngRenderImportModel,
-  svg: FigmaSvgRenderImportModel,
-});
-
-export const FigmaFileStructureNodeImportModel: z.ZodType<
-  FigmaFileStructureNodeImportModel,
-  ZodTypeDef,
-  FigmaFileStructureNodeImportModelBaseInput
-> = FigmaFileStructureNodeImportModelBase.extend({
-  children: z.lazy(() => FigmaFileStructureNodeImportModel.array()),
-});
-
-type FigmaFileStructureNodeImportModelBaseInput = z.input<typeof FigmaFileStructureNodeImportModelBase> & {
-  children: FigmaFileStructureNodeImportModelBaseInput[];
-};
-
-export type FigmaFileStructureNodeImportModel = z.infer<typeof FigmaFileStructureNodeImportModelBase> & {
-  children: FigmaFileStructureNodeImportModel[];
-};
-
-//
-// Structure Import Model
-//
-
-const FigmaFileStructureImportModelPart = z.object({
-  data: z.object({
-    rootNode: FigmaFileStructureNodeImportModel,
-    assetsInFile: FigmaFileStructureStatistics,
-  }),
-});
-
-export const FigmaFileStructureImportModel = ImportModelBase.extend(FigmaFileStructureImportModelPart.shape).extend({
-  origin: FigmaFileStructureOrigin,
-});
-
-export type FigmaFileStructureImportModel = z.infer<typeof FigmaFileStructureImportModel>;
-
-//
-// Import model input
-//
-
-export const FigmaFileStructureImportModelInput = ImportModelInputBase.extend(
-  FigmaFileStructureImportModelPart.shape
-).extend({
-  fileVersionId: z.string(),
-});
-
-export type FigmaFileStructureImportModelInput = z.infer<typeof FigmaFileStructureImportModelInput>;
-
-export function figmaFileStructureImportModelToMap(
-  root: FigmaFileStructureNodeImportModel
-): Map<string, FigmaFileStructureNodeImportModel> {
-  const map = new Map<string, FigmaFileStructureNodeImportModel>();
-  recursiveFigmaFileStructureToMap(root, map);
-  return map;
-}
-
-function recursiveFigmaFileStructureToMap(
-  node: FigmaFileStructureNodeImportModel,
-  map: Map<string, FigmaFileStructureNodeImportModel>
-) {
-  map.set(node.id, node);
-  for (const child of node.children) recursiveFigmaFileStructureToMap(child, map);
-}

package/src/dsm/import/image.ts

@@ -1,87 +0,0 @@
-import { z } from "zod";
-import { AssetScope } from "../assets";
-
-//
-// Abstract
-//
-
-export const ImageImportModelType = z.enum(["Url", "FigmaRender"]);
-export type ImageImportModelType = z.infer<typeof ImageImportModelType>;
-
-const ImageImportModelBase = z.object({
-  scope: AssetScope,
-});
-
-//
-// Url
-//
-
-export const UrlImageImportModel = ImageImportModelBase.extend({
-  type: z.literal(ImageImportModelType.enum.Url),
-  url: z.string(),
-  originKey: z.string(),
-  extension: z.string(),
-});
-
-export type UrlImageImportModel = z.infer<typeof UrlImageImportModel>;
-
-//
-// Figma Render
-//
-
-export const FigmaRenderFormat = z.enum(["Svg", "Png", "Pdf"]);
-
-const FigmaRenderBase = ImageImportModelBase.extend({
-  type: z.literal(ImageImportModelType.enum.FigmaRender),
-  fileId: z.string(),
-  fileVersionId: z.string().optional(),
-  nodeId: z.string(),
-  originKey: z.string(),
-});
-
-export const FigmaPngRenderImportModel = FigmaRenderBase.extend({
-  format: z.literal(FigmaRenderFormat.enum.Png),
-  scale: z.number(),
-});
-
-export const FigmaSvgRenderImportModel = FigmaRenderBase.extend({
-  format: z.literal(FigmaRenderFormat.enum.Svg),
-});
-
-export const FigmaRenderImportModel = z.discriminatedUnion("format", [
-  FigmaPngRenderImportModel,
-  FigmaSvgRenderImportModel,
-]);
-
-//
-// Union
-//
-
-// Unfortunately discriminated union doesn't support inserting another discriminated union
-export const ImageImportModel = z.union([UrlImageImportModel, FigmaRenderImportModel]);
-
-//
-// Types
-//
-
-export type FigmaRenderFormat = z.infer<typeof FigmaRenderFormat>;
-export type FigmaRenderBase = z.infer<typeof FigmaRenderBase>;
-export type FigmaPngRenderImportModel = z.infer<typeof FigmaPngRenderImportModel>;
-export type FigmaSvgRenderImportModel = z.infer<typeof FigmaSvgRenderImportModel>;
-export type FigmaRenderImportModel = z.infer<typeof FigmaRenderImportModel>;
-export type ImageImportModel = z.infer<typeof ImageImportModel>;
-
-//
-// Utils
-//
-
-export function getFigmaRenderFormatFileExtension(format: FigmaRenderFormat): string {
-  switch (format) {
-    case "Pdf":
-      return "pdf";
-    case "Png":
-      return "png";
-    case "Svg":
-      return "svg";
-  }
-}

package/src/dsm/import/index.ts

@@ -1,12 +0,0 @@
-export * from "./support";
-export * from "./asset";
-export * from "./base";
-export * from "./collection";
-export * from "./component";
-export * from "./data-source";
-export * from "./figma-frames";
-export * from "./image";
-export * from "./origin";
-export * from "./theme";
-export * from "./tokens";
-export * from "./warning";

package/src/dsm/import/origin.ts

@@ -1,5 +0,0 @@
-export type DesignElementOriginImportModel = {
-  id: string;
-  name: string;
-  sourceId: string;
-};

package/src/dsm/import/support/figma-files.ts

@@ -1,19 +0,0 @@
-import { z } from "zod";
-
-export const FigmaFileDownloadScope = z.object({
-  styles: z.boolean(),
-  components: z.boolean(),
-  componentSets: z.boolean(),
-  currentVersion: z.literal("__latest__").nullable(),
-  publishedVersion: z.string().nullable(),
-  downloadChunkSize: z.number().optional(),
-  maxFileDepth: z.number().optional(),
-});
-
-export const FigmaFileAccessData = z.object({
-  accessToken: z.string(),
-  accessTokenType: z.enum(["OAuth2", "PAT"]).default("OAuth2"),
-});
-
-export type FigmaFileDownloadScope = z.infer<typeof FigmaFileDownloadScope>;
-export type FigmaFileAccessData = z.infer<typeof FigmaFileAccessData>;

package/src/dsm/import/support/import-context.ts

@@ -1,94 +0,0 @@
-import { z } from "zod";
-import { DataSourceFigmaImportMetadata, DataSourceFigmaRemote } from "../../data-sources";
-import { ImportWarning } from "../warning";
-import { FigmaFileAccessData, FigmaFileDownloadScope } from "./figma-files";
-
-//
-// Importer payload
-//
-
-export const ImportFunctionInput = z.object({
-  importJobId: z.string(),
-  importContextId: z.string(),
-  designSystemId: z.string().optional(),
-});
-
-export type ImportFunctionInput = z.infer<typeof ImportFunctionInput>;
-
-//
-// Base context
-//
-
-export const ImportedFigmaSourceData = z.object({
-  sourceId: z.string(),
-  figmaRemote: DataSourceFigmaRemote,
-});
-
-export const FigmaImportBaseContext = z.object({
-  designSystemId: z.string(),
-
-  /**
-   * Data required for accessing Figma files. This should contain access data for all file ids
-   * mentioned in the `importedSourceDataBySourceId`
-   *
-   * fileId: file data
-   */
-  fileAccessByFileId: z.record(FigmaFileAccessData),
-
-  /**
-   * Figma source data for which import was requested
-   *
-   * sourceId: source data
-   */
-  importedSourceDataBySourceId: z.record(ImportedFigmaSourceData),
-
-  /**
-   * Array of warnings that will be written into the import result summary at the end
-   * of import job execution and displayed by the client.
-   */
-  importWarnings: z.record(ImportWarning.array()).default({}),
-});
-
-export type ImportedFigmaSourceData = z.infer<typeof ImportedFigmaSourceData>;
-export type FigmaImportBaseContext = z.infer<typeof FigmaImportBaseContext>;
-
-//
-// Context with source state updates
-//
-
-export const FigmaImportContextWithSourcesState = FigmaImportBaseContext.extend({
-  sourcesWithMissingAccess: z.array(z.string()).default([]),
-  shadowOpacityOptional: z.boolean().default(false),
-  typographyPropsKeepAliases: z.boolean().default(false),
-});
-
-export type FigmaImportContextWithSourcesState = z.infer<typeof FigmaImportContextWithSourcesState>;
-
-//
-// Context with file download scope
-//
-
-export const ChangedImportedFigmaSourceData = ImportedFigmaSourceData.extend({
-  importMetadata: DataSourceFigmaImportMetadata,
-});
-
-export const FigmaImportContextWithDownloadScopes = FigmaImportContextWithSourcesState.extend({
-  /**
-   * Describes what to download from each file, this should contain all file id mentioned in
-   * importMetadataBySourceId.
-   *
-   * File id -> file download scope
-   */
-  fileDownloadScopesByFileId: z.record(FigmaFileDownloadScope),
-
-  /**
-   * Sources filtered down to the ones that have changed since last import and therefore need to be
-   * imported again.
-   *
-   * Source id -> import metadata
-   */
-  changedImportedSourceDataBySourceId: z.record(ChangedImportedFigmaSourceData),
-});
-
-export type ChangedImportedFigmaSourceData = z.infer<typeof ChangedImportedFigmaSourceData>;
-export type FigmaImportContextWithDownloadScopes = z.infer<typeof FigmaImportContextWithDownloadScopes>;

package/src/dsm/import/support/import-model-collections.ts

@@ -1,50 +0,0 @@
-import { z } from "zod";
-import { CollectionImportModel, CollectionImportModelInput } from "../collection";
-import { AssetImportModelInput, FigmaComponentImportModel, FigmaComponentImportModelInput } from "../component";
-import { DataSourceImportModel } from "../data-source";
-import { FigmaFileStructureImportModel, FigmaFileStructureImportModelInput } from "../figma-frames";
-import { ThemeImportModel, ThemeImportModelInput, ThemeUpdateImportModel, ThemeUpdateImportModelInput } from "../theme";
-import { DesignTokenImportModel, DesignTokenImportModelInput } from "../tokens";
-
-//
-// Collections
-//
-
-export const ImportModelInputCollection = z.object({
-  source: DataSourceImportModel,
-  tokens: z.array(DesignTokenImportModelInput).default([]),
-  components: z.array(FigmaComponentImportModelInput).default([]),
-  assets: z.array(AssetImportModelInput).default([]),
-  themeUpdates: z.array(ThemeUpdateImportModelInput).default([]),
-  themes: z.array(ThemeImportModelInput).default([]),
-  figmaFileStructure: FigmaFileStructureImportModelInput.optional(),
-  collections: z.array(CollectionImportModelInput),
-});
-
-export const ImportModelCollection = z.object({
-  sources: z.array(DataSourceImportModel),
-  tokens: z.array(DesignTokenImportModel).default([]),
-  components: z.array(FigmaComponentImportModel).default([]),
-  themeUpdates: z.array(ThemeUpdateImportModel).default([]),
-  themes: z.array(ThemeImportModel).default([]),
-  figmaFileStructures: z.array(FigmaFileStructureImportModel),
-  collections: z.array(CollectionImportModel),
-});
-
-export type ImportModelCollection = z.infer<typeof ImportModelCollection>;
-export type ImportModelInputCollection = z.infer<typeof ImportModelInputCollection>;
-
-export function addImportModelCollections(
-  lhs: ImportModelCollection,
-  rhs: ImportModelCollection
-): ImportModelCollection {
-  return {
-    sources: [...lhs.sources, ...rhs.sources],
-    tokens: [...lhs.tokens, ...rhs.tokens],
-    components: [...lhs.components, ...rhs.components],
-    themeUpdates: [...lhs.themeUpdates, ...rhs.themeUpdates],
-    themes: [...lhs.themes, ...rhs.themes],
-    figmaFileStructures: [...lhs.figmaFileStructures, ...rhs.figmaFileStructures],
-    collections: [...lhs.collections, ...rhs.collections],
-  };
-}

package/src/dsm/import/support/index.ts

@@ -1,3 +0,0 @@
-export * from "./figma-files";
-export * from "./import-context";
-export * from "./import-model-collections";

package/src/dsm/import/theme.ts

@@ -1,76 +0,0 @@
-import { z } from "zod";
-import { DesignTokenTypedData } from "../elements";
-import { DesignTokenType } from "../elements";
-import { ThemeOriginObject, ThemeOriginSource, ThemeOverrideOrigin, ThemeOverrideOriginPart } from "../elements";
-import { ObjectMeta } from "../../common";
-
-//
-// Overrides
-//
-
-export const ThemeOverrideImportModelBase = DesignTokenTypedData.and(
-  z.object({
-    id: z.string(),
-    meta: ObjectMeta,
-  })
-);
-
-export const ThemeOverrideImportModel = ThemeOverrideImportModelBase.and(
-  z.object({
-    origin: ThemeOverrideOrigin,
-  })
-);
-
-export const ThemeOverrideImportModelInput = ThemeOverrideImportModelBase.and(
-  z.object({
-    originId: z.string(),
-    originMetadata: ThemeOverrideOriginPart,
-  })
-);
-
-export type ThemeOverrideImportModel = z.infer<typeof ThemeOverrideImportModel>;
-export type ThemeOverrideImportModelOfType<T extends DesignTokenType> = Extract<ThemeOverrideImportModel, { type: T }>;
-
-export type ThemeOverrideImportModelInput = z.infer<typeof ThemeOverrideImportModelInput>;
-export type ThemeOverrideImportModelInputOfType<T extends DesignTokenType> = Extract<
-  ThemeOverrideImportModelInput,
-  { type: T }
->;
-
-//
-// Themes
-//
-
-export const ThemeImportModel = z.object({
-  meta: ObjectMeta,
-  brandPersistentId: z.string(),
-  originSource: ThemeOriginSource,
-  overrides: z.array(ThemeOverrideImportModel),
-  sortOrder: z.number(),
-});
-
-export const ThemeImportModelInput = z.object({
-  meta: ObjectMeta,
-  originObjects: z.array(ThemeOriginObject),
-  overrides: z.array(ThemeOverrideImportModelInput),
-});
-
-export type ThemeImportModel = z.infer<typeof ThemeImportModel>;
-export type ThemeImportModelInput = z.infer<typeof ThemeImportModelInput>;
-
-//
-// Theme Update
-//
-
-export const ThemeUpdateImportModel = z.object({
-  themePersistentId: z.string(),
-  overrides: z.array(ThemeOverrideImportModel),
-});
-
-export const ThemeUpdateImportModelInput = z.object({
-  themePersistentId: z.string(),
-  overrides: z.array(ThemeOverrideImportModelInput),
-});
-
-export type ThemeUpdateImportModel = z.infer<typeof ThemeUpdateImportModel>;
-export type ThemeUpdateImportModelInput = z.infer<typeof ThemeUpdateImportModelInput>;