@supernova-studio/supernova-sdk-beta 1.6.13 → 1.6.14

package/build/sdk-typescript/src/tests/FigmaTokensDataLoader.d.ts

@@ -3,6 +3,19 @@ import { DTPluginToSupernovaMapPack, DTPluginToSupernovaSettings } from "../tool
 export declare class FigmaTokensDataLoader {
     static sync(instance: Supernova, designSystemId: string, versionId: string, basePath: string[], dataPath?: string[], mappingPath?: string[], root?: string): Promise<void>;
     static syncPath(instance: Supernova, designSystemId: string, versionId: string, basePath: string, dataPath?: string, mappingPath?: string, root?: string): Promise<void>;
+    static loadTokenStudioPayload(basePath: string[], dataPath?: string[], mappingPath?: string[], root?: string): Promise<{
+        connection: {
+            name: string;
+        };
+        settings: DTPluginToSupernovaSettings;
+        mapping: {
+            supernovaBrand: string;
+            supernovaTheme: string;
+            tokensTheme: string;
+            tokenSets: string[];
+        }[];
+        payload: object;
+    }>;
     /** Load token definitions from path */
     loadTokensFromPath(pathToFile: string): object;
     loadTokensFromDirectory(pathToDirectory: string, settingsPath: string): object;

package/build/sdk-typescript/src/tests/validators.d.ts

@@ -75,7 +75,7 @@ export declare const validateTypographyToken: (t: any, tokens: Token[], name: st
 export declare const validateTypographyTokenRef: (t: any, tokens: Token[], description: string, refName: string, fontFamily: string, fontWeight: string, lineHeightMeasure: number, fontSizeMeasure: number, letterSpacingMeasure: number, paragraphSpacingMeasure: number, paragraphIndentMeasure: number, textDecoration: TextDecoration, textCase: TextCase) => void;
 export declare const validateTypographyTokenInnerRef: (t: any, tokens: Token[], name: string, fontFamily: string, fontWeight: string, lineHeightMeasure: number, fontSizeMeasure: number, letterSpacingMeasure: number, paragraphSpacingMeasure: number, paragraphIndentMeasure: number, textDecoration: TextDecoration, textCase: TextCase) => void;
 export declare const validateNoToken: (t: any, tokens: Token[], name: string) => void;
-export declare const validateTokenRef: (t: any, tokens: Token[], description: string, hex: string, name: string) => void;
+export declare const validateTokenRef: (t: any, tokens: Token[], description: string, hex: string, name: string, refDescription?: string) => void;
 export declare const validateTokensJustColorRef: (t: any, token: ColorToken, colorRef: ColorToken, name: string, hex: string, opacity?: number, colorRefId?: string, colorRefName?: string, refHex?: string, refOpacity?: number) => void;
 export declare const validateTokenJustColorRef: (t: any, tokens: Token[], name: string, hex: string, opacity?: number, colorRefId?: string, colorRefName?: string, refHex?: string, refOpacity?: number) => void;
 export declare const validateDimensionTokenRef: (t: any, tokens: Token[], description: string, refName: string, measure: number, unit: Unit) => void;

package/build/sdk-typescript/src/tools/design-tokens/SDKToolsDesignTokensPlugin.d.ts

@@ -6,6 +6,7 @@ import { Token } from "../../model/tokens/SDKToken";
 import { DTProcessedTokenNode } from "./utilities/SDKDTJSONConverter";
 import { DTPluginToSupernovaMap, DTPluginToSupernovaMapPack, DTPluginToSupernovaSettings } from "./utilities/SDKDTMapLoader";
 import { DTTokenMergeDiff } from "./utilities/SDKDTTokenMerger";
+import { AnyToken } from "../../model/tokens/SDKTokenValue";
 export type SupernovaToolsDesignTokensLoadingResult = {
     processedNodes: Array<DTProcessedTokenNode>;
     tokens: Array<Token>;
@@ -30,7 +31,7 @@ export declare class SupernovaToolsDesignTokensPlugin {
     private setTokensOrigin;
     /** Creates pure tree for validation purposes, ignoring any existing token state in workspaces. This method works offline. */
     createPureTokenTree(processedNodes: Array<DTProcessedTokenNode>, verbose: boolean): {
-        tokens: Array<Token>;
+        tokens: Array<AnyToken>;
         groups: Array<TokenGroup>;
     };
     /** Loads remote source connected to this tool, then merges tokens and groups with it, creating union. Can optionally write to the source as well */

package/build/sdk-typescript/src/tools/design-tokens/utilities/SDKDTJSONConverter.d.ts

@@ -1,11 +1,11 @@
 import { Brand } from "../../../model/base/SDKBrand";
 import { DTOriginalTokenType } from "../../../model/enums/SDKTokenType";
-import { Token } from "../../../model/tokens/SDKToken";
 import { DTParsedNode } from "./SDKDTJSONLoader";
 import { DTPluginToSupernovaMapPack } from "./SDKDTMapLoader";
 import { DTTokenReferenceResolver } from "./SDKDTTokenReferenceResolver";
-export type DTProcessedTokenNode = {
-    token: Token;
+import { AnyToken } from "../../../model/tokens/SDKTokenValue";
+export type DTProcessedTokenNode<T extends AnyToken = AnyToken> = {
+    token: T;
     originalType: DTOriginalTokenType;
     path: Array<string>;
     key: string;

package/build/sdk-typescript/src/tools/design-tokens/utilities/SDKDTThemeMerger.d.ts

@@ -12,6 +12,4 @@ export declare class DTThemeMerger {
     constructor(versionId: string);
     makeTheme(upstreamTokens: Array<Token>, upstreamGroups: Array<TokenGroup>, upstreamTheme: TokenTheme, processedNodes: Array<DTProcessedTokenNode>, preciseCopy?: boolean): TokenTheme;
     inlineTokens(themeReplica: TokenTheme, tokensInThemeButNotInUpstream: Map<string, DTProcessedTokenNode>): void;
-    buildKey(path: Array<string>, name: string): string;
-    buildPath(token: Token, groups: Array<TokenGroup>): Array<string>;
 }

package/build/sdk-typescript/src/tools/design-tokens/utilities/SDKDTTokenMerger.d.ts

@@ -1,5 +1,5 @@
 import { TokenGroup } from "../../../model/groups/SDKTokenGroup";
-import { Token } from "../../../model/tokens/SDKToken";
+import { AnyToken } from "../../../model/tokens/SDKTokenValue";
 import { DTProcessedTokenNode } from "./SDKDTJSONConverter";
 export type DTTokenMergeDiff = {
     toUpdate: Array<DTProcessedTokenNode>;
@@ -10,8 +10,7 @@ export type DTTokenMergeDiff = {
 /** Utility allowing merging of two pools of tokens */
 export declare class DTTokenMerger {
     static buildKey(path: Array<string>, name: string): string;
-    buildPath(token: Token, groups: Array<TokenGroup>): Array<string>;
     buildNodeMap(nodes: Array<DTProcessedTokenNode>): Map<string, DTProcessedTokenNode>;
-    convertBaseTokensToProcessedNode(tokens: Array<Token>, groups: Array<TokenGroup>): Array<DTProcessedTokenNode>;
-    makeTokensDiff(existing: Array<Token>, extracted: Array<DTProcessedTokenNode>, groups: Array<TokenGroup>): DTTokenMergeDiff;
+    convertBaseTokensToProcessedNode(tokens: Array<AnyToken>, groups: Array<TokenGroup>): Array<DTProcessedTokenNode>;
+    makeTokensDiff(existing: Array<AnyToken>, extracted: Array<DTProcessedTokenNode>, groups: Array<TokenGroup>): DTTokenMergeDiff;
 }

package/build/sdk-typescript/src/tools/design-tokens/utilities/SDKDTTokenReferenceResolver.d.ts

@@ -1,3 +1,4 @@
+import { TokenType } from "../../../model/enums/SDKTokenType";
 import { Token } from "../../../model/tokens/SDKToken";
 import { AnyToken } from "../../../model/tokens/SDKTokenValue";
 import { DTProcessedTokenNode } from "./SDKDTJSONConverter";
@@ -9,19 +10,22 @@ export declare class DTTokenReferenceResolver {
     addAtomicToken(token: DTProcessedTokenNode, indexOfNewNode: number): void;
     addAtomicTokens(tokens: Array<DTProcessedTokenNode>): void;
     unmappedValues(): Array<DTProcessedTokenNode>;
+    tokensOfType(type: TokenType): Array<Token>;
     lookupReferencedToken(reference: string): Token | undefined;
     lookupAllReferencedTokens(reference: string): Array<{
         token: Token;
         key: string;
         location: number;
+        dollarTypeReference: boolean;
     }> | undefined;
     replaceAllReferencedTokens(reference: string, replacements: Array<{
         token: Token;
         key: string;
         location: number;
+        dollarTypeReference: boolean;
     }>): string;
-    replaceToken(base: string, token: Token, key: string, location: number): string;
-    replaceAt(s: string, what: string, replacement: string, index: number): string;
+    replaceToken(base: string, token: Token, key: string, location: number, dollarTypeReference: boolean): string;
+    replaceAt(s: string, what: string, replacement: string, index: number, dollarTypeReference: boolean): string;
     replacableValue(token: Token): string;
     isBalancedReference(syntax: string): boolean;
     valueHasReference(value: string | object | number): boolean;
@@ -32,5 +36,12 @@ export declare class DTTokenReferenceResolver {
     findBracketStrings(str: string): {
         index: number;
         value: string;
+        dollarTypeReference: boolean;
     }[];
+    findDollarStrings(str: string): {
+        index: number;
+        value: string;
+        dollarTypeReference: boolean;
+    }[];
+    isDollarIdentifier(value: string): boolean;
 }

package/build/sdk-typescript/src/tools/design-tokens/utilities/collection/SDKDTTokenCollection.d.ts

@@ -2,7 +2,7 @@ import { DTProcessedTokenNode } from "../SDKDTJSONConverter";
 export declare class DTProcessedTokenNodeCollection {
     readonly index: Map<string, DTProcessedTokenNode>;
     readonly added: Set<string>;
-    readonly deleted: Map<string, DTProcessedTokenNode>;
+    readonly deleted: Map<string, DTProcessedTokenNode<import("../../../..").AnyToken>>;
     readonly dirty: Set<string>;
     readonly list: Array<DTProcessedTokenNode>;
     constructor(source: Array<DTProcessedTokenNode> | Map<string, DTProcessedTokenNode>);

package/build/sdk-typescript/src/tools/token-preview/TokenUtilPreviewSegmentGenerator.d.ts

@@ -1,5 +1,7 @@
 import { Token } from "../../model/tokens/SDKToken";
+import { ShadowTokenValue } from "../../model/tokens/SDKTokenValue";
 import { TokenUtilPreviewTokenValueSegment } from "./TokenUtilPreviewTypes";
 export declare class TokenUtilPreviewSegmentGenerator {
-    resolvedSegmentsForToken(token: Token, allTokens: Map<string, Token>): Array<TokenUtilPreviewTokenValueSegment | "separator">;
+    static resolvedSegmentsForToken(token: Token, allTokens: Map<string, Token>): Array<TokenUtilPreviewTokenValueSegment | "separator">;
+    static shadowValuesToSegments(layer: ShadowTokenValue | null, allTokens: Map<string, Token>): Array<TokenUtilPreviewTokenValueSegment | "separator">;
 }

package/build/sdk-typescript/src/utils/TokenUtils.d.ts

@@ -11,6 +11,7 @@ import { FontFamilyToken, FontWeightToken, ProductCopyToken, StringToken } from
 import { TextCaseToken } from "../model/tokens/SDKTextCaseToken";
 import { TextDecorationToken } from "../model/tokens/SDKTextDecorationToken";
 import { Token } from "../model/tokens/SDKToken";
+import { AnyTokenValue } from "../model/tokens/SDKTokenValue";
 import { TypographyToken } from "../model/tokens/SDKTypographyToken";
 import { VisibilityToken } from "../model/tokens/SDKVisibilityToken";
 type TokenMapCompletenessTypeCheck<T extends {
@@ -43,7 +44,38 @@ type ActualTypeToTokenMap = {
     [TokenType.duration]: DurationToken;
     [TokenType.zIndex]: ZIndexToken;
 };
+type ActualTypeToTokenClassMap = {
+    [TokenType.color]: typeof ColorToken;
+    [TokenType.typography]: typeof TypographyToken;
+    [TokenType.blur]: typeof BlurToken;
+    [TokenType.border]: typeof BorderToken;
+    [TokenType.shadow]: typeof ShadowToken;
+    [TokenType.gradient]: typeof GradientToken;
+    [TokenType.string]: typeof StringToken;
+    [TokenType.productCopy]: typeof ProductCopyToken;
+    [TokenType.fontFamily]: typeof FontFamilyToken;
+    [TokenType.fontWeight]: typeof FontWeightToken;
+    [TokenType.textCase]: typeof TextCaseToken;
+    [TokenType.textDecoration]: typeof TextDecorationToken;
+    [TokenType.visibility]: typeof VisibilityToken;
+    [TokenType.borderWidth]: typeof BorderWidthToken;
+    [TokenType.dimension]: typeof DimensionToken;
+    [TokenType.size]: typeof SizeToken;
+    [TokenType.space]: typeof SpaceToken;
+    [TokenType.opacity]: typeof OpacityToken;
+    [TokenType.fontSize]: typeof FontSizeToken;
+    [TokenType.lineHeight]: typeof LineHeightToken;
+    [TokenType.letterSpacing]: typeof LetterSpacingToken;
+    [TokenType.paragraphSpacing]: typeof ParagraphSpacingToken;
+    [TokenType.radius]: typeof RadiusToken;
+    [TokenType.duration]: typeof DurationToken;
+    [TokenType.zIndex]: typeof ZIndexToken;
+};
 export type TokenTypeMapToken = TokenMapCompletenessTypeCheck<ActualTypeToTokenMap>;
+type TokenClassMapCompletenessTypeCheck<T extends {
+    [key in TokenType]: new (...args: any[]) => TokenTypeMapToken[key];
+}> = T;
+export type TokenClassTypeMapToken = TokenClassMapCompletenessTypeCheck<ActualTypeToTokenClassMap>;
 export declare class TokenUtils {
     /** Map tokens for lookup */
     static tokensToReferenceMap(tokens: Array<Token>): Map<string, Token>;
@@ -109,5 +141,18 @@ export declare class TokenUtils {
     static replaceIdAcrossAllPossibleReferences(override: DTProcessedTokenNode, newId: string, allTokens: Array<DTProcessedTokenNode>): void;
     static replaceIdAcrossAllPossibleReferencesWithTokens(currentId: string, newId: string, allTokens: Array<Token>): void;
     static replaceIdForComplexTokens(token: AnyToken, currentId: string, newId: string): void;
+    static inlineValueIntoComplexTokens(token: AnyToken, candidateId: string, candidateValueToInline: AnyTokenValue): void;
+    static getRefIdsFromComplexTokens(token: AnyToken): string[];
+    static buildKey(path: Array<string>, name: string): string;
+    static buildPath(token: Token, groups: Array<TokenGroup>): Array<string>;
+    static mapTypeToPrefix: (type: TokenType) => string;
+    static mapTypeToPrefixBack: (type: TokenType) => string;
+    static mapTypeToPrefix2: (type: TokenType) => string;
+    static buildFallbackKey(node: Pick<DTProcessedTokenNode, 'path' | 'token'>): string;
+    static buildFallbackKeyBack(node: Pick<DTProcessedTokenNode, 'path' | 'token'>): string;
+    static buildFallbackKey2(node: Pick<DTProcessedTokenNode, 'path' | 'token'>): string;
+    static getTokenByKeyOrFallbackKeys<T extends DTProcessedTokenNode | Token>(node: Pick<DTProcessedTokenNode, 'path' | 'token'>, map: Map<string, T>): T | undefined;
+    static getKeysByKeyOrFallbackKeys<T extends DTProcessedTokenNode | Token>(node: Pick<DTProcessedTokenNode, 'path' | 'token'>): string[];
+    static getTokenByKeyOrBackwardKey(node: Pick<DTProcessedTokenNode, 'path' | 'token'>, map: Map<string, DTProcessedTokenNode>): DTProcessedTokenNode | undefined;
 }
 export {};