soltana-ui 0.1.0

package/dist/enhancers/hover-card.d.ts

@@ -0,0 +1,15 @@
+import { EnhancerCleanup, EnhancerOptions } from '../config/types.js';
+export declare const HOVER_CARD_SELECTOR = "[data-sol-hover-card]";
+/**
+ * Enhance all `[data-sol-hover-card]` elements with hover-triggered
+ * floating card behavior.
+ *
+ * Expected structure:
+ * ```html
+ * <div data-sol-hover-card class="hover-card">
+ *   <span class="hover-card-trigger">Hover me</span>
+ *   <div class="hover-card-content">Rich content</div>
+ * </div>
+ * ```
+ */
+export declare function initHoverCards(options?: EnhancerOptions): EnhancerCleanup;

package/dist/enhancers/index.d.ts

@@ -0,0 +1,42 @@
+import { EnhancerCleanup, EnhancerOptions } from '../config/types.js';
+import { initModals } from './modal.js';
+import { initTabs } from './tabs.js';
+import { initTooltips } from './tooltip.js';
+import { initAccordions } from './accordion.js';
+import { initDropdowns } from './dropdown.js';
+import { initDrawers } from './drawer.js';
+import { initToasts, showToast, dismissToast } from './toast.js';
+import { initCollapsibles } from './collapsible.js';
+import { initComboboxes } from './combobox.js';
+import { initHoverCards } from './hover-card.js';
+import { initContextMenus } from './context-menu.js';
+import { initCarousels } from './carousel.js';
+import { initScrollAreas } from './scroll-area.js';
+import { initDatePickers } from './date-picker.js';
+import { initColorPickers } from './color-picker.js';
+import { initTrees } from './tree.js';
+export { initModals, initTabs, initTooltips };
+export { initAccordions, initDropdowns, initDrawers, initToasts };
+export { showToast, dismissToast };
+export { initCollapsibles, initComboboxes, initHoverCards };
+export { initContextMenus, initCarousels, initScrollAreas };
+export { initDatePickers, initColorPickers, initTrees };
+export { MODAL_SELECTOR, MODAL_OPEN_SELECTOR } from './modal.js';
+export { TABS_SELECTOR } from './tabs.js';
+export { TOOLTIP_SELECTOR } from './tooltip.js';
+export { ACCORDION_SELECTOR } from './accordion.js';
+export { DROPDOWN_SELECTOR } from './dropdown.js';
+export { DRAWER_SELECTOR, DRAWER_OPEN_SELECTOR } from './drawer.js';
+export { TOAST_CONTAINER_SELECTOR } from './toast.js';
+export { COLLAPSIBLE_SELECTOR } from './collapsible.js';
+export { COMBOBOX_SELECTOR } from './combobox.js';
+export { HOVER_CARD_SELECTOR } from './hover-card.js';
+export { CONTEXT_MENU_SELECTOR } from './context-menu.js';
+export { CAROUSEL_SELECTOR } from './carousel.js';
+export { SCROLL_AREA_SELECTOR } from './scroll-area.js';
+export { DATE_PICKER_SELECTOR } from './date-picker.js';
+export { COLOR_PICKER_SELECTOR } from './color-picker.js';
+export { TREE_SELECTOR } from './tree.js';
+export type { ToastOptions, ToastType, ToastPosition } from './toast.js';
+/** Initialize all enhancers. Call after DOM content is loaded. */
+export declare function initAll(options?: EnhancerOptions): EnhancerCleanup;

package/dist/enhancers/modal.d.ts

@@ -0,0 +1,16 @@
+export declare const MODAL_SELECTOR = "[data-sol-modal]";
+export declare const MODAL_OPEN_SELECTOR = "[data-modal-open]";
+/**
+ * Enhance all `[data-sol-modal]` elements with open/close, focus trapping,
+ * Escape key, and backdrop click behavior.
+ *
+ * Open triggers: elements with `[data-modal-open="<modal-id>"]`.
+ * Close triggers: elements with `[data-modal-close]` inside the modal.
+ * Adds the `.sol-modal-open` class to `document.body` while any modal is open
+ * to prevent background scrolling.
+ *
+ * @param options - Optional scoping and selector overrides.
+ * @returns Cleanup handle — call `destroy()` to remove all listeners.
+ *          Re-calling `initModals()` implicitly cleans up previous listeners.
+ */
+export declare const initModals: (options?: import('../index.js').EnhancerOptions) => import('../index.js').EnhancerCleanup;

