@pandacss/token-dictionary 0.0.0-dev-20221121152823

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Segun Adebayo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,216 @@
+declare type TokenStatus$1 = 'deprecated' | 'experimental' | 'new';
+declare type ExtensionData = {
+    status?: TokenStatus$1;
+    category?: string;
+    references?: TokenReferences;
+    condition?: string;
+    conditions?: TokenConditions;
+};
+declare type TokenConditions = Record<string, string>;
+declare type TokenReferences = Record<string, Token>;
+declare type TokenExtensions = ExtensionData & {
+    [key: string]: any;
+};
+declare type ExtendedToken = {
+    name: string;
+    value: any;
+    type?: string;
+    path?: string[];
+    description?: string;
+    extensions?: TokenExtensions;
+};
+/**
+ * Represents a design token in the dictionary
+ */
+declare class Token {
+    name: string;
+    value: any;
+    originalValue: any;
+    path: string[];
+    type?: string;
+    description?: string;
+    extensions: TokenExtensions;
+    constructor(data: ExtendedToken);
+    /**
+     * Whether the token is a conditional token.
+     * Conditional tokens are tokens that have multiple values based on a condition.
+     */
+    get isConditional(): boolean;
+    /**
+     * Whether the token has a reference in its value.
+     * e.g. {color.gray.100}
+     */
+    get hasReference(): boolean;
+    /**
+     * Whether the token is a complex or composite token.
+     */
+    get isComposite(): boolean;
+    /**
+     * Returns the token value with the references expanded.
+     * e.g. {color.gray.100} => #f7fafc
+     *
+     */
+    expandReferences(): string;
+    /**
+     * Whether this token has a reference to another token
+     */
+    get isReference(): boolean;
+    /**
+     * Returns the list of references in the token value
+     */
+    get references(): string[];
+    clone(): Token;
+    /**
+     * Returns an array of tokens per conditions.
+     * It is commonly used in semantic tokens, and can have multiple values based on a condition.
+     * e.g. primary: { light: '#000', dark: '#fff' }
+     */
+    getConditionTokens(): Token[] | undefined;
+    /**
+     * Add more extensions to the token
+     */
+    setExtensions(extensions: TokenExtensions): this;
+    setType(): void;
+}
+
+declare type TokenStatus = 'deprecated' | 'experimental' | 'new';
+declare type TokenEntry<V = any> = {
+    value: V;
+    description?: string;
+    type?: string;
+    extensions?: {
+        status?: TokenStatus;
+        [key: string]: any;
+    };
+};
+declare type SemanticTokenEntry<V = string, C extends string = string> = {
+    description?: string;
+    type?: string;
+    value: V | Record<C, V>;
+    extensions?: {
+        [key: string]: any;
+    };
+};
+declare type Border = {
+    color: string;
+    width: string | number;
+    style: string;
+};
+declare type Shadow = {
+    offsetX: number;
+    offsetY: number;
+    blur: number;
+    spread: number;
+    color: string;
+    inset?: boolean;
+};
+declare type Gradient = {
+    type: 'linear' | 'radial';
+    placement: string | number;
+    stops: Array<{
+        color: string;
+        position: number;
+    }>;
+};
+declare type Nested<T> = {
+    [key: string]: T | Nested<T>;
+};
+declare type TokenValues = {
+    zIndex: number;
+    opacity: number;
+    colors: string;
+    fonts: string | string[];
+    fontSizes: string;
+    fontWeights: string | number;
+    lineHeights: string | number;
+    letterSpacings: string;
+    sizes: string;
+    largeSizes: string;
+    shadows: Shadow | Shadow[] | string | string[];
+    spacing: string | number;
+    radii: string;
+    borders: string | Border;
+    durations: string;
+    easings: string | number[];
+    animations: string;
+    blurs: string;
+    gradients: string | Gradient;
+};
+declare type Tokens = {
+    [key in keyof TokenValues]?: Nested<TokenEntry<TokenValues[key]>>;
+};
+declare type SemanticTokens<C extends string = string> = {
+    [key in keyof TokenValues]?: Nested<SemanticTokenEntry<TokenValues[key], C>>;
+};
+
+declare type EnforcePhase = 'pre' | 'post';
+declare type Options = {
+    prefix?: string;
+};
+declare type TokenTransformer = {
+    name: string;
+    enforce?: EnforcePhase;
+    type?: 'value' | 'name' | 'extensions';
+    match?: (token: Token) => boolean;
+    transform: (token: Token, options: Options) => any;
+};
+declare type TokenDictionaryOptions = {
+    tokens?: Tokens;
+    semanticTokens?: SemanticTokens;
+    prefix?: string;
+};
+declare type TokenMiddleware = {
+    enforce?: EnforcePhase;
+    transform: (dict: TokenDictionary$1, options: Options) => void;
+};
+declare class TokenDictionary$1 {
+    allTokens: Token[];
+    prefix: string | undefined;
+    get allNames(): string[];
+    constructor(options: TokenDictionaryOptions);
+    getByName: (name: string) => Token | undefined;
+    private transforms;
+    registerTransform(...transforms: TokenTransformer[]): this;
+    private execTransform;
+    transformTokens(enforce: EnforcePhase): this;
+    private middlewares;
+    registerMiddleware(...middlewares: TokenMiddleware[]): this;
+    applyMiddlewares(enforce: EnforcePhase): void;
+    getReferences(value: string): Token[];
+    usesReference(value: any): boolean;
+    addReferences(): this;
+    filter(pattern: Partial<Token> | ((token: Token) => boolean)): Token[];
+    addConditionalTokens(): this;
+    expandReferences(): this;
+    build(): void;
+    get isEmpty(): boolean;
+}
+
+declare class TokenDictionary extends TokenDictionary$1 {
+    constructor(options: TokenDictionaryOptions);
+    get get(): (path: string, fallback?: string | number | undefined) => any;
+    get conditionMap(): Map<string, Set<Token>>;
+    get categoryMap(): Map<string, Map<string, Token>>;
+    get values(): Map<string, Map<string, string>>;
+    get palettes(): {
+        clear: never;
+        delete: never;
+        forEach: never;
+        get: never;
+        has: never;
+        set: never;
+        readonly size: never;
+        entries: never;
+        keys: never;
+        values: never;
+        [Symbol.iterator]: never;
+        readonly [Symbol.toStringTag]: never;
+    };
+    get vars(): Map<string, Map<string, string>>;
+    getValue(path: string): {
+        [k: string]: string;
+    } | undefined;
+    getTokenVar(path: string): any;
+}
+
+export { TokenDictionary };