@dsai-io/tools 1.0.7 → 1.2.1

package/dist/index.js

@@ -4,7 +4,7 @@ import path2__default, { relative, basename, extname, join, dirname, parse, reso
 import { cosmiconfig, cosmiconfigSync } from 'cosmiconfig';
 import * as fs3 from 'fs';
 import { existsSync, readFileSync, readdirSync, statSync, writeFileSync, mkdirSync, rmSync } from 'fs';
-import { execSync } from 'child_process';
+import { execFileSync, execSync } from 'child_process';
 import { createHash } from 'crypto';
 import fg from 'fast-glob';
 import { readFile, writeFile } from 'fs/promises';
@@ -976,20 +976,6 @@ var init_line_height = __esm({
   }
 });
 
-// src/tokens/style-dictionary/transforms/name.ts
-var nameKebab;
-var init_name = __esm({
-  "src/tokens/style-dictionary/transforms/name.ts"() {
-    nameKebab = {
-      name: "name/kebab",
-      type: "name",
-      transform: (token) => {
-        return token.path.join("-").replace(/_/g, "-").toLowerCase();
-      }
-    };
-  }
-});
-
 // src/tokens/style-dictionary/transforms/name-js-identifier.ts
 function toPascalCaseSegment3(segment) {
   const needsNumericPrefix = /^\d/.test(segment);
@@ -1009,6 +995,20 @@ var init_name_js_identifier = __esm({
   }
 });
 