package/dist/enhancers/scroll-area.d.ts

@@ -0,0 +1,14 @@
+import { EnhancerCleanup, EnhancerOptions } from '../config/types.js';
+export declare const SCROLL_AREA_SELECTOR = "[data-sol-scroll-area]";
+/**
+ * Enhance all `[data-sol-scroll-area]` elements with auto-hiding
+ * scrollbar visibility on scroll.
+ *
+ * Expected structure:
+ * ```html
+ * <div data-sol-scroll-area class="scroll-area" style="max-height: 20rem;">
+ *   <!-- Scrollable content -->
+ * </div>
+ * ```
+ */
+export declare function initScrollAreas(options?: EnhancerOptions): EnhancerCleanup;

package/dist/enhancers/tabs.d.ts

@@ -0,0 +1,26 @@
+import { EnhancerCleanup, EnhancerOptions } from '../config/types.js';
+export declare const TABS_SELECTOR = "[data-sol-tabs]";
+/**
+ * Enhance all `[data-sol-tabs]` elements with tab switching, keyboard
+ * navigation, and ARIA attributes.
+ *
+ * Expected structure:
+ * ```html
+ * <div data-sol-tabs>
+ *   <div role="tablist">
+ *     <button role="tab" aria-selected="true">Tab 1</button>
+ *     <button role="tab">Tab 2</button>
+ *   </div>
+ *   <div role="tabpanel">Panel 1</div>
+ *   <div role="tabpanel" hidden>Panel 2</div>
+ * </div>
+ * ```
+ *
+ * Mutates each tab container by setting `id`, `aria-controls`, and
+ * `aria-labelledby` attributes on tabs and panels.
+ *
+ * @param options - Optional scoping and selector overrides.
+ * @returns Cleanup handle — call `destroy()` to remove all listeners.
+ *          Re-calling `initTabs()` implicitly cleans up previous listeners.
+ */
+export declare function initTabs(options?: EnhancerOptions): EnhancerCleanup;

package/dist/enhancers/test-helpers.d.ts

@@ -0,0 +1,20 @@
+import { vi } from 'vitest';
+import { EnhancerCleanup } from '../config/types.js';
+/**
+ * Verifies that re-calling an enhancer init function does not duplicate listeners.
+ * Tests the singleton behavior pattern used across all enhancers.
+ *
+ * @param initFn - The enhancer init function to test (e.g., initTabs, initModals)
+ * @param setupDOM - Callback to create the necessary DOM structure and return the trigger element
+ * @param verify - Callback to verify the expected behavior after triggering
+ */
+export declare function testSingletonBehavior(initFn: () => EnhancerCleanup, setupDOM: () => HTMLElement, verify: (trigger: HTMLElement) => void): void;
+/**
+ * Mocks getBoundingClientRect on an HTML element with default positioning values.
+ * Useful for tests that require element dimensions and positioning (e.g., tooltips, popovers).
+ *
+ * @param element - The element to mock getBoundingClientRect on
+ * @param overrides - Optional partial DOMRect properties to override defaults
+ * @returns The vitest spy instance
+ */
+export declare function mockBoundingClientRect(element: HTMLElement, overrides?: Partial<DOMRect>): ReturnType<typeof vi.spyOn>;

package/dist/enhancers/test-utils.d.ts

@@ -0,0 +1,10 @@
+type InitFn = (opts?: {
+    root?: Element;
+}) => {
+    destroy: () => void;
+};
+export declare function testDestroyPreventsInteraction(init: InitFn, createDOM: () => HTMLElement, triggerAction: (el: HTMLElement) => void, verifyInactive: (el: HTMLElement) => void): void;
+export declare function testIdempotentInit(init: InitFn, createDOM: () => HTMLElement, act: (el: HTMLElement) => void): void;
+export declare function testNoMatchGraceful(init: InitFn): void;
+export declare function testCustomRoot(init: InitFn, setupInRoot: (root: HTMLElement) => void, verify: (root: HTMLElement) => void): void;
+export {};

package/dist/enhancers/toast.d.ts

