@supernova-studio/model 0.58.26 → 0.59.0

package/package.json

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

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/export/export-configuration.ts

@@ -0,0 +1,90 @@
+import { z } from "zod";
+
+//
+// Primitives
+//
+
+const PrimitiveValue = z.number().or(z.boolean()).or(z.string());
+const ArrayValue = z.array(z.string());
+const ObjectValue = z.record(z.string());
+
+export const ExporterPropertyDefinitionValue = PrimitiveValue.or(ArrayValue).or(ObjectValue);
+export const ExporterPropertyType = z.enum(["Enum", "Boolean", "String", "Number", "Array", "Object"]);
+
+export type ExporterPropertyDefinitionValue = z.infer<typeof ExporterPropertyDefinitionValue>;
+export type ExporterPropertyType = z.infer<typeof ExporterPropertyType>;
+
+//
+// Property
+//
+
+const PropertyDefinitionBase = z.object({
+  key: z.string(),
+  title: z.string(),
+  description: z.string(),
+});
+
+export const ExporterPropertyDefinitionEnum = PropertyDefinitionBase.extend({
+  type: z.literal(ExporterPropertyType.Enum.Enum),
+  options: z.string().array(),
+  default: z.string(),
+});
+
+export const ExporterPropertyDefinitionBoolean = PropertyDefinitionBase.extend({
+  type: z.literal(ExporterPropertyType.Enum.Boolean),
+  default: z.boolean(),
+});
+
+export const ExporterPropertyDefinitionString = PropertyDefinitionBase.extend({
+  type: z.literal(ExporterPropertyType.Enum.String),
+  default: z.string(),
+});
+
+export const ExporterPropertyDefinitionNumber = PropertyDefinitionBase.extend({
+  type: z.literal(ExporterPropertyType.Enum.Number),
+  default: z.number(),
+});
+
+export const ExporterPropertyDefinitionArray = PropertyDefinitionBase.extend({
+  type: z.literal(ExporterPropertyType.Enum.Array),
+  default: ArrayValue,
+});
+
+export const ExporterPropertyDefinitionObject = PropertyDefinitionBase.extend({
+  type: z.literal(ExporterPropertyType.Enum.Object),
+  default: ObjectValue,
+  allowedKeys: z
+    .object({
+      options: z.string().array(),
+      type: z.string(),
+    })
+    .optional(),
+  allowedValues: z
+    .object({
+      type: z.string(),
+    })
+    .optional(),
+});
+
+export const ExporterPropertyDefinition = z.discriminatedUnion("type", [
+  ExporterPropertyDefinitionEnum,
+  ExporterPropertyDefinitionBoolean,
+  ExporterPropertyDefinitionString,
+  ExporterPropertyDefinitionNumber,
+  ExporterPropertyDefinitionArray,
+  ExporterPropertyDefinitionObject,
+]);
+
+export type ExporterPropertyDefinitionEnum = z.infer<typeof ExporterPropertyDefinitionEnum>;
+export type ExporterPropertyDefinitionBoolean = z.infer<typeof ExporterPropertyDefinitionBoolean>;
+export type ExporterPropertyDefinitionString = z.infer<typeof ExporterPropertyDefinitionString>;
+export type ExporterPropertyDefinitionNumber = z.infer<typeof ExporterPropertyDefinitionNumber>;
+export type ExporterPropertyDefinitionArray = z.infer<typeof ExporterPropertyDefinitionArray>;
+export type ExporterPropertyDefinitionObject = z.infer<typeof ExporterPropertyDefinitionObject>;
+export type ExporterPropertyDefinition = z.infer<typeof ExporterPropertyDefinition>;
+//
+// Value
+//
+
+export const ExporterPropertyDefinitionValueMap = z.record(ExporterPropertyDefinitionValue);
+export type ExporterPropertyDefinitionValueMap = z.infer<typeof ExporterPropertyDefinitionValueMap>;

package/src/export/export-jobs.ts

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { PublishedDocEnvironment } from "../dsm";
 import { DbCreateInputOmit, DbUpdate, nullishToOptional } from "../helpers";
 import { ExportDestinationsMap } from "./export-destinations";
+import { ExporterPropertyDefinitionValueMap } from "./export-configuration";
 
 //
 // Enums
@@ -89,6 +90,7 @@ export const ExportJob = z.object({
   status: ExportJobStatus,
   result: ExportJobResult.optional(),
   createdByUserId: z.string().optional(),
+  exporterConfigurationProperties: ExporterPropertyDefinitionValueMap.optional(),
 
   // Destinations
   ...ExportDestinationsMap.shape,

package/src/export/export-runner/export-context.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { ExporterPropertyValue, PublishedDocEnvironment } from "../../dsm";
+import { ExporterPropertyDefinitionValueMap } from "../export-configuration";
 
 export const ExportJobDocumentationContext = z.object({
   isSingleVersionDocs: z.boolean(),
@@ -27,6 +28,7 @@ export const ExportJobContext = z.object({
 export const ExportJobExporterConfiguration = z.object({
   exporterPackageUrl: z.string(),
   exporterPropertyValues: ExporterPropertyValue.array(),
+  exporterConfigurationProperties: ExporterPropertyDefinitionValueMap.optional(),
 });
 
 export type ExportJobDocumentationContext = z.infer<typeof ExportJobDocumentationContext>;

package/src/export/exporter.ts

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { nullishToOptional } from "../helpers";
 import { GitProvider } from "./git-providers";
 import { PulsarContributionConfigurationProperty, PulsarContributionVariant, PulsarCustomBlock } from "./pulsar";
+import { ExporterPropertyDefinition } from "./export-configuration";
 
 export const ExporterType = z.enum(["code", "documentation"]);
 export const ExporterSource = z.enum(["git", "upload"]);
@@ -22,6 +23,7 @@ export const ExporterPulsarDetails = z.object({
   configurationProperties: nullishToOptional(z.array(PulsarContributionConfigurationProperty)).default([]),
   customBlocks: nullishToOptional(z.array(PulsarCustomBlock)).default([]),
   blockVariants: nullishToOptional(z.record(z.string(), z.array(PulsarContributionVariant))).default({}),
+  properties: nullishToOptional(ExporterPropertyDefinition.array()),
 
   usesBrands: nullishToOptional(z.boolean()).default(false),
   usesThemes: nullishToOptional(z.boolean()).default(false),
@@ -45,6 +47,7 @@ export const Exporter = z.object({
   details: ExporterDetails,
   exporterType: nullishToOptional(ExporterType).default("code"),
   storagePath: nullishToOptional(z.string()).default(""),
+  properties: nullishToOptional(ExporterPropertyDefinition.array()),
 });
 
 export type ExporterType = z.infer<typeof ExporterType>;

package/src/export/index.ts

@@ -1,4 +1,5 @@
 export * from "./export-runner";
+export * from "./export-configuration";
 export * from "./export-destinations";
 export * from "./export-jobs";
 export * from "./exporter-workspace-membership-role";

package/src/export/pipeline.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { ExportDestinationsMap } from "./export-destinations";
+import { ExporterPropertyDefinitionValueMap } from "./export-configuration";
 
 export const PipelineEventType = z.enum(["OnVersionReleased", "OnHeadChanged", "OnSourceUpdated", "None"]);
 
@@ -21,6 +22,7 @@ export const Pipeline = z.object({
   brandPersistentId: z.string().optional(),
   themePersistentId: z.string().optional(),
   themePersistentIds: z.string().array().optional(),
+  exporterConfigurationProperties: ExporterPropertyDefinitionValueMap.optional(),
 
   // Destinations
   ...ExportDestinationsMap.shape,

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({