@vellira-ui/tokens 2.103.0 → 2.103.2

package/dist/component-token-dependencies.d.ts

@@ -0,0 +1,140 @@
+export declare const componentTokenDependencyPolicyV1: {
+    readonly semanticRoles: {
+        readonly default: "required";
+        readonly rule: "Select semantic roles by meaning, never by resolved color equality.";
+    };
+    readonly primitiveColors: {
+        readonly default: "prohibited";
+        readonly allowedContexts: readonly ["intent-palette-construction", "component-owned-presentation"];
+    };
+    readonly baseTokens: {
+        readonly allowed: readonly ["spacing", "radius", "typography", "motion", "z-index", "shadow-intent"];
+    };
+    readonly componentToComponent: {
+        readonly default: "prohibited";
+        readonly rule: "Another component token family may be consumed only through an explicitly registered architectural edge.";
+    };
+    readonly transparentPrimitive: "transparent is an implementation primitive for absent paint and does not require semantic ownership.";
+    readonly generatorRule: "Generated component tokens must prefer canonical semantic roles by meaning; primitive colors are allowed only in explicit intent/palette construction or documented component-owned presentation, and another component token family may not be consumed unless the edge is explicitly architectural.";
+};
+export type ComponentPrimitiveColorUsage = 'none' | 'intent-palette-construction' | 'component-owned-presentation';
+export declare const allowedComponentFactoryDependencyEdgesV1: readonly [{
+    readonly from: "dropdown";
+    readonly to: "input";
+    readonly symbol: "createInputColorPalette";
+    readonly reason: "Dropdown trigger intentionally shares the established field-control intent palette contract.";
+}, {
+    readonly from: "select";
+    readonly to: "input";
+    readonly symbol: "createInputColorPalette";
+    readonly reason: "Select trigger intentionally shares the established field-control intent palette contract.";
+}];
+export declare const componentTokenDependencyAuditV1: readonly [{
+    readonly factory: "createAccordionTokens";
+    readonly component: "accordion";
+    readonly file: "accordion.ts";
+    readonly primitiveColorUsage: readonly ["none"];
+    readonly unresolved: readonly [];
+}, {
+    readonly factory: "createButtonTokens";
+    readonly component: "button";
+    readonly file: "button.ts";
+    readonly primitiveColorUsage: readonly ["intent-palette-construction"];
+    readonly unresolved: readonly [];
+}, {
+    readonly factory: "createCheckboxTokens";
+    readonly component: "checkbox";
+    readonly file: "checkbox.ts";
+    readonly primitiveColorUsage: readonly ["intent-palette-construction"];
+    readonly unresolved: readonly [];
+}, {
+    readonly factory: "createContextMenuTokens";
+    readonly component: "contextMenu";
+    readonly file: "contextMenu.ts";
+    readonly primitiveColorUsage: readonly ["none"];
+    readonly unresolved: readonly [];
+}, {
+    readonly factory: "createDropdownTokens";
+    readonly component: "dropdown";
+    readonly file: "dropdown.ts";
+    readonly primitiveColorUsage: readonly ["intent-palette-construction"];
+    readonly unresolved: readonly [];
+}, {
+    readonly factory: "createFormFieldTokens";
+    readonly component: "formField";
+    readonly file: "formField.ts";
+    readonly primitiveColorUsage: readonly ["component-owned-presentation"];
+    readonly unresolved: readonly [];
+}, {
+    readonly factory: "createInputTokens";
+    readonly component: "input";
+    readonly file: "input.ts";
+    readonly primitiveColorUsage: readonly ["intent-palette-construction", "component-owned-presentation"];
+    readonly unresolved: readonly [];
+}, {
+    readonly factory: "createModalTokens";
+    readonly component: "modal";
+    readonly file: "modal.ts";
+    readonly primitiveColorUsage: readonly ["none"];
+    readonly unresolved: readonly [];
+}, {
+    readonly factory: "createPopoverTokens";
+    readonly component: "popover";
+    readonly file: "popover.ts";
+    readonly primitiveColorUsage: readonly ["none"];
+    readonly unresolved: readonly [];
+}, {
+    readonly factory: "createRadioGroupTokens";
+    readonly component: "radioGroup";
+    readonly file: "radioGroup.ts";
+    readonly primitiveColorUsage: readonly ["none"];
+    readonly unresolved: readonly [];
+}, {
+    readonly factory: "createRadioTokens";
+    readonly component: "radio";
+    readonly file: "radio.ts";
+    readonly primitiveColorUsage: readonly ["intent-palette-construction"];
+    readonly unresolved: readonly [];
+}, {
+    readonly factory: "createSelectTokens";
+    readonly component: "select";
+    readonly file: "select.ts";
+    readonly primitiveColorUsage: readonly ["intent-palette-construction", "component-owned-presentation"];
+    readonly unresolved: readonly [];
+}, {
+    readonly factory: "createSwitchTokens";
+    readonly component: "switch";
+    readonly file: "switch.ts";
+    readonly primitiveColorUsage: readonly ["none"];
+    readonly unresolved: readonly [];
+}, {
+    readonly factory: "createTabsTokens";
+    readonly component: "tabs";
+    readonly file: "tabs.ts";
+    readonly primitiveColorUsage: readonly ["intent-palette-construction", "component-owned-presentation"];
+    readonly unresolved: readonly [];
+}, {
+    readonly factory: "createTooltipTokens";
+    readonly component: "tooltip";
+    readonly file: "tooltip.ts";
+    readonly primitiveColorUsage: readonly ["none"];
+    readonly unresolved: readonly [];
+}];
+export declare const semanticDependencyRepairsV1: readonly [{
+    readonly component: "formField";
+    readonly paths: readonly ["requiredMark.fg", "labelInfo.border"];
+    readonly repair: "Move component-specific presentation paint out of unrelated status/text semantic roles while preserving the resolved theme values.";
+}, {
+    readonly component: "input";
+    readonly paths: readonly ["clearButton.hoverFg", "clearButton.hoverBg"];
+    readonly repair: "Use canonical danger icon semantics when value-equivalent; otherwise use explicit component-owned presentation paint to preserve the existing resolved value without depending on validation status.";
+}, {
+    readonly component: "input";
+    readonly paths: readonly ["error.ring"];
+    readonly repair: "Use status.error.ring rather than a coincidentally equal status.error.fg value.";
+}, {
+    readonly component: "select";
+    readonly paths: readonly ["clearButton.hoverFg", "clearButton.hoverBg"];
+    readonly repair: "Use canonical danger icon semantics when value-equivalent; otherwise use explicit component-owned presentation paint to preserve the existing resolved value without depending on validation status.";
+}];
+//# sourceMappingURL=component-token-dependencies.d.ts.map