@@ -0,0 +1,24 @@
+import { EnhancerCleanup, EnhancerOptions } from '../config/types.js';
+export declare const TOAST_CONTAINER_SELECTOR = "[data-sol-toast-container]";
+export type ToastType = 'success' | 'warning' | 'error' | 'info';
+export type ToastPosition = 'top-right' | 'top-left' | 'top-center' | 'bottom-right' | 'bottom-left' | 'bottom-center';
+export interface ToastOptions {
+    message: string;
+    type?: ToastType;
+    duration?: number;
+    position?: ToastPosition;
+}
+/**
+ * Programmatically show a toast notification.
+ * Creates DOM, animates in, and auto-dismisses after `duration` ms (default 5000).
+ */
+export declare function showToast(opts: ToastOptions): HTMLElement;
+/**
+ * Dismiss a specific toast element.
+ */
+export declare function dismissToast(toast: HTMLElement): void;
+/**
+ * Enhance all `[data-sol-toast-container]` elements with ARIA attributes
+ * and close button behavior on existing toasts.
+ */
+export declare function initToasts(options?: EnhancerOptions): EnhancerCleanup;

package/dist/enhancers/tooltip.d.ts

@@ -0,0 +1,15 @@
+import { EnhancerCleanup, EnhancerOptions } from '../config/types.js';
+export declare const TOOLTIP_SELECTOR = "[data-sol-tooltip]";
+/**
+ * Enhance all `[data-sol-tooltip]` elements with positioned tooltips.
+ *
+ * Attaches mouseenter/focus listeners that show a tooltip, and
+ * mouseleave/blur/Escape listeners that hide it. Creates a single shared
+ * tooltip element appended to `document.body`.
+ *
+ * @param options - Optional scoping and selector overrides.
+ * @returns Cleanup handle — call `destroy()` to remove all listeners and the
+ *          tooltip element. Re-calling `initTooltips()` implicitly cleans up
+ *          previous listeners.
+ */
+export declare function initTooltips(options?: EnhancerOptions): EnhancerCleanup;

package/dist/enhancers/tree.d.ts

@@ -0,0 +1,24 @@
+import { EnhancerCleanup, EnhancerOptions } from '../config/types.js';
+export declare const TREE_SELECTOR = "[data-sol-tree]";
+/**
+ * Enhance all `[data-sol-tree]` elements with expand/collapse and
+ * keyboard navigation behavior.
+ *
+ * Expected structure:
+ * ```html
+ * <div data-sol-tree class="tree" role="tree">
+ *   <div class="tree-branch tree-node" role="treeitem">
+ *     <div class="tree-node-content">
+ *       <button class="tree-toggle"></button>
+ *       Folder
+ *     </div>
+ *     <div class="tree-children">
+ *       <div class="tree-leaf tree-node" role="treeitem">
+ *         <div class="tree-node-content">File</div>
+ *       </div>
+ *     </div>
+ *   </div>
+ * </div>
+ * ```
+ */
+export declare function initTrees(options?: EnhancerOptions): EnhancerCleanup;

package/dist/enhancers/utils/click-away.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Register a callback that fires when a click occurs outside `element`.
+ * Uses the provided `AbortSignal` for cleanup — no manual teardown needed.
+ *
+ * @internal
+ */
+export declare function onClickAway(element: HTMLElement, callback: () => void, signal: AbortSignal): void;

package/dist/enhancers/utils/create-overlay-enhancer.d.ts

@@ -0,0 +1,14 @@
+import { EnhancerCleanup, EnhancerOptions } from '../../config/types.js';
+interface OverlayConfig {
+    overlaySelector: string;
+    openTriggerAttr: string;
+    closeTriggerAttr: string;
+    bodyOpenClass: string;
+    contentSelector: string;
+    childElementsToActivate: string[];
+    checkOverlayAsBackdrop: boolean;
+    backdropSelector: string;
+    setupAria?: (overlay: HTMLElement) => void;
+}
+export declare function createOverlayEnhancer(config: OverlayConfig): (options?: EnhancerOptions) => EnhancerCleanup;
+export {};

package/dist/enhancers/utils/focus-trap.d.ts

@@ -0,0 +1,9 @@
+declare const FOCUSABLE: string;
+/**
+ * Trap Tab/Shift+Tab focus within a container element.
+ * Call from a `keydown` handler when `e.key === 'Tab'`.
+ *
+ * @internal
+ */
+export declare function trapFocus(container: HTMLElement, event: KeyboardEvent): void;
+export { FOCUSABLE };

package/dist/enhancers/utils/generate-id.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Generate a short random ID string suitable for ARIA `id` attributes.
+ *
+ * @internal
+ */
+export declare function generateId(): string;

package/dist/enhancers/utils/keyboard-nav.d.ts

