@supernova-studio/supernova-sdk-beta 1.6.10 → 1.6.12

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

@@ -1,2 +1,7 @@
-import { Supernova } from '../core/SDKSupernova';
+import { RemoteVersionIdentifier, RemoteWorkspaceVersionIdentifier } from "../core/areas/SDKRemoteIdentifiers";
+import { Supernova } from "../core/SDKSupernova";
 export declare const testInstance: Supernova;
+export declare const testVersionIdentifier: RemoteVersionIdentifier;
+export declare const testWorkspaceVersionIdentifier: RemoteWorkspaceVersionIdentifier;
+export declare const randomAlphabeticalOnlyIdentifier: (length: number) => string;
+export declare const randomNumberInRange: (min: number, max: number) => number;

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

@@ -0,0 +1,83 @@
+import { BorderPosition, ColorToken, ShadowType, TextCase, TextDecoration, Unit } from "../index";
+import { BorderStyle } from "../model/enums/SDKBorderStyle";
+import { StringTokenType } from "../model/enums/SDKTokenType";
+import { Token } from "../model/tokens/SDKToken";
+export declare const validateToken: (t: any, tokens: Token[], name: string, hex: string, opacity?: number) => void;
+export declare const validateDimensionToken: (t: any, tokens: Token[], name: string, measure: number, unit: Unit) => void;
+export declare const validateStringToken: (t: any, tokens: Token[], name: string, text: string, type: StringTokenType) => void;
+export declare const validateOptionToken: (t: any, tokens: Token[], name: string, text: string) => void;
+export declare const validateBorderToken: (t: any, tokens: Token[], name: string, hex: string, position: BorderPosition, style: BorderStyle, measure: number, unit: Unit) => void;
+export declare const validateShadowToken: (t: any, tokens: Token[], name: string, value: {
+    hex: string;
+    x: number;
+    y: number;
+    blur: number;
+    spread: number;
+    type: ShadowType;
+}, layers: Array<{
+    hex: string;
+    x: number;
+    y: number;
+    blur: number;
+    spread: number;
+    type: ShadowType;
+}>) => void;
+export declare const validateShadowTokenRef: (t: any, tokens: Token[], description: string, refName: string, value: {
+    hex: string;
+    x: number;
+    y: number;
+    blur: number;
+    spread: number;
+    type: ShadowType;
+}, layers: Array<{
+    hex: string;
+    x: number;
+    y: number;
+    blur: number;
+    spread: number;
+    type: ShadowType;
+}>) => void;
+export declare const validateShadowTokenRefMultiple: (t: any, tokens: Token[], description: string, layers: {
+    refName: string;
+    layers: Array<{
+        hex: string;
+        x: number;
+        y: number;
+        blur: number;
+        spread: number;
+        type: ShadowType;
+    }>;
+}[]) => void;
+export declare const validateShadowTokenInnerRef: (t: any, tokens: Token[], name: string, value: {
+    hex: string;
+    x: number;
+    xUnit: Unit;
+    y: number;
+    yUnit: Unit;
+    blur: number;
+    blurUnit: Unit;
+    spread: number;
+    spreadUnit: Unit;
+    type: ShadowType;
+}, layers: Array<{
+    hex: string;
+    x: number;
+    xUnit: Unit;
+    y: number;
+    yUnit: Unit;
+    blur: number;
+    blurUnit: Unit;
+    spread: number;
+    spreadUnit: Unit;
+    type: ShadowType;
+}>, allTokens: Map<string, Token>) => void;
+export declare const validateTypographyToken: (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 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 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;
+export declare const validateBorderTokenRef: (t: any, tokens: Token[], description: string, refName: string, hex: string, position: BorderPosition, style: BorderStyle, measure: number, unit: Unit) => void;
+export declare const validateBorderTokenInnerRef: (t: any, tokens: Token[], name: string, hex: string, position: BorderPosition, style: BorderStyle, measure: number, unit: Unit) => void;

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

@@ -1,36 +1,38 @@
-import { DesignSystemVersion } from '../../core/SDKDesignSystemVersion';
-import { TokenGroup } from '../../model/groups/SDKTokenGroup';
-import { Token } from '../../model/tokens/SDKToken';
-import { DTProcessedTokenNode } from './utilities/SDKDTJSONConverter';
-import { DTTokenMergeDiff } from './utilities/SDKDTTokenMerger';
-import { Brand } from '../../core/SDKBrand';
-import { TokenTheme } from '../../model/themes/SDKTokenTheme';
-import { DTPluginToSupernovaMap, DTPluginToSupernovaMapPack, DTPluginToSupernovaSettings } from './utilities/SDKDTMapLoader';
+import { Supernova } from "../../core/SDKSupernova";
+import { Brand } from "../../model/base/SDKBrand";
+import { TokenGroup } from "../../model/groups/SDKTokenGroup";
+import { TokenTheme } from "../../model/themes/SDKTokenTheme";
+import { Token } from "../../model/tokens/SDKToken";
+import { DTProcessedTokenNode } from "./utilities/SDKDTJSONConverter";
+import { DTPluginToSupernovaMap, DTPluginToSupernovaMapPack, DTPluginToSupernovaSettings } from "./utilities/SDKDTMapLoader";
+import { DTTokenMergeDiff } from "./utilities/SDKDTTokenMerger";
 export type SupernovaToolsDesignTokensLoadingResult = {
     processedNodes: Array<DTProcessedTokenNode>;
     tokens: Array<Token>;
     groups: Array<TokenGroup>;
 };
 export type SupernovaToolsDesignTokensResult = {
-    map: Pick<DTPluginToSupernovaMap, 'bindToBrand' | 'bindToTheme' | 'pluginSets' | 'pluginTheme' | 'type'>;
+    map: Pick<DTPluginToSupernovaMap, "bindToBrand" | "bindToTheme" | "pluginSets" | "pluginTheme" | "type">;
     tokensCreated: Array<string>;
     tokensUpdated: Array<string>;
     tokensDeleted: Array<string>;
 };
 /** Design Tokens Plugin Manipulation Tool */
 export declare class SupernovaToolsDesignTokensPlugin {
-    private version;
+    private instance;
+    private designSystemId;
+    private versionId;
     private sortMultiplier;
-    constructor(version: DesignSystemVersion);
+    constructor(designSystemId: string, versionId: string, instance: Supernova);
     synchronizeTokensFromData(data: object, mapping: DTPluginToSupernovaMapPack, settings: DTPluginToSupernovaSettings): Promise<boolean>;
     synchronizeTokensFromDataWithResults(data: object, mapping: DTPluginToSupernovaMapPack, settings: DTPluginToSupernovaSettings): Promise<SupernovaToolsDesignTokensResult[]>;
     private processTokenNodes;
     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): Promise<{
+    createPureTokenTree(processedNodes: Array<DTProcessedTokenNode>, verbose: boolean): {
         tokens: Array<Token>;
         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 */
     mergeWithRemoteSource(processedNodes: Array<DTProcessedTokenNode>, brand: Brand, write: boolean, verbose: boolean, preciseCopy: boolean): Promise<{
         tokens: Array<Token>;

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

@@ -1,32 +1,35 @@
-import { Brand } from '../../../core/SDKBrand';
-import { DesignSystemVersion } from '../../../core/SDKDesignSystemVersion';
-import { Token } from '../../../model/tokens/SDKToken';
-import { DTParsedNode } from './SDKDTJSONLoader';
-import { DTPluginToSupernovaMapPack } from './SDKDTMapLoader';
-import { DTTokenReferenceResolver } from './SDKDTTokenReferenceResolver';
+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;
-    originalType: string;
+    originalType: DTOriginalTokenType;
     path: Array<string>;
     key: string;
 };
 /** Utility to DS Tokens plugin JSON to Supernova entities */
 export declare class DTJSONConverter {
-    version: DesignSystemVersion;
+    versionId: string;
     mapping: DTPluginToSupernovaMapPack;
     referenceResolver: DTTokenReferenceResolver;
-    constructor(version: DesignSystemVersion, mapping: DTPluginToSupernovaMapPack);
+    constructor(versionId: string, mapping: DTPluginToSupernovaMapPack);
     convertNodesToTokens(nodes: Array<DTParsedNode>, brand: Brand): Array<DTProcessedTokenNode>;
     private remapRootNodeKeys;
     private convertNodesToTokensForSupportedNodeTypes;
     private convertAtomicNode;
     private convertColorAtomicNode;
-    private convertMeasureAtomicNode;
-    private convertRadiusAtomicNode;
+    private convertDimensionAtomicNode;
+    private convertStringAtomicNode;
+    private convertTextCaseAtomicNode;
+    private convertTextDecorationAtomicNode;
+    private convertVisibilityAtomicNode;
     private convertShadowAtomicNode;
     private convertBorderAtomicNode;
+    private convertGradientAtomicNode;
     private convertTypographyAtomicNode;
-    private convertGenericAtomicNode;
     private convertReferencedNode;
     private convertPureReferencedNode;
     private convertComplexReferenceNode;

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

@@ -1,6 +1,8 @@
-import { Brand, DesignSystemVersion, TokenGroup, TokenType } from '../../..';
-import { DTProcessedTokenNode } from './SDKDTJSONConverter';
-import { DTPluginToSupernovaMapPack } from './SDKDTMapLoader';
+import { Brand } from "../../../model/base/SDKBrand";
+import { TokenType } from "../../../model/enums/SDKTokenType";
+import { TokenGroup } from "../../../model/groups/SDKTokenGroup";
+import { DTProcessedTokenNode } from "./SDKDTJSONConverter";
+import { DTPluginToSupernovaMapPack } from "./SDKDTMapLoader";
 export type DTRootGroupMapping = {
     snType: TokenType;
     dtType: string;
@@ -9,13 +11,13 @@ export type DTRootGroupMapping = {
 };
 /** Utility for building token trees */
 export declare class DTJSONGroupBuilder {
-    version: DesignSystemVersion;
+    versionId: string;
     mapping: DTPluginToSupernovaMapPack;
-    constructor(version: DesignSystemVersion, mapping: DTPluginToSupernovaMapPack);
+    constructor(versionId: string, mapping: DTPluginToSupernovaMapPack);
     /** Create mapping between DT <> SN and assign all tokens into their respective newly created groups */
     constructAllDefinableGroupsTrees(processedNodes: Array<DTProcessedTokenNode>, brand: Brand): Array<TokenGroup>;
     /** Create group tree needed to contain entire token tree for particular mapping combination */
     constructGroupTree(processedNodes: Array<DTProcessedTokenNode>, mapping: DTRootGroupMapping, brand: Brand): Array<TokenGroup>;
-    constructGroupChain(version: DesignSystemVersion, brand: Brand, groups: Map<string, TokenGroup>, path: Array<string>): void;
+    constructGroupChain(versionId: string, brand: Brand, groups: Map<string, TokenGroup>, path: Array<string>): void;
     createGroup(brandId: string, versionId: string, name: string, type: TokenType, isRoot: boolean): TokenGroup;
 }

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

@@ -1,8 +1,9 @@
+import { DTOriginalTokenType } from "../../../model/enums/SDKTokenType";
 export type DTParsedNode = {
     rootKey: string;
     name: string;
     path: Array<string>;
-    type: string;
+    type: DTOriginalTokenType;
     value: any;
     description: string | null;
 };

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

@@ -1,8 +1,9 @@
+import { DTOriginalTokenType } from "../../../model/enums/SDKTokenType";
 export type DTParsedNode = {
     rootKey: string;
     name: string;
     path: Array<string>;
-    type: string;
+    type: DTOriginalTokenType;
     value: any;
     description: string | null;
 };
@@ -29,12 +30,13 @@ export declare enum DTParsedThemeSetPriority {
 export declare class DTJSONParser {
     themeBuffer: Array<DTParsedTheme>;
     constructor();
-    processPluginDataRepresentation(definition: object): Promise<{
+    processPluginDataRepresentation(definition: object): {
         nodes: Array<DTParsedNode>;
         themes: Array<DTParsedTheme>;
         sets: Array<DTParsedTokenSet>;
-    }>;
+    };
     private processThemes;
     private processSets;
     private parseNode;
+    private modifyEntityForParse;
 }

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

@@ -1,6 +1,6 @@
-import { TokenGroup } from '../../..';
-import { DTProcessedTokenNode } from './SDKDTJSONConverter';
-import { DTParsedNode } from './SDKDTJSONLoader';
+import { TokenGroup } from "../../../model/groups/SDKTokenGroup";
+import { DTProcessedTokenNode } from "./SDKDTJSONConverter";
+import { DTParsedNode } from "./SDKDTJSONLoader";
 export type DTPluginToSupernovaMapPack = Array<DTPluginToSupernovaMap>;
 export declare enum DTPluginToSupernovaMapType {
     theme = "theme",
@@ -17,7 +17,7 @@ export type DTPluginToSupernovaMap = {
     processedGroups: Array<TokenGroup> | null;
 };
 export type DTPluginToSupernovaMappingFile = {
-    mode: 'single-file' | 'multi-file';
+    mode: "single-file" | "multi-file";
     mapping: [
         {
             tokensTheme?: string;

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

@@ -1,10 +1,7 @@
-import { DesignSystemVersion } from '../../../core/SDKDesignSystemVersion';
-import { DTParsedTheme, DTParsedTokenSet } from './SDKDTJSONLoader';
-import { DTPluginToSupernovaMap } from './SDKDTMapLoader';
+import { DTParsedTheme, DTParsedTokenSet } from "./SDKDTJSONLoader";
+import { DTPluginToSupernovaMap } from "./SDKDTMapLoader";
 /** Utility to resolve token maps */
 export declare class DTMapResolver {
-    private version;
-    constructor(version: DesignSystemVersion);
     mappedNodePools(map: DTPluginToSupernovaMap, themes: Array<DTParsedTheme>, sets: Array<DTParsedTokenSet>): DTPluginToSupernovaMap;
     private computeUniqueNodesFromSets;
 }

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

@@ -1,17 +1,17 @@
-import { DesignSystemVersion } from "../../../core/SDKDesignSystemVersion";
-import { DTProcessedTokenNode } from "./SDKDTJSONConverter";
+import { TokenGroup } from "../../../model/groups/SDKTokenGroup";
 import { TokenTheme } from "../../../model/themes/SDKTokenTheme";
 import { Token } from "../../../model/tokens/SDKToken";
+import { DTProcessedTokenNode } from "./SDKDTJSONConverter";
 export type DTThemeMergeDiff = {
     toUpdate: Array<DTProcessedTokenNode>;
     toCreate: Array<DTProcessedTokenNode>;
 };
 /** Utility allowing merging of two pools of tokens */
 export declare class DTThemeMerger {
-    private version;
-    constructor(version: DesignSystemVersion);
-    makeTheme(upstreamTokens: Array<Token>, upstreamTheme: TokenTheme, processedNodes: Array<DTProcessedTokenNode>, preciseCopy?: boolean): TokenTheme;
-    replaceIdAcrossAllPossibleReferences(override: DTProcessedTokenNode, newId: string, allTokens: Array<DTProcessedTokenNode>): void;
+    private versionId;
+    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): Array<string>;
+    buildPath(token: Token, groups: Array<TokenGroup>): Array<string>;
 }

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

@@ -1,6 +1,7 @@
-import { Token, TokenGroup } from '../../..';
-import { DTTokenMergeDiff } from './SDKDTTokenMerger';
-import { TokenTreeElement } from './tree/SDKDTGroupTreeNode';
+import { TokenGroup } from "../../../model/groups/SDKTokenGroup";
+import { Token } from "../../../model/tokens/SDKToken";
+import { TokenTreeElement } from "./tree/SDKDTGroupTree";
+import { DTTokenMergeDiff } from "./SDKDTTokenMerger";
 export type DTTokenTreeMergeDiff = {
     toUpdate: Array<TokenTreeElement>;
     toCreate: Array<TokenTreeElement>;
@@ -11,13 +12,12 @@ export type DTGroupMergeDiffElement = {
     element: TokenTreeElement;
     childrenIds: Array<string>;
 };
-export declare class DTGroupMergeDiff {
+export type DTGroupMergeDiff = {
     toUpdate: Array<DTGroupMergeDiffElement>;
     toCreate: Array<DTGroupMergeDiffElement>;
     toDelete: Array<TokenTreeElement>;
-}
+};
 /** Utility allowing merging of two distinct token trees */
 export declare class DTTokenGroupTreeMerger {
-    constructor();
     makeGroupsDiff(tokensDiff: DTTokenMergeDiff, existingElements: Array<Token | TokenGroup>): DTGroupMergeDiff;
 }

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

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

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

@@ -1,13 +1,12 @@
-import { AnyToken } from '../../../model/tokens/SDKTokenValue';
-import { Token } from '../../../model/tokens/SDKToken';
-import { DTProcessedTokenNode } from './SDKDTJSONConverter';
+import { Token } from "../../../model/tokens/SDKToken";
+import { AnyToken } from "../../../model/tokens/SDKTokenValue";
+import { DTProcessedTokenNode } from "./SDKDTJSONConverter";
 /** Utility allowing resolution of token references */
 export declare class DTTokenReferenceResolver {
     private mappedTokens;
     private nodes;
-    constructor();
     replaceRefs(existingToken: AnyToken, newToken: AnyToken): void;
-    addAtomicToken(token: DTProcessedTokenNode): void;
+    addAtomicToken(token: DTProcessedTokenNode, indexOfNewNode: number): void;
     addAtomicTokens(tokens: Array<DTProcessedTokenNode>): void;
     unmappedValues(): Array<DTProcessedTokenNode>;
     lookupReferencedToken(reference: string): Token | undefined;
@@ -29,7 +28,7 @@ export declare class DTTokenReferenceResolver {
     valueIsPureReference(value: string | object): boolean;
     hasSameNumberOfCharacters(str: string, char1: string, char2: string): boolean;
     countCharacter(str: string, char: string): number;
-    tokenReferenceKey(path: Array<String>, name: string): string;
+    tokenReferenceKey(path: Array<string>, name: string): string;
     findBracketStrings(str: string): {
         index: number;
         value: string;

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

@@ -1,4 +1,4 @@
-import { Token } from "../../..";
+import { Token } from "../../../model/tokens/SDKToken";
 export type DTProcessedTheme = {
     sets: Array<DTProcessedTokenSet>;
 };
@@ -7,6 +7,5 @@ export type DTProcessedTokenSet = {
 };
 /** Utility allowing merging of two pools of tokens */
 export declare class DTTokenSetResolver {
-    constructor();
     parseTokenSets(sets: any): void;
 }

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

@@ -1,5 +1,7 @@
-import { Token, TokenGroup, TokenType } from '../../../..';
-import { GroupTreeNode } from './SDKDTGroupTreeNode';
+import { TokenType } from "../../../../model/enums/SDKTokenType";
+import { TokenGroup } from "../../../../model/groups/SDKTokenGroup";
+import { Token } from "../../../../model/tokens/SDKToken";
+import { GroupTreeNode } from "./SDKDTGroupTreeNode";
 export type GroupTreeNodeWalker = (node: GroupTreeNode, path: GroupTreeNode[]) => void;
 export type TokenTreeElement = Token | TokenGroup;
 export declare class GroupTree extends GroupTreeNode {

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

@@ -1,7 +1,4 @@
-import { Token, TokenGroup } from '../../../..';
-import { GroupTree } from './SDKDTGroupTree';
-export type GroupTreeNodeWalker = (node: GroupTreeNode, path: GroupTreeNode[]) => void;
-export type TokenTreeElement = Token | TokenGroup;
+import { GroupTree, GroupTreeNodeWalker, TokenTreeElement } from "./SDKDTGroupTree";
 export declare class GroupTreeNode {
     children: GroupTreeNode[];
     element: TokenTreeElement;

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

@@ -1,4 +1,4 @@
-import { TokenTreeElement } from "./SDKDTGroupTreeNode";
+import { TokenTreeElement } from "./SDKDTGroupTree";
 export declare const MAX_SORT_ORDER: number;
 export declare function buildParentChildrenMap(elements: TokenTreeElement[]): {
     childrenMap: Map<string, TokenTreeElement[]>;

package/build/sdk-typescript/src/tools/json-builder/SDKToolsJSONBuilder.d.ts

@@ -1,4 +1,3 @@
-import { DesignSystemVersion } from "../../core/SDKDesignSystemVersion";
 import { Supernova } from "../../core/SDKSupernova";
 import { TokenType } from "../../model/enums/SDKTokenType";
 import { TokenGroup } from "../../model/groups/SDKTokenGroup";
@@ -38,12 +37,14 @@ declare enum ConsumerMode {
 export declare class TokenJSONBuilder {
     private instance;
     private version;
+    private designSystemId;
+    private versionId;
     private tokenTransformer;
-    constructor(instance: Supernova, version: DesignSystemVersion);
+    constructor(instance: Supernova, designSystemId: string, versionId: string);
     /** Fetches all tokens available for selected design system version, and converts them to style dictionary representation. */
-    styleDictionaryRepresentation(options: TokenJSONBuilderOptions): Promise<Object>;
+    styleDictionaryRepresentation(options: TokenJSONBuilderOptions): Promise<{}>;
     /** Fetches all tokens available for selected design system version, and converts them to figma tokens representation. */
-    figmaTokensRepresentation(isSingleFile: boolean): Promise<Object>;
+    figmaTokensRepresentation(isSingleFile: boolean): Promise<{}>;
     private buildTokenStructure;
     /** Generate style dictionary tree */
     private generateStyleDictionaryTree;
@@ -52,6 +53,6 @@ export declare class TokenJSONBuilder {
     /** Find all tokens that belong to a certain group and retrieve them as objects */
     static tokensOfGroup(containingGroup: TokenGroup, allTokens: Array<Token>): Array<Token>;
     /** Retrieve chain of groups up to a specified group, ordered from parent to children */
-    static referenceGroupChain(containingGroup: TokenGroup): Array<TokenGroup>;
+    static referenceGroupChain(containingGroup: TokenGroup, allGroups: Array<TokenGroup>): Array<TokenGroup>;
 }
 export {};

package/build/sdk-typescript/src/tools/json-builder/elements-transformers/SDKToolsJSONElementFigmaTokensTransformer.d.ts

@@ -1,40 +1,37 @@
 import { TokenGroup } from "../../../model/groups/SDKTokenGroup";
 import { Token } from "../../../model/tokens/SDKToken";
-import { BorderTokenValue, ColorTokenValue, FontTokenValue, GradientTokenValue, MeasureTokenValue, RadiusTokenValue, ShadowTokenValue, TextTokenValue, TypographyTokenValue } from "../../../model/tokens/SDKTokenValue";
-import { JSONBuilderNamingOption, TokenJSONBuilderOptionsInternal } from "../SDKToolsJSONBuilder";
+import { AnyOptionTokenValue, AnyStringTokenValue, BorderTokenValue, ColorTokenValue, DimensionTokenValue, GradientTokenValue, ShadowTokenValue, TypographyTokenValue } from "../../../model/tokens/SDKTokenValue";
+import { TokenJSONBuilderOptionsInternal } from "../SDKToolsJSONBuilder";
 import { TokenJSONElementTransformer } from "./SDKToolsJSONElementTransformer";
 /** Token transformer that allow generic transform of tokens to different destinations, like Style Dictionary or Figma Tokens representation */
 export declare class TokenJSONElementFigmaTokensTransformer extends TokenJSONElementTransformer {
     /** Represent color token value either as reference or as plain representation */
-    representColorTokenValue(value: ColorTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
-    /** Represent radius token value either as reference or as plain representation */
-    representRadiusTokenValue(value: RadiusTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
-    /** Represent measure token value either as reference or as plain representation */
-    representMeasureTokenValue(value: MeasureTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
-    /** Represent font token value either as reference or as plain representation */
-    representFontTokenValue(value: FontTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    representColorTokenValue(value: ColorTokenValue, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent dimension token value either as reference or as plain representation */
+    representDimensionTokenValue(value: DimensionTokenValue, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
     /** Represent text token value either as reference or as plain representation */
-    representTextTokenValue(value: TextTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    representStringTokenValue(value: AnyStringTokenValue, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    representOptionTokenValue(value: AnyOptionTokenValue, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
     /** Represent typography token value either as reference or as plain representation */
-    representTypographyTokenValue(value: TypographyTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    representTypographyTokenValue(value: TypographyTokenValue, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
     /** Represent border token value either as reference or as plain representation */
-    representBorderTokenValue(value: BorderTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    representBorderTokenValue(value: BorderTokenValue, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
     /** Represent shadow token value either as reference or as plain representation */
-    representShadowTokenValue(value: ShadowTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    representShadowTokenValue(values: ShadowTokenValue[], allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
     /** Represent gradient token value either as reference or as plain representation */
-    representGradientTokenValue(value: GradientTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    representGradientTokenValue(values: GradientTokenValue[], allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
     /** Retrieve token wrapper containing its metadata and value information (used as container for each defined token) */
-    tokenWrapper(token: Token, value: any, options: TokenJSONBuilderOptionsInternal): Object;
+    tokenWrapper(token: Token, value: any, options: TokenJSONBuilderOptionsInternal, groups: Array<TokenGroup>): object;
     /** Retrieve human-readable token type in unified fashion, used both as token type and as token master group */
-    typeLabelConsideringAbstractGroups(token: Token): "border" | "color" | "fontSize" | "letterSpacing" | "lineHeight" | "paragraphSpacing" | "font" | "gradient" | "radius" | "shadow" | "text" | "typography" | "sizing" | "borderWidth" | "spacing" | "opacity" | "dimension" | "borderRadius";
+    typeLabelConsideringAbstractGroups(token: Token, groups: Array<TokenGroup>): string;
     /** Retrieve wrapper to certain token (referenced by name) pointing to token value */
-    referenceWrapper(reference: string, options: TokenJSONBuilderOptionsInternal): string;
+    referenceWrapper(reference: string): string;
     /** Retrieve safe group name made out of normal group name
      * This replace spaces with dashes, also change anything non-alphanumeric char to it as well.
      * For example, ST&RK Industries will be changed to st-rk-industries
      */
-    safeGroupName(group: TokenGroup, naming: JSONBuilderNamingOption): string;
+    safeGroupName(group: TokenGroup): string;
     /** Create full reference name representing token. Such name can, for example, look like: [g1].[g2].[g3].[g4].[token-name] */
-    referenceName(token: Token, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): string;
-    groupIsAbstract(group: TokenGroup): boolean;
+    referenceName(referenceId: string, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): string;
+    groupIsAbstract(group: TokenGroup, allGroups: Array<TokenGroup>): boolean;
 }

package/build/sdk-typescript/src/tools/json-builder/elements-transformers/SDKToolsJSONElementStyleDictionaryTransformer.d.ts

@@ -1,29 +1,26 @@
 import { TokenGroup } from "../../../model/groups/SDKTokenGroup";
 import { Token } from "../../../model/tokens/SDKToken";
-import { BorderTokenValue, ColorTokenValue, FontTokenValue, GradientTokenValue, MeasureTokenValue, RadiusTokenValue, ShadowTokenValue, TextTokenValue, TypographyTokenValue } from "../../../model/tokens/SDKTokenValue";
+import { AnyOptionTokenValue, AnyStringTokenValue, BorderTokenValue, ColorTokenValue, DimensionTokenValue, GradientTokenValue, ShadowTokenValue, TypographyTokenValue } from "../../../model/tokens/SDKTokenValue";
 import { TokenJSONBuilderOptionsInternal } from "../SDKToolsJSONBuilder";
 import { TokenJSONElementTransformer } from "./SDKToolsJSONElementTransformer";
 /** Token transformer that allow generic transform of tokens to different destinations, like Style Dictionary or Figma Tokens representation */
 export declare class TokenJSONElementStyleDictionaryTransformer extends TokenJSONElementTransformer {
     /** Represent color token value either as reference or as plain representation */
-    representColorTokenValue(value: ColorTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
-    /** Represent radius token value either as reference or as plain representation */
-    representRadiusTokenValue(value: RadiusTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
-    /** Represent measure token value either as reference or as plain representation */
-    representMeasureTokenValue(value: MeasureTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
-    /** Represent font token value either as reference or as plain representation */
-    representFontTokenValue(value: FontTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    representColorTokenValue(value: ColorTokenValue, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    /** Represent dimension token value either as reference or as plain representation */
+    representDimensionTokenValue(value: DimensionTokenValue, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
     /** Represent text token value either as reference or as plain representation */
-    representTextTokenValue(value: TextTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    representStringTokenValue(value: AnyStringTokenValue, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    representOptionTokenValue(value: AnyOptionTokenValue, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
     /** Represent typography token value either as reference or as plain representation */
-    representTypographyTokenValue(value: TypographyTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    representTypographyTokenValue(value: TypographyTokenValue, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
     /** Represent border token value either as reference or as plain representation */
-    representBorderTokenValue(value: BorderTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    representBorderTokenValue(value: BorderTokenValue, allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
     /** Represent shadow token value either as reference or as plain representation */
-    representShadowTokenValue(value: ShadowTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    representShadowTokenValue(values: ShadowTokenValue[], allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
     /** Represent gradient token value either as reference or as plain representation */
-    representGradientTokenValue(value: GradientTokenValue, allTokens: Array<Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
+    representGradientTokenValue(values: GradientTokenValue[], allTokens: Map<string, Token>, allGroups: Array<TokenGroup>, options: TokenJSONBuilderOptionsInternal): any;
     /** Retrieve wrapper to certain token (referenced by name) pointing to token value */
-    referenceWrapper(reference: string, options: TokenJSONBuilderOptionsInternal): string;
+    referenceWrapper(reference: string): string;
     groupIsAbstract(group: TokenGroup): boolean;
 }