package/dist/component-token-dependencies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-token-dependencies.d.ts","sourceRoot":"","sources":["../src/component-token-dependencies.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;CA8BnC,CAAC;AAEX,MAAM,MAAM,4BAA4B,GACtC,MAAM,GAAG,6BAA6B,GAAG,8BAA8B,CAAC;AAE1E,eAAO,MAAM,wCAAwC;;;;;;;;;;EAe3C,CAAC;AAEX,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmHlC,CAAC;AAEX,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;EAyB9B,CAAC"}

package/dist/component-token-dependencies.js

@@ -0,0 +1,181 @@
+export const componentTokenDependencyPolicyV1 = {
+    semanticRoles: {
+        default: 'required',
+        rule: 'Select semantic roles by meaning, never by resolved color equality.',
+    },
+    primitiveColors: {
+        default: 'prohibited',
+        allowedContexts: [
+            'intent-palette-construction',
+            'component-owned-presentation',
+        ],
+    },
+    baseTokens: {
+        allowed: [
+            'spacing',
+            'radius',
+            'typography',
+            'motion',
+            'z-index',
+            'shadow-intent',
+        ],
+    },
+    componentToComponent: {
+        default: 'prohibited',
+        rule: 'Another component token family may be consumed only through an explicitly registered architectural edge.',
+    },
+    transparentPrimitive: 'transparent is an implementation primitive for absent paint and does not require semantic ownership.',
+    generatorRule: 'Generated component tokens must prefer canonical semantic roles by meaning; primitive colors are allowed only in explicit intent/palette construction or documented component-owned presentation, and another component token family may not be consumed unless the edge is explicitly architectural.',
+};
+export const allowedComponentFactoryDependencyEdgesV1 = [
+    {
+        from: 'dropdown',
+        to: 'input',
+        symbol: 'createInputColorPalette',
+        reason: 'Dropdown trigger intentionally shares the established field-control intent palette contract.',
+    },
+    {
+        from: 'select',
+        to: 'input',
+        symbol: 'createInputColorPalette',
+        reason: 'Select trigger intentionally shares the established field-control intent palette contract.',
+    },
+];
+export const componentTokenDependencyAuditV1 = [
+    {
+        factory: 'createAccordionTokens',
+        component: 'accordion',
+        file: 'accordion.ts',
+        primitiveColorUsage: ['none'],
+        unresolved: [],
+    },
+    {
+        factory: 'createButtonTokens',
+        component: 'button',
+        file: 'button.ts',
+        primitiveColorUsage: ['intent-palette-construction'],
+        unresolved: [],
+    },
+    {
+        factory: 'createCheckboxTokens',
+        component: 'checkbox',
+        file: 'checkbox.ts',
+        primitiveColorUsage: ['intent-palette-construction'],
+        unresolved: [],
+    },
+    {
+        factory: 'createContextMenuTokens',
+        component: 'contextMenu',
+        file: 'contextMenu.ts',
+        primitiveColorUsage: ['none'],
+        unresolved: [],
+    },
+    {
+        factory: 'createDropdownTokens',
+        component: 'dropdown',
+        file: 'dropdown.ts',
+        primitiveColorUsage: ['intent-palette-construction'],
+        unresolved: [],
+    },
+    {
+        factory: 'createFormFieldTokens',
+        component: 'formField',
+        file: 'formField.ts',
+        primitiveColorUsage: ['component-owned-presentation'],
+        unresolved: [],
+    },
+    {
+        factory: 'createInputTokens',
+        component: 'input',
+        file: 'input.ts',
+        primitiveColorUsage: [
+            'intent-palette-construction',
+            'component-owned-presentation',
+        ],
+        unresolved: [],
+    },
+    {
+        factory: 'createModalTokens',
+        component: 'modal',
+        file: 'modal.ts',
+        primitiveColorUsage: ['none'],
+        unresolved: [],
+    },
+    {
+        factory: 'createPopoverTokens',
+        component: 'popover',
+        file: 'popover.ts',
+        primitiveColorUsage: ['none'],
+        unresolved: [],
+    },
+    {
+        factory: 'createRadioGroupTokens',
+        component: 'radioGroup',
+        file: 'radioGroup.ts',
+        primitiveColorUsage: ['none'],
+        unresolved: [],
+    },
+    {
+        factory: 'createRadioTokens',
+        component: 'radio',
+        file: 'radio.ts',
+        primitiveColorUsage: ['intent-palette-construction'],
+        unresolved: [],
+    },
+    {
+        factory: 'createSelectTokens',
+        component: 'select',
+        file: 'select.ts',
+        primitiveColorUsage: [
+            'intent-palette-construction',
+            'component-owned-presentation',
+        ],
+        unresolved: [],
+    },
+    {
+        factory: 'createSwitchTokens',
+        component: 'switch',
+        file: 'switch.ts',
+        primitiveColorUsage: ['none'],
+        unresolved: [],
+    },
+    {
+        factory: 'createTabsTokens',
+        component: 'tabs',
+        file: 'tabs.ts',
+        primitiveColorUsage: [
+            'intent-palette-construction',
+            'component-owned-presentation',
+        ],
+        unresolved: [],
+    },
+    {
+        factory: 'createTooltipTokens',
+        component: 'tooltip',
+        file: 'tooltip.ts',
+        primitiveColorUsage: ['none'],
+        unresolved: [],
+    },
+];
+export const semanticDependencyRepairsV1 = [
+    {
+        component: 'formField',
+        paths: ['requiredMark.fg', 'labelInfo.border'],
+        repair: 'Move component-specific presentation paint out of unrelated status/text semantic roles while preserving the resolved theme values.',
+    },
+    {
+        component: 'input',
+        paths: ['clearButton.hoverFg', 'clearButton.hoverBg'],
+        repair: 'Use canonical danger icon semantics when value-equivalent; otherwise use explicit component-owned presentation paint to preserve the existing resolved value without depending on validation status.',
+    },
+    {
+        component: 'input',
+        paths: ['error.ring'],
+        repair: 'Use status.error.ring rather than a coincidentally equal status.error.fg value.',
+    },
+    {
+        component: 'select',
+        paths: ['clearButton.hoverFg', 'clearButton.hoverBg'],
+        repair: 'Use canonical danger icon semantics when value-equivalent; otherwise use explicit component-owned presentation paint to preserve the existing resolved value without depending on validation status.',
+    },
+];