@@ -0,0 +1,21 @@
+/** @internal */
+export interface KeyboardNavOptions {
+    /** Container element holding the navigable items. */
+    container: HTMLElement;
+    /** CSS selector for individual navigable items within the container. */
+    itemSelector: string;
+    /** Navigation direction supported by the component. */
+    orientation: 'vertical' | 'horizontal' | 'both';
+    /** Wrap from last item to first (and vice versa). Defaults to true. */
+    wrap?: boolean;
+    /** Callback invoked when an item is activated (Enter/Space). */
+    onActivate?: (item: HTMLElement) => void;
+}
+/**
+ * Handle a keydown event for arrow-key navigation within a list of items.
+ * Manages `aria-activedescendant`-style focus by calling `focus()` on
+ * the target item. Returns true if the event was handled.
+ *
+ * @internal
+ */
+export declare function handleKeyboardNav(options: KeyboardNavOptions, event: KeyboardEvent): boolean;

package/dist/enhancers/utils/position.d.ts

@@ -0,0 +1,30 @@
+export type Placement = 'top' | 'bottom' | 'left' | 'right';
+export interface PositionOptions {
+    /** Anchor element or fixed coordinates (e.g. for context menus). */
+    anchor: HTMLElement | {
+        x: number;
+        y: number;
+    };
+    /** Floating element to position. */
+    floating: HTMLElement;
+    /** Preferred placement relative to the anchor. */
+    placement: Placement;
+    /** Gap between anchor and floating element in pixels. */
+    gap?: number;
+    /** Minimum distance from viewport edges in pixels. */
+    viewportPadding?: number;
+    /** Auto-flip to opposite side when clipped by viewport. */
+    flip?: boolean;
+}
+export interface PositionResult {
+    top: number;
+    left: number;
+}
+/**
+ * Compute absolute position for a floating element relative to an anchor.
+ * Supports viewport clamping and optional flip when the preferred placement
+ * would be clipped.
+ *
+ * @internal
+ */
+export declare function computePosition(options: PositionOptions): PositionResult;

package/dist/fonts/index.d.ts

@@ -0,0 +1,20 @@
+export declare const DEFAULT_FONT_URL: string;
+/**
+ * Inject a font stylesheet (and optional preconnect hints) into `<head>`.
+ *
+ * Idempotent: only the first call injects elements; subsequent calls are
+ * no-ops. The internal loaded flag is reset when `destroy()` is called on
+ * the Soltana instance, allowing re-initialization.
+ *
+ * @param url - Font CSS URL. Defaults to the bundled Google Fonts URL
+ *              containing Cinzel, Cinzel Decorative, Raleway, and JetBrains
+ *              Mono. When the URL
+ *              points to `fonts.googleapis.com`, preconnect links are also
+ *              injected automatically.
+ */
+export declare function loadSoltanaFonts(url?: string): void;
+/**
+ * Remove injected font elements and reset loaded flag. Called by destroy().
+ * @internal
+ */
+export declare function _resetFontLoader(): void;

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { initSoltana, DEFAULT_STATE } from './init.js';
+export { BUILT_IN_THEMES, BUILT_IN_RELIEFS, BUILT_IN_FINISHES } from './config/index.js';
+/** Advanced exports for runtime validation, testing, and custom integrations. */
+export { VALID_THEMES, VALID_RELIEFS, VALID_FINISHES } from './config/index.js';
+export type { SoltanaConfig, SoltanaInitOptions, SoltanaInstance, SoltanaChangeDetail, EnhancerCleanup, EnhancerOptions, Theme, Relief, Finish, BuiltInTheme, BuiltInRelief, BuiltInFinish, TierName, SoltanaChangeType, ThemeSeed, RegisterThemeOptions, RegisterReliefOptions, RegisterFinishOptions, TierRegistration, } from './config/index.js';
+export { initModals, initTabs, initTooltips, initAccordions, initDropdowns, initDrawers, initToasts, showToast, dismissToast, initCollapsibles, initComboboxes, initHoverCards, initContextMenus, initCarousels, initScrollAreas, initDatePickers, initColorPickers, initTrees, initAll, MODAL_SELECTOR, MODAL_OPEN_SELECTOR, TABS_SELECTOR, TOOLTIP_SELECTOR, ACCORDION_SELECTOR, DROPDOWN_SELECTOR, DRAWER_SELECTOR, DRAWER_OPEN_SELECTOR, TOAST_CONTAINER_SELECTOR, COLLAPSIBLE_SELECTOR, COMBOBOX_SELECTOR, HOVER_CARD_SELECTOR, CONTEXT_MENU_SELECTOR, CAROUSEL_SELECTOR, SCROLL_AREA_SELECTOR, DATE_PICKER_SELECTOR, COLOR_PICKER_SELECTOR, TREE_SELECTOR, } from './enhancers/index.js';
+export type { ToastOptions, ToastType, ToastPosition } from './enhancers/index.js';
+export { loadSoltanaFonts, DEFAULT_FONT_URL } from './fonts/index.js';
+export declare const version: string;

