@supernova-studio/model 0.58.27 → 0.59.1

package/package.json

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

package/src/dsm/elements/data/figma-node-reference.ts

@@ -1,27 +1,55 @@
 import { z } from "zod";
+import { nullishToOptional } from "../../../helpers/nullish-to-optional";
 
+//
+// Enums
+//
+
+export const FigmaNodeRenderState = z.enum(["InProgress", "Success", "Failed"]);
 export const FigmaNodeRenderFormat = z.enum(["Png", "Svg"]);
+export const FigmaNodeRenderErrorType = z.enum(["MissingIntegration", "NodeNotFound", "RenderError"]);
+
+export type FigmaNodeRenderState = z.infer<typeof FigmaNodeRenderState>;
+export type FigmaNodeRenderFormat = z.infer<typeof FigmaNodeRenderFormat>;
+export type FigmaNodeRenderErrorType = z.infer<typeof FigmaNodeRenderErrorType>;
+
+//
+// Definition
+//
+
+export const FigmaNodeRelinkData = z.object({
+  fileId: z.string(),
+});
+
+export const FigmaNodeRenderedImage = z.object({
+  resourceId: z.string(),
+  format: FigmaNodeRenderFormat,
+  scale: nullishToOptional(z.number()),
+
+  width: nullishToOptional(z.number()),
+  height: nullishToOptional(z.number()),
+  url: nullishToOptional(z.string()),
+  originKey: nullishToOptional(z.string()),
+});
+
+export const FigmaNodeRenderError = z.object({
+  type: FigmaNodeRenderErrorType,
+});
 
 export const FigmaNodeReferenceData = z.object({
-  structureElementId: z.string(),
   nodeId: z.string(),
-  fileId: z.string().optional(),
-  valid: z.boolean(),
-  format: FigmaNodeRenderFormat.default("Png"),
-
-  // Asset data
-  assetId: z.string().optional(),
-  assetScale: z.number().optional(),
-  assetWidth: z.number().optional(),
-  assetHeight: z.number().optional(),
-  assetUrl: z.string().optional(),
-  assetOriginKey: z.string().optional(),
-});
+  format: FigmaNodeRenderFormat,
+  scale: nullishToOptional(z.number()),
+
+  renderState: FigmaNodeRenderState,
+  renderedImage: FigmaNodeRenderedImage.optional(),
+  renderError: FigmaNodeRenderError.optional(),
 
-export const FigmaNodeReferenceElementData = z.object({
-  value: FigmaNodeReferenceData,
+  hasSource: z.boolean(),
+  relinkData: FigmaNodeRelinkData.optional(),
 });
 
-export type FigmaNodeRenderFormat = z.infer<typeof FigmaNodeRenderFormat>;
+export type FigmaNodeRelinkData = z.infer<typeof FigmaNodeRelinkData>;
+export type FigmaNodeRenderedImage = z.infer<typeof FigmaNodeRenderedImage>;
+export type FigmaNodeRenderError = z.infer<typeof FigmaNodeRenderError>;
 export type FigmaNodeReferenceData = z.infer<typeof FigmaNodeReferenceData>;
-export type FigmaNodeReferenceElementData = z.infer<typeof FigmaNodeReferenceElementData>;

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

@@ -93,14 +93,32 @@ const stringTokenTypes: Set<DesignTokenType> = new Set([
   "FontWeight",
 ] satisfies DesignTokenType[]);
 
-export function areTokenTypesCompatible(lhs: DesignTokenType, rhs: DesignTokenType): boolean {
+const fallbackNumberValue = 14;
+
+export function areTokenTypesCompatible(
+  lhs: DesignTokenType,
+  rhs: DesignTokenType,
+  isNonCompatibleTypeChangesEnabled = false
+): boolean {
   if (lhs === rhs) return true;
   if (numberTokenTypes.has(lhs) && numberTokenTypes.has(rhs)) return true;
   if (stringTokenTypes.has(lhs) && stringTokenTypes.has(rhs)) return true;
 
+  if (isNonCompatibleTypeChangesEnabled && stringTokenTypes.has(lhs) && numberTokenTypes.has(rhs)) return true;
+
   return false;
 }
 
+export function castStringToDimensionValue(lhs: DesignTokenType, rhs: DesignTokenType, value?: unknown) {
+  if (stringTokenTypes.has(lhs) && numberTokenTypes.has(rhs) && value) {
+    const newValue = Number.parseFloat(value?.toString() ?? "");
+    const measure = Number.isNaN(newValue) ? fallbackNumberValue : newValue;
+    return { unit: "Pixels", measure };
+  }
+
+  return value;
+}
+
 //
 // Element category
 //

package/src/dsm/elements/tokens.ts

@@ -35,7 +35,7 @@ import {
   VisibilityTokenData,
   ZIndexTokenData,
 } from "./data";
-import { areTokenTypesCompatible, DesignTokenType } from "./raw-element";
+import { areTokenTypesCompatible, castStringToDimensionValue, DesignTokenType } from "./raw-element";
 
 //
 // Base
@@ -279,15 +279,21 @@ export function extractTokenTypedData<T extends DesignTokenType, I extends Desig
 
 export function convertTokenTypedData<I extends DesignTokenType, O extends DesignTokenType>(
   source: DesignTokenTypedDataOfType<I>,
-  type: O
+  type: O,
+  isNonCompatibleTypeChangesEnabled: boolean
 ): DesignTokenTypedDataOfType<O> {
-  if (!areTokenTypesCompatible(source.type, type)) {
+  if (!areTokenTypesCompatible(source.type, type, isNonCompatibleTypeChangesEnabled)) {
     throw SupernovaException.invalidOperation(`Cannot convert token from ${source.type} to ${type}`);
   }
 
+  const data = source.data;
+  if (isNonCompatibleTypeChangesEnabled) {
+    data.value = castStringToDimensionValue(source.type, type, source.data.value);
+  }
+
   return {
-    type: type,
-    data: source.data,
+    type,
+    data,
   } as DesignTokenTypedDataOfType<O>;
 }
 

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

@@ -60,6 +60,7 @@ export const FeatureFlagsKeepAliases = z.object({
   isTypographyPropsKeepAliasesEnabled: z.boolean().default(false),
   isGradientPropsKeepAliasesEnabled: z.boolean().default(false),
   isShadowPropsKeepAliasesEnabled: z.boolean().default(false),
+  isNonCompatibleTypeChangesEnabled: z.boolean().default(false),
 });
 export type FeatureFlagsKeepAliases = z.infer<typeof FeatureFlagsKeepAliases>;
 

package/src/feature-flags/feature-flags.ts

@@ -8,6 +8,7 @@ export const FlaggedFeature = z.enum([
   "TypographyPropsKeepAliases",
   "GradientPropsKeepAliases",
   "ShadowPropsKeepAliases",
+  "NonCompatibleTypeChanges",
 ]);
 export const FeatureFlagMap = z.record(FlaggedFeature, z.boolean());
 export const FeatureFlag = z.object({