package/dist/dark/components/accordion.d.ts

@@ -1,2 +1,2 @@
-export declare const accordionTokens: import("../../factories/createAccordionTokens.js").AccordionTokensConfig;
+export declare const accordionTokens: import("../../factories/index.js").AccordionTokensConfig;
 //# sourceMappingURL=accordion.d.ts.map

package/dist/dark/components/accordion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"accordion.d.ts","sourceRoot":"","sources":["../../../src/dark/components/accordion.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,eAAe,0EAK1B,CAAC"}
+{"version":3,"file":"accordion.d.ts","sourceRoot":"","sources":["../../../src/dark/components/accordion.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,eAAe,0DAK1B,CAAC"}

package/dist/dark/components/accordion.js

@@ -1,4 +1,4 @@
-import { createAccordionTokensFromSemantics } from '../../factories/createAccordionTokens.js';
+import { createAccordionTokensFromSemantics } from '../../factories/components/createAccordionTokens.js';
 import { border } from '../semantic/border.js';
 import { focus } from '../semantic/focus.js';
 import { surface } from '../semantic/surface.js';

package/dist/dark/components/button.d.ts

@@ -2,9 +2,9 @@ export declare const button: {
     readonly primary: {
         readonly ring: string;
         readonly solid: {
-            default: import("../../factories/createButtonPalette.js").ButtonState;
-            hover: import("../../factories/createButtonPalette.js").ButtonState;
-            pressed: import("../../factories/createButtonPalette.js").ButtonState;
+            default: import("../../factories/index.js").ButtonState;
+            hover: import("../../factories/index.js").ButtonState;
+            pressed: import("../../factories/index.js").ButtonState;
         };
         readonly outline: {
             readonly default: {
@@ -78,9 +78,9 @@ export declare const button: {
     readonly neutral: {
         readonly ring: string;
         readonly solid: {
-            default: import("../../factories/createButtonPalette.js").ButtonState;
-            hover: import("../../factories/createButtonPalette.js").ButtonState;
-            pressed: import("../../factories/createButtonPalette.js").ButtonState;
+            default: import("../../factories/index.js").ButtonState;
+            hover: import("../../factories/index.js").ButtonState;
+            pressed: import("../../factories/index.js").ButtonState;
         };
         readonly outline: {
             readonly default: {
@@ -154,9 +154,9 @@ export declare const button: {
     readonly success: {
         readonly ring: string;
         readonly solid: {
-            default: import("../../factories/createButtonPalette.js").ButtonState;
-            hover: import("../../factories/createButtonPalette.js").ButtonState;
-            pressed: import("../../factories/createButtonPalette.js").ButtonState;
+            default: import("../../factories/index.js").ButtonState;
+            hover: import("../../factories/index.js").ButtonState;
+            pressed: import("../../factories/index.js").ButtonState;
         };
         readonly outline: {
             readonly default: {
@@ -230,9 +230,9 @@ export declare const button: {
     readonly warning: {
         readonly ring: string;
         readonly solid: {
-            default: import("../../factories/createButtonPalette.js").ButtonState;
-            hover: import("../../factories/createButtonPalette.js").ButtonState;
-            pressed: import("../../factories/createButtonPalette.js").ButtonState;
+            default: import("../../factories/index.js").ButtonState;
+            hover: import("../../factories/index.js").ButtonState;
+            pressed: import("../../factories/index.js").ButtonState;
         };
         readonly outline: {
             readonly default: {
@@ -306,9 +306,9 @@ export declare const button: {
     readonly danger: {
         readonly ring: string;
         readonly solid: {
-            default: import("../../factories/createButtonPalette.js").ButtonState;
-            hover: import("../../factories/createButtonPalette.js").ButtonState;
-            pressed: import("../../factories/createButtonPalette.js").ButtonState;
+            default: import("../../factories/index.js").ButtonState;
+            hover: import("../../factories/index.js").ButtonState;
+            pressed: import("../../factories/index.js").ButtonState;
         };
         readonly outline: {
             readonly default: {

package/dist/dark/components/button.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"button.d.ts","sourceRoot":"","sources":["../../../src/dark/components/button.ts"],"names":[],"mappings":"AA2KA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAYT,CAAC"}
+{"version":3,"file":"button.d.ts","sourceRoot":"","sources":["../../../src/dark/components/button.ts"],"names":[],"mappings":"AA8KA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAYjB,CAAC"}

package/dist/dark/components/button.js

@@ -1,4 +1,4 @@
-import { createButtonPalette } from '../../factories/createButtonPalette.js';
+import { createButtonPalette, createButtonTokens, } from '../../factories/components/createButtonTokens.js';
 import { colors } from '../../primitives/colors.js';
 import { border } from '../semantic/border.js';
 import { surface } from '../semantic/surface.js';
@@ -148,7 +148,7 @@ const danger = createButtonPalette({
     pressedBg: colors.error[800],
     pressedBorder: colors.error[700],
 });
-export const button = {
+export const button = createButtonTokens({
     primary,
     neutral,
     success,
@@ -159,4 +159,4 @@ export const button = {
         fg: text.disabled,
         border: border.disabled,
     },
-};
+});

package/dist/dark/components/checkbox.d.ts

@@ -12,33 +12,33 @@ export declare const checkbox: {
     };
     readonly primary: {
         readonly ring: string;
-        readonly default: import("../../factories/createCheckboxPalette.js").CheckboxState;
-        readonly hover: import("../../factories/createCheckboxPalette.js").CheckboxState;
-        readonly pressed: import("../../factories/createCheckboxPalette.js").CheckboxState;
+        readonly default: import("../../factories/index.js").CheckboxState;
+        readonly hover: import("../../factories/index.js").CheckboxState;
+        readonly pressed: import("../../factories/index.js").CheckboxState;
     };
     readonly neutral: {
         readonly ring: string;
-        readonly default: import("../../factories/createCheckboxPalette.js").CheckboxState;
-        readonly hover: import("../../factories/createCheckboxPalette.js").CheckboxState;
-        readonly pressed: import("../../factories/createCheckboxPalette.js").CheckboxState;
+        readonly default: import("../../factories/index.js").CheckboxState;
+        readonly hover: import("../../factories/index.js").CheckboxState;
+        readonly pressed: import("../../factories/index.js").CheckboxState;
     };
     readonly success: {
         readonly ring: string;
-        readonly default: import("../../factories/createCheckboxPalette.js").CheckboxState;
-        readonly hover: import("../../factories/createCheckboxPalette.js").CheckboxState;
-        readonly pressed: import("../../factories/createCheckboxPalette.js").CheckboxState;
+        readonly default: import("../../factories/index.js").CheckboxState;
+        readonly hover: import("../../factories/index.js").CheckboxState;
+        readonly pressed: import("../../factories/index.js").CheckboxState;
     };
     readonly warning: {
         readonly ring: string;
-        readonly default: import("../../factories/createCheckboxPalette.js").CheckboxState;
-        readonly hover: import("../../factories/createCheckboxPalette.js").CheckboxState;
-        readonly pressed: import("../../factories/createCheckboxPalette.js").CheckboxState;
+        readonly default: import("../../factories/index.js").CheckboxState;
+        readonly hover: import("../../factories/index.js").CheckboxState;
+        readonly pressed: import("../../factories/index.js").CheckboxState;
     };
     readonly danger: {
         readonly ring: string;
-        readonly default: import("../../factories/createCheckboxPalette.js").CheckboxState;
-        readonly hover: import("../../factories/createCheckboxPalette.js").CheckboxState;
-        readonly pressed: import("../../factories/createCheckboxPalette.js").CheckboxState;
+        readonly default: import("../../factories/index.js").CheckboxState;
+        readonly hover: import("../../factories/index.js").CheckboxState;
+        readonly pressed: import("../../factories/index.js").CheckboxState;
     };
     readonly focus: {
         readonly ring: "#B8A8FF";

package/dist/dark/components/checkbox.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"checkbox.d.ts","sourceRoot":"","sources":["../../../src/dark/components/checkbox.ts"],"names":[],"mappings":"AAuHA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCX,CAAC"}
+{"version":3,"file":"checkbox.d.ts","sourceRoot":"","sources":["../../../src/dark/components/checkbox.ts"],"names":[],"mappings":"AA0HA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCnB,CAAC"}

package/dist/dark/components/checkbox.js

@@ -1,4 +1,4 @@
-import { createCheckboxPalette } from '../../factories/createCheckboxPalette.js';
+import { createCheckboxPalette, createCheckboxTokens, } from '../../factories/components/createCheckboxTokens.js';
 import { colors } from '../../primitives/colors.js';
 import { border } from '../semantic/border.js';
 import { control } from '../semantic/control.js';
@@ -111,7 +111,7 @@ const danger = createCheckboxPalette({
         labelFg: colors.error[600],
     },
 });
-export const checkbox = {
+export const checkbox = createCheckboxTokens({
     default: {
         bg: surface.elevated,
         fg: text.primary,
@@ -139,4 +139,4 @@ export const checkbox = {
         border: status.error.border,
         ring: status.error.ring,
     },
-};
+});

package/dist/dark/components/contextMenu.js

@@ -1,4 +1,4 @@
-import { createContextMenuTokensFromSemantics } from '../../factories/createContextMenuTokens.js';
+import { createContextMenuTokensFromSemantics } from '../../factories/components/createContextMenuTokens.js';
 import { focus } from '../semantic/focus.js';
 import { menu } from '../semantic/menu.js';
 import { text } from '../semantic/text.js';

package/dist/dark/components/dropdown.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dropdown.d.ts","sourceRoot":"","sources":["../../../src/dark/components/dropdown.ts"],"names":[],"mappings":"AAyEA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwIX,CAAC"}
+{"version":3,"file":"dropdown.d.ts","sourceRoot":"","sources":["../../../src/dark/components/dropdown.ts"],"names":[],"mappings":"AA4EA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwInB,CAAC"}

package/dist/dark/components/dropdown.js

@@ -1,6 +1,6 @@
-import { createComponentFocusRing } from '../../factories/componentFocusRing.js';
-import { createDropdownPalette } from '../../factories/createDropdownPalette.js';
-import { createInputColorPalette } from '../../factories/createInputPalette.js';
+import { createDropdownPalette, createDropdownTokens, } from '../../factories/components/createDropdownTokens.js';
+import { createInputColorPalette } from '../../factories/components/createInputTokens.js';
+import { createComponentFocusRing } from '../../factories/shared/componentFocusRing.js';
 import { createComponentShadowIntent } from '../../platform-output/component-token-intents.js';
 import { colors } from '../../primitives/colors.js';
 import { withAlpha } from '../../utils/color.js';
@@ -64,7 +64,7 @@ const danger = createInputColorPalette({
     hoverBg: colors.error[950],
     ring: colors.error[500],
 });
-export const dropdown = {
+export const dropdown = createDropdownTokens({
     primary: createDropdownPalette(primary, {
         contentBorder: 'transparent',
         itemActiveBg: withAlpha(colors.primary[400], 0.18),
@@ -184,4 +184,4 @@ export const dropdown = {
         bg: border.muted,
         fg: text.muted,
     },
-};
+});

package/dist/dark/components/formField.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"formField.d.ts","sourceRoot":"","sources":["../../../src/dark/components/formField.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMpB,CAAC"}
+{"version":3,"file":"formField.d.ts","sourceRoot":"","sources":["../../../src/dark/components/formField.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAUpB,CAAC"}

package/dist/dark/components/formField.js

@@ -1,4 +1,5 @@
-import { createFormFieldTokensFromTheme } from '../../factories/createFormFieldTokens.js';
+import { createFormFieldTokensFromTheme } from '../../factories/components/createFormFieldTokens.js';
+import { colors } from '../../primitives/colors.js';
 import { radius } from '../../tokens/radius.js';
 import { spacing } from '../../tokens/spacing.js';
 import { typography } from '../../tokens/typography.js';
@@ -10,4 +11,8 @@ export const formField = createFormFieldTokensFromTheme({
     typography,
     status,
     text,
+    presentation: {
+        requiredMarkFg: colors.error[400],
+        labelInfoBorder: colors.vellira[300],
+    },
 });