package/dist/init.d.ts

@@ -0,0 +1,16 @@
+import { SoltanaConfig, SoltanaInitOptions, SoltanaInstance } from './config/types.js';
+/**
+ * Default tier configuration used when no overrides are provided.
+ *
+ * - `theme: 'auto'` resolves to `'dark'` or `'light'` via `prefers-color-scheme`.
+ * - `relief: 'flat'` is the minimal baseline (no shadow effects).
+ * - `finish: 'matte'` is the zero-effect baseline (no blur, sheen, or tint).
+ *
+ * All built-in tier combinations (3 themes + auto resolver, 4 reliefs, 4 finishes) are valid.
+ */
+export declare const DEFAULT_STATE: Readonly<SoltanaConfig>;
+/**
+ * Initialize the Soltana design system.
+ * Sets data attributes on <html> to activate SCSS theme/relief/finish selectors.
+ */
+export declare function initSoltana(userConfig?: Partial<SoltanaConfig & SoltanaInitOptions>): SoltanaInstance;

package/dist/plugins/index.d.ts

@@ -0,0 +1,2 @@
+export { default as soltanaTreeshake } from './postcss-soltana-treeshake.js';
+export type { SoltanaTreeshakeOptions, TierConfig } from './types.js';

package/dist/plugins/index.js

@@ -0,0 +1 @@
+export { default as soltanaTreeshake } from './postcss-soltana-treeshake.js';

package/dist/plugins/postcss-soltana-treeshake.d.ts

@@ -0,0 +1,10 @@
+import type { Plugin } from 'postcss';
+import type { SoltanaTreeshakeOptions } from './types.js';
+/**
+ * PostCSS plugin that strips CSS rules referencing excluded tier values.
+ */
+declare function soltanaTreeshake(options?: SoltanaTreeshakeOptions): Plugin;
+declare namespace soltanaTreeshake {
+    var postcss: true;
+}
+export default soltanaTreeshake;

package/dist/plugins/postcss-soltana-treeshake.js