+// src/tokens/style-dictionary/transforms/name.ts
+var nameKebab;
+var init_name = __esm({
+  "src/tokens/style-dictionary/transforms/name.ts"() {
+    nameKebab = {
+      name: "name/kebab",
+      type: "name",
+      transform: (token) => {
+        return token.path.join("-").replace(/_/g, "-").toLowerCase();
+      }
+    };
+  }
+});
+
 // src/tokens/style-dictionary/transforms/index.ts
 var transforms_exports = {};
 __export(transforms_exports, {
@@ -1037,8 +1037,8 @@ var init_transforms = __esm({
     init_dimension();
     init_font_weight();
     init_line_height();
-    init_name();
     init_name_js_identifier();
+    init_name();
     init_font_weight();
     init_line_height();
     init_dimension();
@@ -1734,13 +1734,29 @@ var globalConfigSchema = z.object({
   framework: frameworkSchema.optional(),
   build: buildConfigSchema.optional()
 });
+var aliasesConfigSchema = z.object({
+  importAlias: z.string().optional().default("@/"),
+  ui: z.string().optional().default("src/components/ui"),
+  hooks: z.string().optional().default("src/hooks"),
+  utils: z.string().optional().default("src/lib/utils"),
+  components: z.string().optional().default("src/components"),
+  lib: z.string().optional().default("src/lib")
+});
+var componentsConfigSchema = z.object({
+  enabled: z.boolean().optional().default(true),
+  registryUrl: z.string().optional().default("https://registry.dsai.dev"),
+  tsx: z.boolean().optional().default(true),
+  overwrite: z.boolean().optional().default(false)
+});
 var dsaiConfigSchema = z.object({
   $schema: z.string().optional(),
   extends: z.union([z.string(), z.array(z.string())]).optional(),
   global: globalConfigSchema.optional(),
   tokens: tokensConfigSchema.optional(),
   themes: themesConfigSchema.optional(),
-  icons: iconsConfigSchema.optional()
+  icons: iconsConfigSchema.optional(),
+  aliases: aliasesConfigSchema.optional(),
+  components: componentsConfigSchema.optional()
 });
 function formatValidationErrors(zodError) {
   return zodError.issues.map((err) => ({
@@ -1778,7 +1794,9 @@ function validateConfigSection(section, config) {
     global: globalConfigSchema,
     tokens: tokensConfigSchema,
     themes: themesConfigSchema,
-    icons: iconsConfigSchema
+    icons: iconsConfigSchema,
+    aliases: aliasesConfigSchema,
+    components: componentsConfigSchema
   };
   const schema = sectionSchemas[section];
   if (!schema) {
@@ -1890,6 +1908,20 @@ var defaultIconsConfig = {
   optimize: true,
   prefix: "Icon"
 };
+var defaultAliasesConfig = {
+  importAlias: "@/",
+  ui: "src/components/ui",
+  hooks: "src/hooks",
+  utils: "src/lib/utils",
+  components: "src/components",
+  lib: "src/lib"
+};
+var defaultComponentsConfig = {
+  enabled: true,
+  registryUrl: "https://registry.dsai.dev",
+  tsx: true,
+  overwrite: false
+};
 var defaultTokensConfig = {
   source: "theme",
   sourceDir: DEFAULT_SOURCE_DIR,
@@ -1924,6 +1956,8 @@ var defaultGlobalConfig = {
 var defaultConfig = {
   tokens: defaultTokensConfig,
   icons: defaultIconsConfig,
+  aliases: defaultAliasesConfig,
+  components: defaultComponentsConfig,
   global: defaultGlobalConfig,
   configDir: process.cwd()
 };
@@ -2187,10 +2221,32 @@ function resolveTokensConfig(config, options) {
     postprocess: config?.postprocess
   };
 }
+function resolveAliasesConfig(config) {
+  const base = defaultAliasesConfig;
+  return {
+    importAlias: config?.importAlias ?? base.importAlias,
+    ui: config?.ui ?? base.ui,
+    hooks: config?.hooks ?? base.hooks,
+    utils: config?.utils ?? base.utils,
+    components: config?.components ?? base.components,
+    lib: config?.lib ?? base.lib
+  };
+}
+function resolveComponentsConfig(config) {
+  const base = defaultComponentsConfig;
+  return {
+    enabled: config?.enabled ?? base.enabled,
+    registryUrl: config?.registryUrl ?? base.registryUrl,
+    tsx: config?.tsx ?? base.tsx,
+    overwrite: config?.overwrite ?? base.overwrite
+  };
+}
 function applyOverrides(config, overrides) {
   return {
     tokens: overrides.tokens ? { ...config.tokens, ...overrides.tokens } : config.tokens,
     icons: overrides.icons ? { ...config.icons, ...overrides.icons } : config.icons,
+    aliases: overrides.aliases ? { ...config.aliases, ...overrides.aliases } : config.aliases,
+    components: overrides.components ? { ...config.components, ...overrides.components } : config.components,
     global: overrides.global ? { ...config.global, ...overrides.global } : config.global
   };
 }
@@ -2201,6 +2257,8 @@ function resolveConfig(config = {}, options = {}) {
     global: resolveGlobalConfig(mergedConfig.global, options),
     tokens: resolveTokensConfig(mergedConfig.tokens, options),
     icons: resolveIconsConfig(mergedConfig.icons, options),
+    aliases: resolveAliasesConfig(mergedConfig.aliases),
+    components: resolveComponentsConfig(mergedConfig.components),
     configDir
   };
 }
@@ -2216,6 +2274,8 @@ function createResolvedConfig(partial = {}) {
     global: partial.global ?? defaultConfig.global,
     tokens: partial.tokens ?? defaultConfig.tokens,
     icons: partial.icons ?? defaultConfig.icons,
+    aliases: partial.aliases ?? defaultConfig.aliases,
+    components: partial.components ?? defaultConfig.components,
     configDir: partial.configDir ?? process.cwd(),
     configPath: partial.configPath
   };
@@ -9072,6 +9132,1156 @@ async function buildIcons(config, options = {}) {
   result.duration = Date.now() - startTime;
   return result;
 }
+var registryItemTypeSchema = z.enum([
+  "registry:ui",
+  "registry:hook",
+  "registry:util",
+  "registry:lib",
+  "registry:component",
+  "registry:style",
+  "registry:type"
+]);
+var registryFileSchema = z.object({
+  path: z.string().min(1, "File path is required"),
+  type: registryItemTypeSchema,
+  content: z.string(),
+  target: z.string().optional()
+});
+var registryItemSchema = z.object({
+  name: z.string().min(1, "Registry item name is required"),
+  type: registryItemTypeSchema,
+  title: z.string().min(1, "Title is required"),
+  description: z.string().default(""),
+  dependencies: z.array(z.string()).default([]),
+  devDependencies: z.array(z.string()).default([]),
+  registryDependencies: z.array(z.string()).default([]),
+  files: z.array(registryFileSchema).min(1, "At least one file is required"),
+  cssVars: z.object({
+    light: z.record(z.string(), z.string()).optional(),
+    dark: z.record(z.string(), z.string()).optional()
+  }).optional(),
+  categories: z.array(z.string()).optional()
+});
+var registryIndexEntrySchema = z.object({
+  name: z.string(),
+  type: registryItemTypeSchema,
+  title: z.string(),
+  description: z.string(),
+  dependencies: z.array(z.string()),
+  registryDependencies: z.array(z.string()),
+  categories: z.array(z.string()).optional()
+});
+var registryIndexSchema = z.object({
+  version: z.string(),
+  count: z.number(),
+  items: z.array(registryIndexEntrySchema)
+});
+
+// src/registry/component-map.ts
+var componentMap = {
+  accordion: {
+    type: "registry:ui",
+    title: "Accordion",
+    description: "Collapsible content panels for presenting information in a limited space.",
+    categories: ["disclosure", "layout"]
+  },
+  alert: {
+    type: "registry:ui",
+    title: "Alert",
+    description: "Contextual feedback messages for user actions.",
+    categories: ["feedback"]
+  },
+  avatar: {
+    type: "registry:ui",
+    title: "Avatar",
+    description: "Graphical representation of a user or entity.",
+    categories: ["data-display"]
+  },
+  badge: {
+    type: "registry:ui",
+    title: "Badge",
+    description: "Small count or status indicator, typically displayed on other elements.",
+    categories: ["data-display"]
+  },
+  breadcrumb: {
+    type: "registry:ui",
+    title: "Breadcrumb",
+    description: "Navigation aid showing the current page location within a hierarchy.",
+    categories: ["navigation"]
+  },
+  button: {
+    type: "registry:ui",
+    title: "Button",
+    description: "Trigger for actions and events.",
+    categories: ["actions"]
+  },
+  card: {
+    type: "registry:ui",
+    title: "Card",
+    description: "Flexible container for grouping related content and actions.",
+    categories: ["layout", "data-display"]
+  },
+  "card-list": {
+    type: "registry:ui",
+    title: "CardList",
+    description: "Responsive list of selectable cards with keyboard navigation.",
+    categories: ["layout", "data-display"]
+  },
+  carousel: {
+    type: "registry:ui",
+    title: "Carousel",
+    description: "Slideshow component for cycling through content.",
+    categories: ["data-display"]
+  },
+  checkbox: {
+    type: "registry:ui",
+    title: "Checkbox",
+    description: "Toggle control for boolean selections.",
+    categories: ["forms"]
+  },
+  "checkbox-group": {
+    type: "registry:ui",
+    title: "CheckboxGroup",
+    description: "Managed group of checkboxes with shared state.",
+    categories: ["forms"]
+  },
+  dropdown: {
+    type: "registry:ui",
+    title: "Dropdown",
+    description: "Toggleable overlay menu for displaying a list of actions.",
+    categories: ["navigation", "actions"],
+    npmDependencies: ["@floating-ui/react"]
+  },
+  icon: {
+    type: "registry:ui",
+    title: "Icon",
+    description: "Scalable vector icon component with accessibility support.",
+    categories: ["data-display"]
+  },
+  input: {
+    type: "registry:ui",
+    title: "Input",
+    description: "Text input field with validation and formatting support.",
+    categories: ["forms"]
+  },
+  "list-group": {
+    type: "registry:ui",
+    title: "ListGroup",
+    description: "Flexible component for displaying a series of items.",
+    categories: ["data-display", "navigation"]
+  },
+  modal: {
+    type: "registry:ui",
+    title: "Modal",
+    description: "Dialog overlay for focused content and user interactions.",
+    categories: ["feedback", "disclosure"]
+  },
+  navbar: {
+    type: "registry:ui",
+    title: "Navbar",
+    description: "Responsive navigation header with branding and links.",
+    categories: ["navigation"]
+  },
+  pagination: {
+    type: "registry:ui",
+    title: "Pagination",
+    description: "Navigation controls for paged content.",
+    categories: ["navigation"]
+  },
+  popover: {
+    type: "registry:ui",
+    title: "Popover",
+    description: "Floating content panel anchored to a trigger element.",
+    categories: ["disclosure"],
+    npmDependencies: ["@floating-ui/react"]
+  },
+  progress: {
+    type: "registry:ui",
+    title: "Progress",
+    description: "Visual indicator of task completion.",
+    categories: ["feedback"]
+  },
+  radio: {
+    type: "registry:ui",
+    title: "Radio",
+    description: "Single-select control within a group of options.",
+    categories: ["forms"]
+  },
+  scrollspy: {
+    type: "registry:ui",
+    title: "Scrollspy",
+    description: "Automatically highlights navigation links based on scroll position.",
+    categories: ["navigation"]
+  },
+  select: {
+    type: "registry:ui",
+    title: "Select",
+    description: "Dropdown selector for choosing from a list of options.",
+    categories: ["forms"],
+    npmDependencies: ["@floating-ui/react"]
+  },
+  "selectable-card": {
+    type: "registry:ui",
+    title: "SelectableCard",
+    description: "Card variant that acts as a selectable option.",
+    categories: ["forms", "data-display"]
+  },
+  sheet: {
+    type: "registry:ui",
+    title: "Sheet",
+    description: "Sliding panel overlay from screen edges.",
+    categories: ["disclosure", "layout"]
+  },
+  spinner: {
+    type: "registry:ui",
+    title: "Spinner",
+    description: "Loading indicator for asynchronous operations.",
+    categories: ["feedback"]
+  },
+  switch: {
+    type: "registry:ui",
+    title: "Switch",
+    description: "Toggle control for binary on/off states.",
+    categories: ["forms"]
+  },
+  table: {
+    type: "registry:ui",
+    title: "Table",
+    description: "Data table with sorting, selection, and responsive layout.",
+    categories: ["data-display"]
+  },
+  tabs: {
+    type: "registry:ui",
+    title: "Tabs",
+    description: "Tabbed interface for switching between content panels.",
+    categories: ["navigation", "layout"]
+  },
+  "tabs-pro": {
+    type: "registry:ui",
+    title: "TabsPro",
+    description: "Advanced tabbed interface with closable, sortable, and overflow support.",
+    categories: ["navigation", "layout"]
+  },
+  toast: {
+    type: "registry:ui",
+    title: "Toast",
+    description: "Brief notification messages that auto-dismiss.",
+    categories: ["feedback"]
+  },
+  tooltip: {
+    type: "registry:ui",
+    title: "Tooltip",
+    description: "Informational popup displayed on hover or focus.",
+    categories: ["data-display"],
+    npmDependencies: ["@floating-ui/react"]
+  },
+  typography: {
+    type: "registry:ui",
+    title: "Typography",
+    description: "Text rendering primitives with semantic variants.",
+    categories: ["data-display"]
+  }
+};
+var hookMap = {
+  "use-async": {
+    type: "registry:hook",
+    title: "useAsync",
+    description: "Manages async operation lifecycle (loading, error, data states).",
+    categories: ["state"]
+  },
+  "use-callback-ref": {
+    type: "registry:hook",
+    title: "useCallbackRef",
+    description: "Stable callback reference that always points to the latest function.",
+    categories: ["refs"]
+  },
+  "use-click-outside": {
+    type: "registry:hook",
+    title: "useClickOutside",
+    description: "Detects clicks outside of a target element.",
+    categories: ["dom"]
+  },
+  "use-controllable-state": {
+    type: "registry:hook",
+    title: "useControllableState",
+    description: "Manages state that can be either controlled or uncontrolled.",
+    categories: ["state"]
+  },
+  "use-dark-mode": {
+    type: "registry:hook",
+    title: "useDarkMode",
+    description: "Detects and toggles dark mode preference.",
+    categories: ["theme"]
+  },
+  "use-debounce": {
+    type: "registry:hook",
+    title: "useDebounce",
+    description: "Debounces a value or callback over a specified delay.",
+    categories: ["timing"]
+  },
+  "use-field": {
+    type: "registry:hook",
+    title: "useField",
+    description: "Form field state management with validation.",
+    categories: ["forms"]
+  },
+  "use-focus-trap": {
+    type: "registry:hook",
+    title: "useFocusTrap",
+    description: "Traps keyboard focus within a container for modal-like experiences.",
+    categories: ["a11y"]
+  },
+  "use-form": {
+    type: "registry:hook",
+    title: "useForm",
+    description: "Comprehensive form state management with validation.",
+    categories: ["forms"]
+  },
+  "use-hover": {
+    type: "registry:hook",
+    title: "useHover",
+    description: "Tracks hover state of an element with enter/leave delays.",
+    categories: ["dom"]
+  },
+  "use-id": {
+    type: "registry:hook",
+    title: "useId",
+    description: "Generates stable unique identifiers for accessibility attributes.",
+    categories: ["a11y"]
+  },
+  "use-intersection-observer": {
+    type: "registry:hook",
+    title: "useIntersectionObserver",
+    description: "Observes element visibility within the viewport.",
+    categories: ["dom"]
+  },
+  "use-key-press": {
+    type: "registry:hook",
+    title: "useKeyPress",
+    description: "Listens for specific keyboard key presses.",
+    categories: ["dom"]
+  },
+  "use-local-storage": {
+    type: "registry:hook",
+    title: "useLocalStorage",
+    description: "Persists state to localStorage with serialization.",
+    categories: ["state", "storage"]
+  },
+  "use-media-query": {
+    type: "registry:hook",
+    title: "useMediaQuery",
+    description: "Matches CSS media queries and provides responsive breakpoint helpers.",
+    categories: ["responsive"]
+  },
+  "use-mounted": {
+    type: "registry:hook",
+    title: "useMounted",
+    description: "Tracks whether the component is currently mounted.",
+    categories: ["lifecycle"]
+  },
+  "use-previous": {
+    type: "registry:hook",
+    title: "usePrevious",
+    description: "Returns the previous value of a variable across renders.",
+    categories: ["state"]
+  },
+  "use-reduced-motion": {
+    type: "registry:hook",
+    title: "useReducedMotion",
+    description: "Detects user preference for reduced motion.",
+    categories: ["a11y"]
+  },
+  "use-resize-observer": {
+    type: "registry:hook",
+    title: "useResizeObserver",
+    description: "Observes element size changes via ResizeObserver.",
+    categories: ["dom"]
+  },
+  "use-roving-focus": {
+    type: "registry:hook",
+    title: "useRovingFocus",
+    description: "Implements roving tabindex pattern for composite widgets.",
+    categories: ["a11y"]
+  },
+  "use-scroll-lock": {
+    type: "registry:hook",
+    title: "useScrollLock",
+    description: "Prevents body scrolling while active (for modals/overlays).",
+    categories: ["dom"]
+  },
+  "use-session-storage": {
+    type: "registry:hook",
+    title: "useSessionStorage",
+    description: "Persists state to sessionStorage with serialization.",
+    categories: ["state", "storage"]
+  },
+  "use-throttle": {
+    type: "registry:hook",
+    title: "useThrottle",
+    description: "Throttles a value or callback to fire at most once per interval.",
+    categories: ["timing"]
+  }
+};
+var utilMap = {
+  cn: {
+    type: "registry:util",
+    title: "cn",
+    description: "Conditional class name composition utility.",
+    categories: ["styling"]
+  },
+  a11y: {
+    type: "registry:util",
+    title: "a11y",
+    description: "Accessibility utilities including screen reader announcements and ARIA helpers.",
+    categories: ["a11y"]
+  },
+  async: {
+    type: "registry:util",
+    title: "async",
+    description: "Async operation utilities: abortable tasks, queues, exponential backoff.",
+    categories: ["async"]
+  },
+  browser: {
+    type: "registry:util",
+    title: "browser",
+    description: "Browser environment detection and feature checks.",
+    categories: ["platform"]
+  },
+  collections: {
+    type: "registry:util",
+    title: "collections",
+    description: "Collection utilities: chunk, paginate, memoize, selectors.",
+    categories: ["data"]
+  },
+  color: {
+    type: "registry:util",
+    title: "color",
+    description: "Color manipulation utilities: contrast, luminance, hex/rgb conversion.",
+    categories: ["styling"]
+  },
+  date: {
+    type: "registry:util",
+    title: "date",
+    description: "Date formatting and relative time utilities.",
+    categories: ["formatting"]
+  },
+  "merge-refs": {
+    type: "registry:util",
+    title: "mergeRefs",
+    description: "Merges multiple React refs into a single callback ref.",
+    categories: ["refs"]
+  },
+  dx: {
+    type: "registry:util",
+    title: "dx",
+    description: "Developer experience helpers: component creation, context factories, polymorphic patterns.",
+    categories: ["dx"]
+  },
+  forms: {
+    type: "registry:util",
+    title: "forms",
+    description: "Form utilities: validators, field error extraction, dirty checking.",
+    categories: ["forms"]
+  },
+  keyboard: {
+    type: "registry:util",
+    title: "keyboard",
+    description: "Keyboard event helpers for detecting specific keys.",
+    categories: ["dom"]
+  },
+  layout: {
+    type: "registry:util",
+    title: "layout",
+    description: "Layout measurement utilities: element bounds, viewport size, resize observation.",
+    categories: ["dom"]
+  },
+  misc: {
+    type: "registry:util",
+    title: "misc",
+    description: "Miscellaneous utilities: clear icon, safe input props, event helpers.",
+    categories: ["misc"]
+  },
+  motion: {
+    type: "registry:util",
+    title: "motion",
+    description: "Animation utilities: spring physics, easing functions, distance calculations.",
+    categories: ["animation"]
+  },
+  number: {
+    type: "registry:util",
+    title: "number",
+    description: "Number formatting and clamping utilities.",
+    categories: ["formatting"]
+  },
+  object: {
+    type: "registry:util",
+    title: "object",
+    description: "Object manipulation utilities: deep merge, pick, omit.",
+    categories: ["data"]
+  },
+  platform: {
+    type: "registry:util",
+    title: "platform",
+    description: "Platform detection utilities: browser, OS, device pixel ratio, text direction.",
+    categories: ["platform"]
+  },
+  responsive: {
+    type: "registry:util",
+    title: "responsive",
+    description: "Responsive design utilities.",
+    categories: ["responsive"]
+  },
+  safety: {
+    type: "registry:util",
+    title: "safety",
+    description: "Security utilities: clipboard access, crypto ID generation, token generation.",
+    categories: ["security"]
+  },
+  string: {
+    type: "registry:util",
+    title: "string",
+    description: "String manipulation utilities: capitalize, slugify, variant classes.",
+    categories: ["formatting"]
+  },
+  telemetry: {
+    type: "registry:util",
+    title: "telemetry",
+    description: "Telemetry utilities: error catching, performance measurement, timing.",
+    categories: ["observability"]
+  },
+  timing: {
+    type: "registry:util",
+    title: "timing",
+    description: "Timing utilities: debounce and throttle functions.",
+    categories: ["timing"]
+  },
+  types: {
+    type: "registry:util",
+    title: "types",
+    description: "Shared type guards and type utilities.",
+    categories: ["types"]
+  },
+  validation: {
+    type: "registry:util",
+    title: "validation",
+    description: "Input validation utilities: email, URL, href safety checks.",
+    categories: ["validation"]
+  }
+};
+var directoryToRegistryName = {
+  Accordion: "accordion",
+  Alert: "alert",
+  Avatar: "avatar",
+  Badge: "badge",
+  Breadcrumb: "breadcrumb",
+  Button: "button",
+  Card: "card",
+  CardList: "card-list",
+  Carousel: "carousel",
+  Checkbox: "checkbox",
+  CheckboxGroup: "checkbox-group",
+  Dropdown: "dropdown",
+  Icon: "icon",
+  Input: "input",
+  ListGroup: "list-group",
+  Modal: "modal",
+  Navbar: "navbar",
+  Pagination: "pagination",
+  Popover: "popover",
+  Progress: "progress",
+  Radio: "radio",
+  Scrollspy: "scrollspy",
+  Select: "select",
+  SelectableCard: "selectable-card",
+  Sheet: "sheet",
+  Spinner: "spinner",
+  Switch: "switch",
+  Table: "table",
+  Tabs: "tabs",
+  TabsPro: "tabs-pro",
+  Toast: "toast",
+  Tooltip: "tooltip",
+  Typography: "typography"
+};
+var hookDirectoryToRegistryName = {
+  useAsync: "use-async",
+  useCallbackRef: "use-callback-ref",
+  useClickOutside: "use-click-outside",
+  useControllableState: "use-controllable-state",
+  useDarkMode: "use-dark-mode",
+  useDebounce: "use-debounce",
+  useField: "use-field",
+  useFocusTrap: "use-focus-trap",
+  useForm: "use-form",
+  useHover: "use-hover",
+  useId: "use-id",
+  useIntersectionObserver: "use-intersection-observer",
+  useKeyPress: "use-key-press",
+  useLocalStorage: "use-local-storage",
+  useMediaQuery: "use-media-query",
+  useMounted: "use-mounted",
+  usePrevious: "use-previous",
+  useReducedMotion: "use-reduced-motion",
+  useResizeObserver: "use-resize-observer",
+  useRovingFocus: "use-roving-focus",
+  useScrollLock: "use-scroll-lock",
+  useSessionStorage: "use-session-storage",
+  useThrottle: "use-throttle"
+};
+
+// src/registry/builder.ts
+var EXCLUDE_PATTERNS = [
+  /\.test\.(tsx?|jsx?)$/,
+  /\.spec\.(tsx?|jsx?)$/,
+  /\.stories\.(tsx?|jsx?)$/,
+  /\.figma\.(tsx?|jsx?)$/,
+  /\.a11y\.test\./,
+  /\.security\.test\./,
+  /\.integration\.test\./,
+  /README\.md$/
+];
+var REACT_BUILTINS = /* @__PURE__ */ new Set(["react", "react-dom", "react/jsx-runtime", "react-dom/client"]);
+var UTIL_SUBPATH_TO_REGISTRY = {
+  index: "cn",
+  keyboard: "keyboard",
+  dom: "merge-refs",
+  "dom/mergeRefs": "merge-refs",
+  browser: "browser",
+  validation: "validation",
+  string: "string",
+  misc: "misc",
+  a11y: "a11y",
+  types: "types",
+  async: "async",
+  collections: "collections",
+  color: "color",
+  date: "date",
+  dx: "dx",
+  forms: "forms",
+  layout: "layout",
+  motion: "motion",
+  number: "number",
+  object: "object",
+  platform: "platform",
+  responsive: "responsive",
+  safety: "safety",
+  telemetry: "telemetry",
+  timing: "timing"
+};
+function shouldIncludeFile(filePath) {
+  const ext = extname(filePath);
+  if (![".ts", ".tsx", ".css"].includes(ext)) return false;
+  return !EXCLUDE_PATTERNS.some((pattern) => pattern.test(filePath));
+}
+function readSourceFiles(dirPath) {
+  if (!existsSync(dirPath) || !statSync(dirPath).isDirectory()) return [];
+  const results = [];
+  for (const entry of readdirSync(dirPath, { withFileTypes: true })) {
+    const fullPath = join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      for (const sub of readdirSync(fullPath, { withFileTypes: true })) {
+        if (sub.isFile()) {
+          const subPath = join(fullPath, sub.name);
+          if (shouldIncludeFile(subPath)) {
+            results.push({ path: relative(dirPath, subPath), content: readFileSync(subPath, "utf-8") });
+          }
+        }
+      }
+    } else if (entry.isFile() && shouldIncludeFile(fullPath)) {
+      results.push({ path: entry.name, content: readFileSync(fullPath, "utf-8") });
+    }
+  }
+  return results;
+}
+function extractCnSource(utilsIndexPath) {
+  const content = readFileSync(utilsIndexPath, "utf-8");
+  const cnPattern = /(\/\*\*[\s\S]*?\*\/\s*)?export function cn\b[\s\S]*?\n\}/;
+  const match = cnPattern.exec(content);
+  return match ? match[0] : "export function cn(...classes: (string | boolean | undefined | null)[]): string {\n  return classes.filter(Boolean).join(' ');\n}";
+}
+function analyzeImports(files, knownNpmDeps) {
+  const registryDeps = /* @__PURE__ */ new Set();
+  const npmDeps = new Set(knownNpmDeps);
+  const importPattern = /(?:import|export)\s+(?:[\s\S]*?)\s+from\s+['"]([^'"]+)['"]/g;
+  for (const file of files) {
+    let m;
+    importPattern.lastIndex = 0;
+    while ((m = importPattern.exec(file.content)) !== null) {
+      const specifier = m[1] ?? "";
+      const typesPattern = /\.\.\/(?:\.\.\/)?types(?:\/.*)?$/;
+      if (typesPattern.test(specifier)) {
+        registryDeps.add("dsai-types");
+        continue;
+      }
+      const hookPattern = /\.\.\/(?:\.\.\/)?hooks\/(\w+)/;
+      const hookMatch = hookPattern.exec(specifier);
+      if (hookMatch && hookMatch[1]) {
+        const regName = hookDirectoryToRegistryName[hookMatch[1]];
+        if (regName) registryDeps.add(regName);
+        continue;
+      }
+      const utilPattern = /\.\.\/(?:\.\.\/)?utils(?:\/(.+))?$/;
+      const utilMatch = utilPattern.exec(specifier);
+      if (utilMatch) {
+        const subpath = utilMatch[1] ?? "index";
+        const regName = UTIL_SUBPATH_TO_REGISTRY[subpath];
+        if (regName) registryDeps.add(regName);
+        continue;
+      }
+      const compPattern = /^\.\.\/(\.\.\/)?(?:components\/)?([A-Z]\w+)(?:\/.*)?$/;
+      const compMatch = compPattern.exec(specifier);
+      if (compMatch && compMatch[2]) {
+        const compDir = compMatch[2];
+        const regName = directoryToRegistryName[compDir];
+        if (regName) registryDeps.add(regName);
+        continue;
+      }
+      if (!specifier.startsWith(".") && !specifier.startsWith("/")) {
+        const parts = specifier.split("/");
+        const pkgName = specifier.startsWith("@") && parts.length >= 2 ? `${parts[0]}/${parts[1]}` : parts[0] ?? specifier;
+        if (pkgName && !REACT_BUILTINS.has(pkgName) && !pkgName.startsWith("@dsai-io/")) {
+          npmDeps.add(pkgName);
+        }
+      }
+    }
+  }
+  return { registryDeps, npmDeps };
+}
+function buildComponentItem(name, dirPath, log) {
+  const meta = componentMap[name];
+  if (!meta) {
+    log(`  [WARN] No metadata for component "${name}", skipping`);
+    return null;
+  }
+  const sourceFiles = readSourceFiles(dirPath);
+  if (sourceFiles.length === 0) {
+    log(`  [WARN] No source files found in ${dirPath}`);
+    return null;
+  }
+  const { registryDeps, npmDeps } = analyzeImports(sourceFiles, meta.npmDependencies ?? []);
+  const files = sourceFiles.map((f) => ({
+    path: f.path,
+    type: extname(f.path) === ".css" ? "registry:style" : meta.type,
+    content: f.content
+  }));
+  return {
+    name,
+    type: meta.type,
+    title: meta.title,
+    description: meta.description,
+    dependencies: [...npmDeps].sort(),
+    devDependencies: [],
+    registryDependencies: [...registryDeps].sort(),
+    files,
+    categories: meta.categories
+  };
+}
+function buildHookItem(name, dirPath, log) {
+  const meta = hookMap[name];
+  if (!meta) {
+    log(`  [WARN] No metadata for hook "${name}", skipping`);
+    return null;
+  }
+  const sourceFiles = readSourceFiles(dirPath);
+  if (sourceFiles.length === 0) {
+    log(`  [WARN] No source files found in ${dirPath}`);
+    return null;
+  }
+  const { registryDeps, npmDeps } = analyzeImports(sourceFiles, meta.npmDependencies ?? []);
+  const files = sourceFiles.map((f) => ({
+    path: f.path,
+    type: extname(f.path) === ".css" ? "registry:style" : meta.type,
+    content: f.content
+  }));
+  return {
+    name,
+    type: meta.type,
+    title: meta.title,
+    description: meta.description,
+    dependencies: [...npmDeps].sort(),
+    devDependencies: [],
+    registryDependencies: [...registryDeps].sort(),
+    files,
+    categories: meta.categories
+  };
+}
+function buildUtilItem(name, reactSrcDir, log) {
+  const meta = utilMap[name];
+  if (!meta) {
+    log(`  [WARN] No metadata for util "${name}", skipping`);
+    return null;
+  }
+  let files;
+  let registryDeps = /* @__PURE__ */ new Set();
+  let npmDeps = /* @__PURE__ */ new Set();
+  if (name === "cn") {
+    const indexPath = join(reactSrcDir, "utils", "index.ts");
+    const cnSource = extractCnSource(indexPath);
+    files = [{ path: "cn.ts", type: "registry:util", content: cnSource }];
+  } else if (name === "merge-refs") {
+    const dirPath = join(reactSrcDir, "utils", "dom");
+    const sourceFiles = readSourceFiles(dirPath);
+    const analyzed = analyzeImports(sourceFiles, []);
+    registryDeps = analyzed.registryDeps;
+    npmDeps = analyzed.npmDeps;
+    files = sourceFiles.map((f) => ({
+      path: `dom/${f.path}`,
+      type: extname(f.path) === ".css" ? "registry:style" : "registry:util",
+      content: f.content
+    }));
+  } else {
+    const dirPath = join(reactSrcDir, "utils", name);
+    if (!existsSync(dirPath) || !statSync(dirPath).isDirectory()) {
+      log(`  [WARN] Util directory not found: ${dirPath}`);
+      return null;
+    }
+    const sourceFiles = readSourceFiles(dirPath);
+    if (sourceFiles.length === 0) {
+      log(`  [WARN] No source files found in ${dirPath}`);
+      return null;
+    }
+    const analyzed = analyzeImports(sourceFiles, []);
+    registryDeps = analyzed.registryDeps;
+    npmDeps = analyzed.npmDeps;
+    files = sourceFiles.map((f) => ({
+      path: `${name}/${f.path}`,
+      type: extname(f.path) === ".css" ? "registry:style" : "registry:util",
+      content: f.content
+    }));
+  }
+  return {
+    name,
+    type: meta.type,
+    title: meta.title,
+    description: meta.description,
+    dependencies: [...npmDeps].sort(),
+    devDependencies: [],
+    registryDependencies: [...registryDeps].sort(),
+    files,
+    categories: meta.categories
+  };
+}
+function buildTypesItem(reactSrcDir, log) {
+  const typesDir = join(reactSrcDir, "types");
+  const sourceFiles = readSourceFiles(typesDir);
+  if (sourceFiles.length === 0) {
+    log("  [WARN] No type files found");
+    return null;
+  }
+  const files = sourceFiles.map((f) => {
+    let content = f.content;
+    content = content.replace(/export \{[^}]*\} from ['"]\.\.\/utils\/[^'"]+['"];?\n?/g, "");
+    return {
+      path: `types/${f.path}`,
+      type: "registry:type",
+      content
+    };
+  });
+  return {
+    name: "dsai-types",
+    type: "registry:type",
+    title: "Shared Types",
+    description: "Shared type definitions (SafeHTMLAttributes, ComponentSize, PolymorphicComponentProps, etc.)",
+    dependencies: [],
+    devDependencies: [],
+    registryDependencies: [],
+    files,
+    categories: ["types"]
+  };
+}
+function buildRegistry(options) {
+  const { reactSrcDir, outputDir, verbose = false } = options;
+  const log = verbose ? (msg) => console.log(msg) : (_msg) => {
+  };
+  const componentsDir = join(reactSrcDir, "components");
+  const hooksDir = join(reactSrcDir, "hooks");
+  const allItems = [];
+  log("[registry] Scanning components...");
+  if (existsSync(componentsDir)) {
+    for (const entry of readdirSync(componentsDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const dirName = entry.name;
+      const registryName = directoryToRegistryName[dirName];
+      if (!registryName) {
+        log(`  [SKIP] Unknown component directory: ${dirName}`);
+        continue;
+      }
+      log(`  Building ${registryName}...`);
+      const item = buildComponentItem(registryName, join(componentsDir, dirName), log);
+      if (item) allItems.push(item);
+    }
+  }
+  log("[registry] Scanning hooks...");
+  if (existsSync(hooksDir)) {
+    for (const entry of readdirSync(hooksDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const dirName = entry.name;
+      const registryName = hookDirectoryToRegistryName[dirName];
+      if (!registryName) {
+        log(`  [SKIP] Unknown hook directory: ${dirName}`);
+        continue;
+      }
+      log(`  Building ${registryName}...`);
+      const item = buildHookItem(registryName, join(hooksDir, dirName), log);
+      if (item) allItems.push(item);
+    }
+  }
+  log("[registry] Scanning utils...");
+  for (const name of Object.keys(utilMap)) {
+    log(`  Building ${name}...`);
+    const item = buildUtilItem(name, reactSrcDir, log);
+    if (item) allItems.push(item);
+  }
+  log("[registry] Building shared types...");
+  const typesItem = buildTypesItem(reactSrcDir, log);
+  if (typesItem) {
+    allItems.push(typesItem);
+    log(`  Built dsai-types (${typesItem.files.length} files)`);
+  }
+  log(`[registry] Writing ${allItems.length} items to ${outputDir}...`);
+  for (const sub of ["components", "hooks", "utils", "types"]) {
+    const dir = join(outputDir, sub);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  }
+  const typeToSubdir = {
+    "registry:ui": "components",
+    "registry:component": "components",
+    "registry:hook": "hooks",
+    "registry:util": "utils",
+    "registry:lib": "utils",
+    "registry:type": "types"
+  };
+  for (const item of allItems) {
+    const subdir = typeToSubdir[item.type] ?? "utils";
+    const filePath = join(outputDir, subdir, `${item.name}.json`);
+    writeFileSync(filePath, JSON.stringify(item, null, 2) + "\n", "utf-8");
+    log(`  Wrote ${relative(outputDir, filePath)}`);
+  }
+  const indexEntries = allItems.map((item) => ({
+    name: item.name,
+    type: item.type,
+    title: item.title,
+    description: item.description,
+    dependencies: item.dependencies,
+    registryDependencies: item.registryDependencies,
+    categories: item.categories
+  }));
+  const registryIndex = {
+    version: "0.1.0",
+    count: indexEntries.length,
+    items: indexEntries
+  };
+  writeFileSync(join(outputDir, "index.json"), JSON.stringify(registryIndex, null, 2) + "\n", "utf-8");
+  log(`[registry] Wrote index.json (${registryIndex.count} items)`);
+  return registryIndex;
+}
+function loadItem(name, registryDir) {
+  const subdirs = ["components", "hooks", "utils", "lib", "styles", "types"];
+  for (const sub of subdirs) {
+    const filePath = join(registryDir, sub, `${name}.json`);
+    if (existsSync(filePath)) {
+      return JSON.parse(readFileSync(filePath, "utf-8"));
+    }
+  }
+  return null;
+}
+function resolveTree(names, registryDir) {
+  const visited = /* @__PURE__ */ new Map();
+  const queue = [...names];
+  while (queue.length > 0) {
+    const name = queue.shift();
+    if (visited.has(name)) continue;
+    const item = loadItem(name, registryDir);
+    if (!item) {
+      throw new Error(`Registry item "${name}" not found. Run \`dsai registry build\` or check the name.`);
+    }
+    visited.set(name, item);
+    for (const dep of item.registryDependencies) {
+      if (!visited.has(dep)) queue.push(dep);
+    }
+  }
+  const inDeg = /* @__PURE__ */ new Map();
+  for (const [name, item] of visited) {
+    inDeg.set(name, item.registryDependencies.filter((d) => visited.has(d)).length);
+  }
+  const sorted = [];
+  const ready = [];
+  for (const [name, deg] of inDeg) {
+    if (deg === 0) ready.push(name);
+  }
+  while (ready.length > 0) {
+    const name = ready.shift();
+    sorted.push(visited.get(name));
+    for (const [otherName, otherItem] of visited) {
+      if (otherItem.registryDependencies.includes(name)) {
+        const newDeg = (inDeg.get(otherName) ?? 1) - 1;
+        inDeg.set(otherName, newDeg);
+        if (newDeg === 0) ready.push(otherName);
+      }
+    }
+  }
+  if (sorted.length !== visited.size) {
+    const missing = [...visited.keys()].filter((n) => !sorted.some((s) => s.name === n));
+    throw new Error(`Circular dependency detected involving: ${missing.join(", ")}`);
+  }
+  const allDeps = /* @__PURE__ */ new Set();
+  const allDevDeps = /* @__PURE__ */ new Set();
+  const lightVars = {};
+  const darkVars = {};
+  for (const item of sorted) {
+    for (const dep of item.dependencies) allDeps.add(dep);
+    for (const dep of item.devDependencies) allDevDeps.add(dep);
+    if (item.cssVars?.light) Object.assign(lightVars, item.cssVars.light);
+    if (item.cssVars?.dark) Object.assign(darkVars, item.cssVars.dark);
+  }
+  return {
+    items: sorted,
+    dependencies: [...allDeps],
+    devDependencies: [...allDevDeps],
+    cssVars: { light: lightVars, dark: darkVars }
+  };
+}
+
+// src/registry/transformer.ts
+function transformImports(content, options) {
+  const { aliases } = options;
+  let result = content;
+  result = result.replace(
+    /(from\s+['"])(?:\.\.\/)+types(?:\/([^'"]+))?(['"])/g,
+    (_match, prefix, subpath, suffix) => {
+      if (subpath) {
+        return `${prefix}${aliases.importAlias}${aliases.components}/types/${subpath}${suffix}`;
+      }
+      return `${prefix}${aliases.importAlias}${aliases.components}/types${suffix}`;
+    }
+  );
+  result = result.replace(
+    /(from\s+['"])\.\.\/(([A-Z]\w+)(\/[^'"]+)?)(['"])/g,
+    (_match, prefix, _fullPath, dirName, subPath, suffix) => {
+      const kebab = dirName.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+      if (subPath) {
+        return `${prefix}${aliases.importAlias}${aliases.ui}/${kebab}${subPath}${suffix}`;
+      }
+      return `${prefix}${aliases.importAlias}${aliases.ui}/${kebab}${suffix}`;
+    }
+  );
+  result = result.replace(
+    /(from\s+['"])(?:\.\.\/)+hooks\/(\w+)(['"])/g,
+    `$1${aliases.importAlias}${aliases.hooks}/$2$3`
+  );
+  result = result.replace(
+    /(from\s+['"])(?:\.\.\/)+utils\/(\w+(?:\/\w+)?)(['"])/g,
+    `$1${aliases.importAlias}${aliases.utils}/$2$3`
+  );
+  result = result.replace(
+    /(from\s+['"])(?:\.\.\/)+utils(['"])/g,
+    `$1${aliases.importAlias}${aliases.utils}$2`
+  );
+  return result;
+}
+function normalizeExtensions(content, tsx) {
+  if (!tsx) {
+    return content.replace(/(from\s+['"][^'"]+)\.tsx(['"])/g, "$1.jsx$2").replace(/(from\s+['"][^'"]+)\.ts(['"])/g, "$1.js$2");
+  }
+  return content;
+}
+function getTargetDir(type, aliases) {
+  switch (type) {
+    case "registry:ui":
+      return aliases.ui;
+    case "registry:hook":
+      return aliases.hooks;
+    case "registry:util":
+      return aliases.utils;
+    case "registry:lib":
+      return aliases.lib;
+    case "registry:component":
+      return aliases.components;
+    case "registry:type":
+      return aliases.components;
+    case "registry:style":
+      return aliases.ui;
+    default:
+      return aliases.lib;
+  }
+}
+function detectPackageManager(projectDir) {
+  if (existsSync(join(projectDir, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(join(projectDir, "bun.lockb")) || existsSync(join(projectDir, "bun.lock"))) return "bun";
+  if (existsSync(join(projectDir, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+function getInstallArgs(pm, packages, dev) {
+  switch (pm) {
+    case "pnpm":
+      return ["pnpm", ["add", ...[], ...packages]];
+    case "yarn":
+      return ["yarn", ["add", ...[], ...packages]];
+    case "bun":
+      return ["bun", ["add", ...[], ...packages]];
+    default:
+      return ["npm", ["install", ...[], ...packages]];
+  }
+}
+function writeRegistryItems(tree, options) {
+  const { projectDir, aliases, components, overwrite, dryRun, log } = options;
+  const result = { written: [], skipped: [], installedDeps: [] };
+  const shouldOverwrite = overwrite ?? components.overwrite;
+  for (const item of tree.items) {
+    const targetBaseDir = getTargetDir(item.type, aliases);
+    for (const file of item.files) {
+      const fileName = basename(file.path);
+      let targetPath;
+      if (file.target) {
+        targetPath = join(projectDir, file.target);
+      } else if (item.type === "registry:ui" || item.type === "registry:component") {
+        targetPath = join(projectDir, targetBaseDir, item.name, fileName);
+      } else if (item.type === "registry:type") {
+        targetPath = join(projectDir, targetBaseDir, file.path);
+      } else {
+        targetPath = join(projectDir, targetBaseDir, fileName);
+      }
+      if (existsSync(targetPath) && !shouldOverwrite) {
+        if (log) log(`  Skipped (exists): ${targetPath}`);
+        result.skipped.push(targetPath);
+        continue;
+      }
+      let content = file.content;
+      content = transformImports(content, { aliases, tsx: components.tsx });
+      content = normalizeExtensions(content, components.tsx);
+      if (dryRun) {
+        if (log) log(`  Would write: ${targetPath}`);
+        result.written.push(targetPath);
+        continue;
+      }
+      const dir = dirname(targetPath);
+      if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+      writeFileSync(targetPath, content, "utf-8");
+      if (log) log(`  Written: ${targetPath}`);
+      result.written.push(targetPath);
+    }
+  }
+  const depsToInstall = tree.dependencies.filter((dep) => {
+    const pkgJsonPath = join(projectDir, "package.json");
+    if (existsSync(pkgJsonPath)) {
+      const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+      const allDeps = { ...pkgJson.dependencies, ...pkgJson.devDependencies };
+      return !Reflect.get(allDeps, dep);
+    }
+    return true;
+  });
+  if (depsToInstall.length > 0 && !dryRun) {
+    const pm = detectPackageManager(projectDir);
+    const [cmd, args] = getInstallArgs(pm, depsToInstall);
+    if (log) log(`  Installing: ${cmd} ${args.join(" ")}`);
+    execFileSync(cmd, args, { cwd: projectDir, stdio: "inherit" });
+    result.installedDeps = depsToInstall;
+  } else if (depsToInstall.length > 0 && dryRun) {
+    if (log) log(`  Would install: ${depsToInstall.join(", ")}`);
+    result.installedDeps = depsToInstall;
+  }
+  return result;
+}
 function getPackageRoot() {
   const currentFile = fileURLToPath(import.meta.url);
   return resolve(dirname(currentFile), "..");
@@ -9181,6 +10391,6 @@ function deepMerge2(target, source) {
   return output;
 }
 
-export { BOOTSTRAP_MAPPINGS, BOOTSTRAP_PATTERNS, CONFIG_FILE_NAMES, DEFAULT_CLEAN_DIRECTORIES, DEFAULT_COLLECTIONS_DIR, DEFAULT_FILE_NAMES, DEFAULT_ICONS_OUTPUT_DIR, DEFAULT_ICONS_SOURCE_DIR, DEFAULT_LOG_LEVEL, DEFAULT_OUTPUT_DIR, DEFAULT_PREFIX, DEFAULT_SOURCE_DIR, SHADCN_MAPPINGS, VALID_TOKEN_TYPES, addScssImportHeader, applyNameMapping, autoDetectThemes, bootstrapMapper, buildAllThemes, buildConfigSchema, buildIcons, buildTheme, buildTokens, buildTokensCLI, builtInFormats, builtInPreprocessors, builtInTransforms, checkDeprecatedOptions, checkMigrationNeeded, cleanSVGForReact, cleanTokenOutputs, cleanTokensCLI, clearConfigCache, createBundle, createBundleFromFiles, createBundles, createFixReferencesPreprocessor, createFrameworkMapper, createOutputConfig, createResolvedConfig, createStyleDictionaryConfig, cssTransformGroup, cssVariablesWithComments, customFormatSchema, customTransformSchema, deepMerge2 as deepMerge, defaultConfig, defaultFormats, defaultGlobalConfig, defaultIconFramework, defaultIconsConfig, defaultOutputFileNames, defaultReactIndexTemplate, defaultReactTemplate, defaultReactTypesTemplate, defaultSVGOConfig, defaultSelectorPattern, defaultSourcePatterns, defaultThemesConfig, defaultTokensConfig, defineConfig, defineConfigAsync, detectModes as detectFigmaModes, detectModes3 as detectModes, detectModes2 as detectTransformModes, diffTokens, dimensionRem, discoverThemeFiles, dsaiConfigSchema, dtcgFileSchema, dtcgTokenCollectionSchema, dtcgTokenSchema, ensureOutputDirs, envArrayKeys, envBooleanKeys, envMappings, envNumberKeys, extractMode, extractModes, extractViewBox, figmaExportSchema, figmaExportWithMetadataSchema, figmaVariablesResponseSchema, fileExists, filePathSchema, filterDiff, filterFiles, findPackageJson, fixReferences, flattenModeStructure, fontWeightUnitless, formatDuration, formatErrorMessage, formatValidationErrors, frameworkSchema, generateAndWriteChangelog, generateChangelog, generateChangelogCLI, generateMigrationScript, generateReactIcons, generateSVGSprite, generateThemeBuildConfig, getBreakingChanges, getConfigFromEnv, getCssFormat, getDefaultCssDir, getDefaultExtension, getDefaultFiles, getDefaultIgnorePatterns, getDefaultOutputDir, getDefaultSyncPaths, getDefaultTransformations, getEnvOverrides, getFrameworkMapper, getLogLevelFromEnv, getOutputFileName, getPackageRoot, getPreprocessedFilesForMode, getSDTokenType, getSDTokenValue, getThemeFiles, getThemeSelector, getTokenDescription, getTokenType, getTokenValue, globPatternSchema, globalConfigSchema, hasDTCGValue, hashTypeSchema, iconOptimizationSchema, iconSpriteSchema, iconsConfigSchema, isCI, isDTCGToken, isDirectory, isFile, isLegacyToken, isSDToken, isToken, isTokenReference, isValidIconName, isValidTokenType, jsTransformGroup, lineHeightUnitless, loadConfig, loadConfigSync, loadContent, logLevelSchema, logger, mapToBootstrapName, mapToShadcnName, mergeCollections, mergeCollectionsCLI, mergeConfigs, mergeContent, migrateConfig, migrateLegacyTokensConfig, nameKebab, normalizeIconName, optimizeSVG, optimizeSVGFiles, outputFormatSchema, parseSVG, parseSVGFiles, parseTokenReference, postprocessCLI, postprocessCss, postprocessCssFiles, preprocessFile, preprocessTokenFiles, processScssImportHeader, readSVGFile, registerAll, registerFormats, registerPreprocessors, registerTransformGroups, registerTransforms, replacePlaceholders, resolveAllOutputPaths, resolveConfig, resolveOutputPath, resolvePath, runBuildCLI, scanDirectories, scanSVGFiles, scssTransformGroup, searchConfigFile, setupStyleDictionary, shadcnMapper, shouldDisableColors, skipOptimization, sortFiles, styleDictionaryInputSchema, styleDictionaryTokenSchema, summarizeDiff, syncTokens, syncTokensCLI, themeDefinitionSchema, themeSelectorPatternSchema, themesConfigSchema, toComponentName, toDTCGToken, toIconName, tokenBuildConfigSchema, tokenCacheConfigSchema, tokenWatchConfigSchema, tokensConfigSchema, tokensHooksSchema, transformGroups, transformToken, transformTokenTree, transformTokens, transformTokensCLI, transformType, transformValue, typescriptDeclarations, validateConfig, validateConfigOrThrow, validateConfigSection, validateDTCGFile, validateDTCGTokens, validateFigmaCLI, validateFigmaExport, validateFigmaExportWithMetadata, validateFigmaExports, validateFigmaFile, validateFigmaVariablesResponse, validateOutputPaths, validateStyleDictionaryInput, validateStyleDictionaryTokens, validateThemeDefinitions, validateTokens, validateTokensCLI, version, versionSchema, writeChangelog };
+export { BOOTSTRAP_MAPPINGS, BOOTSTRAP_PATTERNS, CONFIG_FILE_NAMES, DEFAULT_CLEAN_DIRECTORIES, DEFAULT_COLLECTIONS_DIR, DEFAULT_FILE_NAMES, DEFAULT_ICONS_OUTPUT_DIR, DEFAULT_ICONS_SOURCE_DIR, DEFAULT_LOG_LEVEL, DEFAULT_OUTPUT_DIR, DEFAULT_PREFIX, DEFAULT_SOURCE_DIR, SHADCN_MAPPINGS, VALID_TOKEN_TYPES, addScssImportHeader, aliasesConfigSchema, applyNameMapping, autoDetectThemes, bootstrapMapper, buildAllThemes, buildConfigSchema, buildIcons, buildRegistry, buildTheme, buildTokens, buildTokensCLI, builtInFormats, builtInPreprocessors, builtInTransforms, checkDeprecatedOptions, checkMigrationNeeded, cleanSVGForReact, cleanTokenOutputs, cleanTokensCLI, clearConfigCache, componentsConfigSchema, createBundle, createBundleFromFiles, createBundles, createFixReferencesPreprocessor, createFrameworkMapper, createOutputConfig, createResolvedConfig, createStyleDictionaryConfig, cssTransformGroup, cssVariablesWithComments, customFormatSchema, customTransformSchema, deepMerge2 as deepMerge, defaultAliasesConfig, defaultComponentsConfig, defaultConfig, defaultFormats, defaultGlobalConfig, defaultIconFramework, defaultIconsConfig, defaultOutputFileNames, defaultReactIndexTemplate, defaultReactTemplate, defaultReactTypesTemplate, defaultSVGOConfig, defaultSelectorPattern, defaultSourcePatterns, defaultThemesConfig, defaultTokensConfig, defineConfig, defineConfigAsync, detectModes as detectFigmaModes, detectModes3 as detectModes, detectModes2 as detectTransformModes, diffTokens, dimensionRem, discoverThemeFiles, dsaiConfigSchema, dtcgFileSchema, dtcgTokenCollectionSchema, dtcgTokenSchema, ensureOutputDirs, envArrayKeys, envBooleanKeys, envMappings, envNumberKeys, extractMode, extractModes, extractViewBox, figmaExportSchema, figmaExportWithMetadataSchema, figmaVariablesResponseSchema, fileExists, filePathSchema, filterDiff, filterFiles, findPackageJson, fixReferences, flattenModeStructure, fontWeightUnitless, formatDuration, formatErrorMessage, formatValidationErrors, frameworkSchema, generateAndWriteChangelog, generateChangelog, generateChangelogCLI, generateMigrationScript, generateReactIcons, generateSVGSprite, generateThemeBuildConfig, getBreakingChanges, getConfigFromEnv, getCssFormat, getDefaultCssDir, getDefaultExtension, getDefaultFiles, getDefaultIgnorePatterns, getDefaultOutputDir, getDefaultSyncPaths, getDefaultTransformations, getEnvOverrides, getFrameworkMapper, getLogLevelFromEnv, getOutputFileName, getPackageRoot, getPreprocessedFilesForMode, getSDTokenType, getSDTokenValue, getThemeFiles, getThemeSelector, getTokenDescription, getTokenType, getTokenValue, globPatternSchema, globalConfigSchema, hasDTCGValue, hashTypeSchema, iconOptimizationSchema, iconSpriteSchema, iconsConfigSchema, isCI, isDTCGToken, isDirectory, isFile, isLegacyToken, isSDToken, isToken, isTokenReference, isValidIconName, isValidTokenType, jsTransformGroup, lineHeightUnitless, loadConfig, loadConfigSync, loadContent, logLevelSchema, logger, mapToBootstrapName, mapToShadcnName, mergeCollections, mergeCollectionsCLI, mergeConfigs, mergeContent, migrateConfig, migrateLegacyTokensConfig, nameKebab, normalizeExtensions, normalizeIconName, optimizeSVG, optimizeSVGFiles, outputFormatSchema, parseSVG, parseSVGFiles, parseTokenReference, postprocessCLI, postprocessCss, postprocessCssFiles, preprocessFile, preprocessTokenFiles, processScssImportHeader, readSVGFile, registerAll, registerFormats, registerPreprocessors, registerTransformGroups, registerTransforms, registryFileSchema, registryIndexEntrySchema, registryIndexSchema, registryItemSchema, registryItemTypeSchema, replacePlaceholders, resolveAllOutputPaths, resolveConfig, resolveOutputPath, resolvePath, resolveTree, runBuildCLI, scanDirectories, scanSVGFiles, scssTransformGroup, searchConfigFile, setupStyleDictionary, shadcnMapper, shouldDisableColors, skipOptimization, sortFiles, styleDictionaryInputSchema, styleDictionaryTokenSchema, summarizeDiff, syncTokens, syncTokensCLI, themeDefinitionSchema, themeSelectorPatternSchema, themesConfigSchema, toComponentName, toDTCGToken, toIconName, tokenBuildConfigSchema, tokenCacheConfigSchema, tokenWatchConfigSchema, tokensConfigSchema, tokensHooksSchema, transformGroups, transformImports, transformToken, transformTokenTree, transformTokens, transformTokensCLI, transformType, transformValue, typescriptDeclarations, validateConfig, validateConfigOrThrow, validateConfigSection, validateDTCGFile, validateDTCGTokens, validateFigmaCLI, validateFigmaExport, validateFigmaExportWithMetadata, validateFigmaExports, validateFigmaFile, validateFigmaVariablesResponse, validateOutputPaths, validateStyleDictionaryInput, validateStyleDictionaryTokens, validateThemeDefinitions, validateTokens, validateTokensCLI, version, versionSchema, writeChangelog, writeRegistryItems };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map