@@ -0,0 +1,149 @@
+// ---------------------------------------------------------------------------
+// PostCSS Soltana Tree-Shake Plugin
+// ---------------------------------------------------------------------------
+// Strips CSS rules referencing excluded built-in tier values from the compiled
+// output. Only explicitly excluded built-in values are removed — custom tier
+// values and non-tier selectors are never touched.
+// ---------------------------------------------------------------------------
+import { BUILT_IN_THEMES, BUILT_IN_RELIEFS, BUILT_IN_FINISHES } from '../config/index.js';
+const BUILT_IN = {
+    theme: BUILT_IN_THEMES,
+    relief: BUILT_IN_RELIEFS,
+    finish: BUILT_IN_FINISHES,
+};
+// Maps plural config keys to singular tier names used in selectors
+const TIER_KEY_MAP = {
+    themes: 'theme',
+    reliefs: 'relief',
+    finishes: 'finish',
+};
+// Matches [data-tier='value'] in a selector fragment (global for all occurrences)
+const DATA_ATTR_RE = /\[data-(theme|relief|finish)='([^']+)'\]/g;
+// Matches .tier-value in a selector fragment
+const CLASS_RE = /\.(theme|relief|finish)-([\w-]+)/;
+// Matches [data-tier='value'] that appears inside :not()
+const NEGATED_ATTR_RE = /:not\([^)]*\[data-(theme|relief|finish)='[^']+'\][^)]*\)/g;
+function isTierConfig(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const obj = value;
+    if ('include' in obj && !Array.isArray(obj.include))
+        return false;
+    if ('exclude' in obj && !Array.isArray(obj.exclude))
+        return false;
+    return true;
+}
+/**
+ * Compute the set of tier values to exclude from output.
+ */
+function buildExcludeSet(options) {
+    const excludes = new Map();
+    for (const [pluralKey, value] of Object.entries(options)) {
+        const tier = TIER_KEY_MAP[pluralKey];
+        if (!tier || !(tier in BUILT_IN))
+            continue;
+        if (!isTierConfig(value))
+            continue;
+        const tierConfig = value;
+        const builtIn = BUILT_IN[tier];
+        if (tierConfig.include && tierConfig.exclude) {
+            console.warn(`[soltana] Tier "${tier}" specifies both include and exclude; exclude will be ignored`);
+        }
+        let excluded;
+        const builtInSet = new Set(builtIn);
+        if (tierConfig.include) {
+            // Warn on unrecognized include values
+            for (const v of tierConfig.include) {
+                if (!builtInSet.has(v)) {
+                    console.warn(`[soltana] Treeshake: include value "${v}" is not a built-in ${tier}`);
+                }
+            }
+            // Exclude everything built-in that isn't in the include list
+            const included = new Set(tierConfig.include);
+            excluded = builtIn.filter((v) => !included.has(v));
+        }
+        else if (tierConfig.exclude) {
+            // Warn on unrecognized exclude values
+            for (const v of tierConfig.exclude) {
+                if (!builtInSet.has(v)) {
+                    console.warn(`[soltana] Treeshake: exclude value "${v}" is not a built-in ${tier}`);
+                }
+            }
+            // Exclude only explicitly listed values (intersected with built-in)
+            excluded = tierConfig.exclude.filter((v) => builtInSet.has(v));
+        }
+        else {
+            continue;
+        }
+        if (excluded.length > 0) {
+            excludes.set(tier, new Set(excluded));
+        }
+    }
+    return excludes;
+}
+/**
+ * Extract all tier + value pairs from a single selector fragment.
+ * Returns an empty array for neutral selectors (no tier reference).
+ * Ignores tier references inside :not() — those are negations, not positive matches.
+ */
+function extractTierRefs(fragment) {
+    const stripped = fragment.replace(NEGATED_ATTR_RE, '');
+    const refs = [];
+    DATA_ATTR_RE.lastIndex = 0;
+    let match;
+    while ((match = DATA_ATTR_RE.exec(stripped)) !== null) {
+        refs.push({ tier: match[1], value: match[2] });
+    }
+    const classMatch = CLASS_RE.exec(stripped);
+    if (classMatch) {
+        refs.push({ tier: classMatch[1], value: classMatch[2] });
+    }
+    return refs;
+}
+/**
+ * Determine whether a selector fragment should be excluded.
+ * A fragment is excluded if any of its tier references targets an excluded value.
+ */
+function isExcluded(fragment, excludes) {
+    const refs = extractTierRefs(fragment);
+    if (refs.length === 0)
+        return false; // Neutral selector — never excluded
+    return refs.some((ref) => {
+        const tierExcludes = excludes.get(ref.tier);
+        return tierExcludes?.has(ref.value) ?? false;
+    });
+}
+/**
+ * PostCSS plugin that strips CSS rules referencing excluded tier values.
+ */
+function soltanaTreeshake(options = {}) {
+    const excludes = buildExcludeSet(options);
+    return {
+        postcssPlugin: 'postcss-soltana-treeshake',
+        Once(root) {
+            if (excludes.size === 0)
+                return;
+            root.walkRules((rule) => {
+                // Never touch @keyframes children
+                if (rule.parent && 'name' in rule.parent && rule.parent.name === 'keyframes') {
+                    return;
+                }
+                const fragments = rule.selectors;
+                const kept = [];
+                for (const fragment of fragments) {
+                    if (!isExcluded(fragment, excludes)) {
+                        kept.push(fragment);
+                    }
+                }
+                if (kept.length === 0) {
+                    rule.remove();
+                }
+                else if (kept.length < fragments.length) {
+                    rule.selectors = kept;
+                }
+            });
+        },
+    };
+}
+soltanaTreeshake.postcss = true;
+export default soltanaTreeshake;

package/dist/plugins/types.d.ts

@@ -0,0 +1,9 @@
+export interface TierConfig {
+    include?: string[];
+    exclude?: string[];
+}
+export interface SoltanaTreeshakeOptions {
+    themes?: TierConfig;
+    reliefs?: TierConfig;
+    finishes?: TierConfig;
+}

package/dist/plugins/types.js

@@ -0,0 +1,4 @@
+// ---------------------------------------------------------------------------
+// Soltana Build Plugin Types
+// ---------------------------------------------------------------------------
+export {};