ui8kit 1.3.8 → 1.4.1

package/dist/index.js

@@ -97,10 +97,18 @@ var SCHEMA_CONFIG = {
     registryVersion: "Registry version",
     registryUrl: "Explicit registry URL override",
     strictCdn: "Disable fallback to built-in CDN URLs",
+    importStyle: "How component imports are rewritten: alias or package",
     lastUpdated: "Last update timestamp",
     categories: "Available component categories",
     components: "Component metadata for quick lookup",
     items: "Full component definitions"
+  },
+  packageAliases: {
+    core: "@ui8kit/core"
+  },
+  importStyle: {
+    alias: "alias",
+    package: "package"
   }
 };
 var TYPE_TO_FOLDER = {
@@ -191,7 +199,8 @@ var configSchema = z.object({
   libDir: z.string().default(SCHEMA_CONFIG.defaultDirectories.lib),
   registryUrl: z.string().url().optional(),
   registryVersion: z.string().optional(),
-  strictCdn: z.boolean().default(false).optional()
+  strictCdn: z.boolean().default(false).optional(),
+  importStyle: z.enum(["alias", "package"]).default("alias").optional()
 });
 
 // src/utils/logger.ts
@@ -580,9 +589,6 @@ async function saveConfig(config) {
   await fs2.ensureDir(path2.dirname(configPath));
   await fs2.writeJson(configPath, config, { spaces: 2 });
 }
-async function ensureDir(dirPath) {
-  await fs2.ensureDir(dirPath);
-}
 
 // src/utils/registry-validator.ts
 import fs6 from "fs-extra";
@@ -937,11 +943,15 @@ async function fetchJsonFromRegistry(url) {
     clearTimeout(timeoutId);
   }
 }
+function resolveImportStyle(rawImportStyle) {
+  return rawImportStyle === "package" ? "package" : "alias";
+}
 function buildInitConfig(options) {
   const registryName = options.registry || SCHEMA_CONFIG.defaultRegistryType;
   const aliases = SCHEMA_CONFIG.defaultAliases;
   const globalCss = options.globalCss || "src/index.css";
   const aliasComponents = options.aliasComponents?.trim() || "@/components";
+  const importStyle = resolveImportStyle(options.importStyle);
   if (options.yes) {
     return {
       $schema: `${SCHEMA_CONFIG.baseUrl}.json`,
@@ -954,7 +964,8 @@ function buildInitConfig(options) {
       libDir: SCHEMA_CONFIG.defaultDirectories.lib,
       registryUrl: options.registryUrl,
       registryVersion: options.registryVersion,
-      strictCdn: options.strictCdn
+      strictCdn: options.strictCdn,
+      importStyle
     };
   }
   return {
@@ -968,7 +979,8 @@ function buildInitConfig(options) {
     libDir: SCHEMA_CONFIG.defaultDirectories.lib,
     registryUrl: options.registryUrl,
     registryVersion: options.registryVersion,
-    strictCdn: options.strictCdn
+    strictCdn: options.strictCdn,
+    importStyle
   };
 }
 async function initCommand(options) {
@@ -1005,7 +1017,7 @@ async function initCommand(options) {
   }
   let config;
   if (options.yes) {
-    config = buildInitConfig({ yes: true, registry: registryName, ...cdnOptions });
+    config = buildInitConfig({ yes: true, registry: registryName, ...cdnOptions, importStyle: options.importStyle });
   } else {
     const responses = await prompts([
       {
@@ -1019,33 +1031,35 @@ async function initCommand(options) {
         name: "aliasComponents",
         message: CLI_MESSAGES.prompts.aliasComponents,
         initial: "@/components"
+      },
+      {
+        type: "select",
+        name: "importStyle",
+        message: "Import style for installed components",
+        choices: [
+          { title: "Alias imports (recommended)", value: "alias" },
+          { title: "Package imports (@ui8kit/core)", value: "package" }
+        ],
+        initial: 0
       }
     ]);
     const aliasComponents = responses.aliasComponents?.trim() || "@/components";
     const globalCss = responses.globalCss || "src/index.css";
+    const importStyle = resolveImportStyle(responses.importStyle);
     config = buildInitConfig({
       yes: false,
       registry: registryName,
       globalCss,
       aliasComponents,
+      importStyle,
       ...cdnOptions
     });
   }
   const spinner = ora3(CLI_MESSAGES.info.initializing(registryName)).start();
   try {
     await saveConfig(config);
-    await ensureDir(config.libDir);
-    await ensureDir(config.componentsDir);
-    await ensureDir(path5.join(config.componentsDir, "ui"));
-    await ensureDir(SCHEMA_CONFIG.defaultDirectories.blocks);
-    await ensureDir(SCHEMA_CONFIG.defaultDirectories.layouts);
-    await ensureDir(SCHEMA_CONFIG.defaultDirectories.variants);
     spinner.text = "Installing core utilities and variants...";
     await installCoreFiles(registryName, config, spinner, cdnOptions);
-    spinner.text = "Installing core dependencies...";
-    await installDependencies(["clsx", "tailwind-merge"], {
-      useSpinner: false
-    });
     spinner.succeed(CLI_MESSAGES.success.initialized(registryName));
     logger.success(`
 \u2705 ${CLI_MESSAGES.success.setupComplete(registryName)}`);
@@ -1063,6 +1077,103 @@ async function initCommand(options) {
     handleError(error);
   }
 }
+function sortCoreDependencies(descriptors) {
+  const itemByTypeAndName = /* @__PURE__ */ new Map();
+  for (const item of descriptors) {
+    itemByTypeAndName.set(`${item.type}:${item.name}`, item);
+  }
+  const findDependencyByName = (name) => {
+    const dependencyByLib = itemByTypeAndName.get(`registry:lib:${name}`);
+    if (dependencyByLib) {
+      return dependencyByLib;
+    }
+    return descriptors.find((item) => item.name === name);
+  };
+  const indegrees = /* @__PURE__ */ new Map();
+  const graph = /* @__PURE__ */ new Map();
+  const queue = [];
+  for (const item of descriptors) {
+    const key = `${item.type}:${item.name}`;
+    indegrees.set(key, 0);
+    graph.set(key, /* @__PURE__ */ new Set());
+  }
+  for (const item of descriptors) {
+    const itemKey = `${item.type}:${item.name}`;
+    for (const registryDep of item.component.registryDependencies ?? []) {
+      const targetName = registryDep.toLowerCase();
+      const dependency = findDependencyByName(targetName);
+      if (!dependency) {
+        continue;
+      }
+      const dependencyKey = `${dependency.type}:${dependency.name}`;
+      if (dependencyKey === itemKey) {
+        continue;
+      }
+      graph.get(dependencyKey)?.add(itemKey);
+      indegrees.set(itemKey, (indegrees.get(itemKey) ?? 0) + 1);
+    }
+  }
+  for (const [key, inDegree] of indegrees.entries()) {
+    if (inDegree === 0) {
+      queue.push(key);
+    }
+  }
+  const result = [];
+  while (queue.length > 0) {
+    const key = queue.shift();
+    if (!key)
+      break;
+    const item = itemByTypeAndName.get(key);
+    if (!item)
+      continue;
+    result.push(item);
+    for (const dependent of graph.get(key) ?? []) {
+      const nextDegree = Math.max((indegrees.get(dependent) ?? 1) - 1, 0);
+      indegrees.set(dependent, nextDegree);
+      if (nextDegree === 0) {
+        queue.push(dependent);
+      }
+    }
+  }
+  if (result.length === descriptors.length) {
+    return result;
+  }
+  for (const item of descriptors) {
+    if (!result.includes(item)) {
+      result.push(item);
+    }
+  }
+  return result;
+}
+async function fetchCoreComponent(name, type, cdnUrls) {
+  const folder = type === "registry:lib" ? "lib" : type === "registry:variants" ? "components/variants" : "components/ui";
+  for (const baseUrl of cdnUrls) {
+    const url = `${baseUrl}/${folder}/${name}.json`;
+    const component = await fetchJsonFromRegistry(url);
+    if (component) {
+      return component;
+    }
+  }
+  return null;
+}
+function resolveComponentTargetDir(type, config) {
+  if (type === "registry:lib") {
+    return config.libDir;
+  }
+  if (type === "registry:variants") {
+    return SCHEMA_CONFIG.defaultDirectories.variants;
+  }
+  return path5.join(config.componentsDir, "ui");
+}
+async function writeComponentFromDescriptor(component, type, config) {
+  for (const file of component.files) {
+    const fileName = path5.basename(file.path);
+    const targetDir = resolveComponentTargetDir(type, config);
+    const targetPath = path5.join(process.cwd(), targetDir, fileName);
+    await fs5.ensureDir(path5.dirname(targetPath));
+    await fs5.writeFile(targetPath, file.content || "", "utf-8");
+  }
+}
 async function installCoreFiles(registryType, config, spinner, cdnResolution = {}) {
   const cdnUrls = getCdnUrls(registryType, {
     registryUrl: cdnResolution.registryUrl,
@@ -1089,13 +1200,49 @@ async function installCoreFiles(registryType, config, spinner, cdnResolution = {
   }
   const variantItems = registryIndex.components.filter((c) => c.type === "registry:variants");
   const libItems = registryIndex.components.filter((c) => c.type === "registry:lib");
-  for (const item of libItems) {
-    spinner.text = `Installing ${item.name}...`;
-    await installComponentFromRegistry(item.name, "registry:lib", cdnUrls, config);
+  const coreItems = [
+    ...libItems.map((item) => ({ name: item.name, type: "registry:lib" })),
+    ...variantItems.map((item) => ({ name: item.name, type: "registry:variants" }))
+  ];
+  if (coreItems.length === 0) {
+    spinner.text = "\u26A0\uFE0F  Registry index has no core components; creating local utils...";
+    await createUtilsFile(config.libDir, config.typescript);
+    return;
   }
-  for (const item of variantItems) {
-    spinner.text = `Installing variant: ${item.name}...`;
-    await installComponentFromRegistry(item.name, "registry:variants", cdnUrls, config);
+  const loadedComponents = [];
+  const coreDependencies = /* @__PURE__ */ new Set();
+  for (const item of coreItems) {
+    spinner.text = `Fetching ${item.name}...`;
+    const component = await fetchCoreComponent(item.name, item.type, cdnUrls);
+    if (!component) {
+      continue;
+    }
+    loadedComponents.push({
+      ...item,
+      component: {
+        name: component.name || item.name,
+        type: item.type,
+        files: component.files,
+        dependencies: component.dependencies ?? [],
+        devDependencies: component.devDependencies ?? [],
+        registryDependencies: component.registryDependencies ?? [],
+        description: component.description
+      }
+    });
+    for (const dep of component.dependencies ?? []) {
+      coreDependencies.add(dep);
+    }
+  }
+  const orderedCoreComponents = sortCoreDependencies(loadedComponents);
+  for (const descriptor of orderedCoreComponents) {
+    spinner.text = `Installing ${descriptor.name}...`;
+    await writeComponentFromDescriptor(descriptor.component, descriptor.type, config);
+  }
+  if (coreDependencies.size > 0) {
+    spinner.text = "Installing core dependencies...";
+    await installDependencies(Array.from(coreDependencies), {
+      useSpinner: false
+    });
   }
   spinner.text = "Syncing variants index...";
   const variantsIndexStatus = await installVariantsIndex(cdnUrls);
@@ -1108,32 +1255,7 @@ async function installCoreFiles(registryType, config, spinner, cdnResolution = {
   } else {
     spinner.text = "variants/index.ts not found in registry (skipped)";
   }
-  spinner.text = `\u2705 Installed ${libItems.length} utilities and ${variantItems.length} variants`;
-}
-async function installComponentFromRegistry(name, type, cdnUrls, config) {
-  const folder = type === "registry:lib" ? "lib" : type === "registry:variants" ? "components/variants" : "components/ui";
-  for (const baseUrl of cdnUrls) {
-    const url = `${baseUrl}/${folder}/${name}.json`;
-    const component = await fetchJsonFromRegistry(url);
-    if (!component) {
-      continue;
-    }
-    for (const file of component.files) {
-      const fileName = path5.basename(file.path);
-      let targetDir;
-      if (type === "registry:lib") {
-        targetDir = config.libDir;
-      } else if (type === "registry:variants") {
-        targetDir = SCHEMA_CONFIG.defaultDirectories.variants;
-      } else {
-        targetDir = path5.join(config.componentsDir, "ui");
-      }
-      const targetPath = path5.join(process.cwd(), targetDir, fileName);
-      await fs5.ensureDir(path5.dirname(targetPath));
-      await fs5.writeFile(targetPath, file.content || "", "utf-8");
-    }
-    return;
-  }
+  spinner.text = `\u2705 Installed ${loadedComponents.length} core components`;
 }
 async function installVariantsIndex(cdnUrls) {
   for (const baseUrl of cdnUrls) {
@@ -1345,6 +1467,7 @@ function formatDiffPreview(diff, maxLines = 80) {
 import path7 from "path";
 import ts from "typescript";
 var IMPORT_NODE_KIND = ts.SyntaxKind.ImportDeclaration;
+var PACKAGE_STYLE_IMPORT_GROUPS = ["components", "layouts", "blocks", "variants", "ui"];
 function normalizeAliasKey(alias) {
   return alias.replace(/\\/g, "/").replace(/\/+$/, "");
 }
@@ -1408,21 +1531,36 @@ function pickAliasForImport(importPath, configuredAliases) {
   }
   return void 0;
 }
-function rewriteModuleSpecifier(specifierText, configuredAliases) {
+function normalizeAliasImportPath(specifierText, aliasesMap) {
+  const rewritten = pickAliasForImport(specifierText, aliasesMap);
+  if (!rewritten || rewritten === normalizeAliasKey(specifierText)) {
+    return void 0;
+  }
+  return rewritten;
+}
+function isComponentAliasImport(aliasPath) {
+  const match = aliasPath.startsWith("@/") ? aliasPath.slice(2) : "";
+  if (!match) {
+    return false;
+  }
+  const firstSegment = match.split("/")[0];
+  return PACKAGE_STYLE_IMPORT_GROUPS.includes(firstSegment);
+}
+function rewriteModuleSpecifier(specifierText, configuredAliases, importStyle = "alias") {
   if (!specifierText.startsWith("@/")) {
     return specifierText;
   }
   const aliasesMap = normalizeConfiguredAliases(configuredAliases);
-  const rewrittenRemainder = pickAliasForImport(specifierText, aliasesMap);
-  if (!rewrittenRemainder || rewrittenRemainder === normalizeAliasKey(specifierText)) {
+  const rewrittenAlias = normalizeAliasImportPath(specifierText, aliasesMap);
+  if (!rewrittenAlias) {
     return specifierText;
   }
-  if (rewrittenRemainder) {
-    return rewrittenRemainder;
+  if (importStyle === "package" && isComponentAliasImport(rewrittenAlias)) {
+    return SCHEMA_CONFIG.packageAliases.core;
   }
-  return specifierText;
+  return rewrittenAlias;
 }
-function transformImports(content, aliases) {
+function transformImports(content, aliases, importStyle = "alias") {
   const sourceFile = ts.createSourceFile("component.tsx", content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
   const importSpans = [];
   const configuredAliases = normalizeConfiguredAliases(aliases);
@@ -1431,7 +1569,7 @@ function transformImports(content, aliases) {
       const moduleSpecifier = node.moduleSpecifier;
       if (ts.isStringLiteral(moduleSpecifier)) {
         const value = moduleSpecifier.text;
-        const rewritten = rewriteModuleSpecifier(value, Object.fromEntries(configuredAliases));
+        const rewritten = rewriteModuleSpecifier(value, Object.fromEntries(configuredAliases), importStyle);
         if (rewritten !== value) {
           importSpans.push({
             start: moduleSpecifier.getStart(sourceFile),
@@ -1457,8 +1595,8 @@ function transformImports(content, aliases) {
 function transformCleanup(content) {
   return content.replace(/\r\n/g, "\n").replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
 }
-function applyTransforms(content, aliases) {
-  const withImports = transformImports(content, aliases);
+function applyTransforms(content, aliases, importStyle = "alias") {
+  const withImports = transformImports(content, aliases, importStyle);
   return transformCleanup(withImports);
 }
 function shouldTransformFile(fileName) {
@@ -1531,6 +1669,9 @@ async function addAllComponents(options, registryType, requestOptions) {
   }
   const spinner = ora4(CLI_MESSAGES.info.fetchingComponentList(registryType)).start();
   try {
+    if (!options.dryRun) {
+      await ensureBaseProjectDirectories(config);
+    }
     const allComponents = await getAllComponentsFn(registryType);
     if (allComponents.length === 0) {
       spinner.fail(`No components found in ${registryType} registry`);
@@ -1572,6 +1713,14 @@ async function addAllComponents(options, registryType, requestOptions) {
     process.exit(1);
   }
 }
+async function ensureBaseProjectDirectories(config) {
+  await fs7.ensureDir(config.libDir);
+  await fs7.ensureDir(config.componentsDir);
+  await fs7.ensureDir(path8.join(config.componentsDir, "ui"));
+  await fs7.ensureDir(SCHEMA_CONFIG.defaultDirectories.blocks);
+  await fs7.ensureDir(SCHEMA_CONFIG.defaultDirectories.layouts);
+  await fs7.ensureDir(SCHEMA_CONFIG.defaultDirectories.variants);
+}
 async function processComponents(componentNames, registryType, config, getComponentFn, options, preloadedComponents, totalCount) {
   const results = [];
   const componentMap = new Map(preloadedComponents?.map((c) => [c.name.toLowerCase(), c]));
@@ -1610,7 +1759,7 @@ async function processComponents(componentNames, registryType, config, getCompon
           logger.info(`   ${status}: ${targetPath}`);
           if (exists) {
             const currentContent = await fs7.readFile(targetPath, "utf-8");
-            const transformedIncoming = shouldTransformFile(fileName) ? applyTransforms(file.content, config.aliases) : file.content;
+            const transformedIncoming = shouldTransformFile(fileName) ? applyTransforms(file.content, config.aliases, config.importStyle || "alias") : file.content;
             const changed = hasDiff(currentContent, transformedIncoming);
             if (changed) {
               const patch = buildUnifiedDiff(targetPath, `${component.name}/${fileName}`, currentContent, transformedIncoming);
@@ -1774,7 +1923,7 @@ async function installComponentFiles(component, config, force = false) {
       continue;
     }
     await fs7.ensureDir(path8.dirname(targetPath));
-    const preparedContent = shouldTransformFile(fileName) ? applyTransforms(file.content, config.aliases) : file.content;
+    const preparedContent = shouldTransformFile(fileName) ? applyTransforms(file.content, config.aliases, config.importStyle || "alias") : file.content;
     await fs7.writeFile(targetPath, preparedContent, "utf-8");
   }
 }
@@ -2008,6 +2157,12 @@ function generateConfigSchema() {
         "type": "boolean",
         "default": false,
         "description": SCHEMA_CONFIG.fieldDescriptions.strictCdn
+      },
+      "importStyle": {
+        "type": "string",
+        "enum": Object.values(SCHEMA_CONFIG.importStyle),
+        "default": SCHEMA_CONFIG.importStyle.alias,
+        "description": SCHEMA_CONFIG.fieldDescriptions.importStyle
       }
     },
     "required": ["framework"],
@@ -2340,7 +2495,9 @@ async function createIndexFile(registry, outputDir) {
       name: item.name,
       type: item.type,
       title: item.title,
-      description: item.description
+      description: item.description,
+      dependencies: item.dependencies ?? [],
+      registryDependencies: item.registryDependencies ?? []
     })),
     categories: SCHEMA_CONFIG.componentCategories,
     version: "1.0.0",
@@ -2464,6 +2621,109 @@ var DEV_PATTERNS = [
   "tailwindcss",
   "autoprefixer"
 ];
+var PACKAGE_CORE_PREFIX = "@ui8kit/core";
+var PACKAGE_STYLE_BARS = [
+  "components",
+  "layouts",
+  "blocks",
+  "variants",
+  "ui"
+];
+var PACKAGE_STYLE_ALIASES = ["@/components", "@/components/ui", "@/ui", "@/layouts", "@/blocks", "@/variants"];
+var REGISTRY_ALIAS_ROOTS = Object.keys(SCHEMA_CONFIG.defaultAliases);
+function toPosix2(value) {
+  return value.replace(/\\/g, "/");
+}
+function toLowerOrEmpty(value) {
+  return value.trim().toLowerCase();
+}
+function stripImportExtension(moduleName) {
+  return moduleName.replace(/\.[tj]sx?$/i, "");
+}
+function getAliasMatch(moduleName) {
+  const normalized = toPosix2(moduleName);
+  if (!normalized.startsWith("@/")) {
+    return null;
+  }
+  const directMatch = REGISTRY_ALIAS_ROOTS.filter((alias) => normalized === alias || normalized.startsWith(`${alias}/`)).sort((a, b) => b.length - a.length)[0];
+  if (!directMatch) {
+    return null;
+  }
+  const remainder = normalized.slice(directMatch.length).replace(/^\/+/, "");
+  return {
+    alias: directMatch,
+    remainder
+  };
+}
+function shouldRewriteAsRegistryDependency(aliasImport) {
+  const match = getAliasMatch(aliasImport);
+  if (!match || !match.remainder) {
+    return false;
+  }
+  if (PACKAGE_STYLE_ALIASES.includes(match.alias)) {
+    return true;
+  }
+  const firstSegment = match.remainder.split("/")[0];
+  return PACKAGE_STYLE_BARS.includes(firstSegment);
+}
+function isUi8kitCoreImport(moduleName) {
+  return moduleName === PACKAGE_CORE_PREFIX || moduleName.startsWith(`${PACKAGE_CORE_PREFIX}/`);
+}
+function extractCoreImportNames(moduleName, node) {
+  if (!isUi8kitCoreImport(moduleName)) {
+    return [];
+  }
+  const names = [];
+  const importClause = node.importClause;
+  if (importClause?.name) {
+    names.push(importClause.name.text);
+  }
+  const namedBindings = importClause?.namedBindings;
+  if (namedBindings && ts4.isNamedImports(namedBindings)) {
+    namedBindings.elements.forEach((element) => {
+      names.push(element.name.text);
+    });
+  }
+  if (moduleName.startsWith(`${PACKAGE_CORE_PREFIX}/`)) {
+    const explicitComponent = toLowerOrEmpty(stripImportExtension(moduleName.slice(PACKAGE_CORE_PREFIX.length + 1)));
+    if (explicitComponent && !names.includes(explicitComponent)) {
+      names.push(explicitComponent);
+    }
+  }
+  return names;
+}
+function mapAliasImportToComponentName(moduleName) {
+  const aliasMatch = getAliasMatch(moduleName);
+  if (!aliasMatch || !aliasMatch.remainder) {
+    return null;
+  }
+  if (!shouldRewriteAsRegistryDependency(moduleName)) {
+    return null;
+  }
+  const componentName = stripImportExtension(aliasMatch.remainder).split("/").at(-1);
+  return componentName ? toLowerOrEmpty(componentName) : null;
+}
+function extractRegistryDependenciesFromImport(node) {
+  const moduleSpecifier = node.moduleSpecifier;
+  if (!ts4.isStringLiteral(moduleSpecifier)) {
+    return [];
+  }
+  const moduleName = moduleSpecifier.text;
+  const importedNames = [];
+  if (isUi8kitCoreImport(moduleName)) {
+    for (const name of extractCoreImportNames(moduleName, node)) {
+      importedNames.push(toLowerOrEmpty(name));
+    }
+    return importedNames;
+  }
+  if (moduleName.startsWith("@/")) {
+    const aliasName = mapAliasImportToComponentName(moduleName);
+    if (aliasName) {
+      importedNames.push(aliasName);
+    }
+  }
+  return importedNames;
+}
 async function scanCommand(options = {}) {
   const registryName = options.registry || SCHEMA_CONFIG.defaultRegistryType;
   const registryPath = `./${registryName}`;
@@ -2502,6 +2762,7 @@ async function scanCommand(options = {}) {
     ];
     const seen = /* @__PURE__ */ new Set();
     const allComponents = [];
+    const localDependencyRefs = /* @__PURE__ */ new Map();
     for (const comp of allComponentsRaw) {
       const key = `${comp.type}:${comp.name}`;
       if (seen.has(key))
@@ -2514,10 +2775,38 @@ async function scanCommand(options = {}) {
       const analysis = await analyzeComponentDependencies(component.files, scanOptions.cwd);
       component.dependencies = analysis.dependencies;
       component.devDependencies = analysis.devDependencies;
+      localDependencyRefs.set(
+        `${component.type}:${component.name}`,
+        new Set(analysis.registryDependencies.map(toLowerOrEmpty))
+      );
       if (analysis.description && !component.description) {
         component.description = analysis.description;
       }
     }
+    const availableComponents = new Set(allComponents.map((item) => item.name.toLowerCase()));
+    allComponents.forEach((item) => {
+      const rawDependencies = localDependencyRefs.get(`${item.type}:${item.name}`) ?? /* @__PURE__ */ new Set();
+      const resolvedDependencies = /* @__PURE__ */ new Set();
+      const unresolvedDependencies = [];
+      for (const candidate of rawDependencies) {
+        const normalized = toLowerOrEmpty(candidate);
+        if (!normalized) {
+          continue;
+        }
+        if (normalized === item.name.toLowerCase()) {
+          continue;
+        }
+        if (!availableComponents.has(normalized)) {
+          unresolvedDependencies.push(normalized);
+          continue;
+        }
+        resolvedDependencies.add(normalized);
+      }
+      if (unresolvedDependencies.length > 0) {
+        console.warn(`\u26A0\uFE0F  Missing local component references in ${item.name} (${item.type}): ${unresolvedDependencies.join(", ")}`);
+      }
+      item.registryDependencies = Array.from(resolvedDependencies).sort();
+    });
     const registry = {
       $schema: "https://ui.buildy.tw/schema/registry.json",
       items: allComponents,
@@ -2577,6 +2866,7 @@ async function scanDirectory(dirPath, type, ignorePatterns = []) {
         description,
         dependencies: [],
         devDependencies: [],
+        registryDependencies: [],
         files: [{
           path: relativePath,
           target: getTargetFromType(type)
@@ -2613,6 +2903,7 @@ async function scanDirectoryFlat(dirPath, type, ignoreFiles = []) {
         description,
         dependencies: [],
         devDependencies: [],
+        registryDependencies: [],
         files: [{
           path: relativePath,
           target: getTargetFromType(type)
@@ -2642,6 +2933,7 @@ async function scanSingleFile(filePath, type) {
       description,
       dependencies: [],
       devDependencies: [],
+      registryDependencies: [],
       files: [{
         path: relativePath,
         target: getTargetFromType(type)
@@ -2679,6 +2971,7 @@ function hasValidExports(content) {
 async function analyzeComponentDependencies(files, cwd) {
   const allDependencies = /* @__PURE__ */ new Set();
   const allDevDependencies = /* @__PURE__ */ new Set();
+  const allRegistryDependencies = /* @__PURE__ */ new Set();
   let description;
   for (const file of files) {
     try {
@@ -2693,6 +2986,7 @@ async function analyzeComponentDependencies(files, cwd) {
       const analysis = analyzeAST(sourceFile);
       analysis.dependencies.forEach((dep) => allDependencies.add(dep));
       analysis.devDependencies.forEach((dep) => allDevDependencies.add(dep));
+      analysis.registryDependencies.forEach((dep) => allRegistryDependencies.add(dep));
       if (analysis.description && !description) {
         description = analysis.description;
       }
@@ -2703,12 +2997,14 @@ async function analyzeComponentDependencies(files, cwd) {
   return {
     dependencies: Array.from(allDependencies),
     devDependencies: Array.from(allDevDependencies),
-    description
+    description,
+    registryDependencies: Array.from(allRegistryDependencies)
   };
 }
 function analyzeAST(sourceFile) {
   const dependencies = /* @__PURE__ */ new Set();
   const devDependencies = /* @__PURE__ */ new Set();
+  const registryDependencies = /* @__PURE__ */ new Set();
   let description;
   let hasExports = false;
   function visit(node) {
@@ -2716,6 +3012,11 @@ function analyzeAST(sourceFile) {
       const moduleSpecifier = node.moduleSpecifier;
       if (ts4.isStringLiteral(moduleSpecifier)) {
         const moduleName = moduleSpecifier.text;
+        for (const name of extractRegistryDependenciesFromImport(node)) {
+          if (name) {
+            registryDependencies.add(name);
+          }
+        }
         if (isExternalDependency(moduleName)) {
           if (isDevDependency(moduleName)) {
             devDependencies.add(moduleName);
@@ -2743,6 +3044,7 @@ function analyzeAST(sourceFile) {
     dependencies: Array.from(dependencies),
     devDependencies: Array.from(devDependencies),
     description,
+    registryDependencies: Array.from(registryDependencies),
     hasExports
   };
 }
@@ -2947,7 +3249,7 @@ async function compareComponentFiles(installed, remote, config) {
   if (!remoteCandidate) {
     return [{ path: installed.filePath, changed: false }];
   }
-  const remoteContent = applyTransforms(remoteCandidate.content, config.aliases);
+  const remoteContent = applyTransforms(remoteCandidate.content, config.aliases, config.importStyle || "alias");
   const changed = hasDiff(localContent, remoteContent);
   return changed ? [{
     path: installed.filePath,
@@ -3400,7 +3702,7 @@ program.command("cache").description("Manage local cache").command("clear").desc
 program.command("registry").description("Manage generated registry artifacts").command("clean").description("Remove generated registry build artifacts").option("--dry-run", "Show what would be removed without deleting").option("--all", "Also remove src/registry.json if it exists").option("-f, --force", "Skip confirmation prompt").action(registryCleanCommand);
 program.command("reset").description("Reset local UI8Kit state").option("--dry-run", "Show what would be removed without deleting").option("--with-cache", "Also clear CLI cache data").option("-y, --yes", "Skip prompts and perform reset").option("-f, --force", "Skip confirmation prompt").action(resetCommand);
 program.command("info").description("Show environment and config diagnostics").option("--json", "Output diagnostics as JSON").option("--cdn", "Show resolved CDN order and active overrides").action(infoCommand);
-program.command("init").description("Initialize UI8Kit structure in your project").option("-y, --yes", "Skip prompts and use defaults").option("-r, --registry <type>", "Registry type: ui", "ui").option("--registry-url <url>", "Override CDN registry base URL").option("--registry-version <version>", "Override registry @latest version").option("--strict-cdn", "Disable fallback CDN providers when override is provided").action(initCommand);
+program.command("init").description("Initialize UI8Kit structure in your project").option("-y, --yes", "Skip prompts and use defaults").option("-r, --registry <type>", "Registry type: ui", "ui").option("--registry-url <url>", "Override CDN registry base URL").option("--registry-version <version>", "Override registry @latest version").option("--strict-cdn", "Disable fallback CDN providers when override is provided").option("--import-style <alias|package>", "Rewrite imports as alias paths or @ui8kit/core package imports", "alias").action(initCommand);
 program.command("add").description("Add components to your project from the registry").argument("[components...]", "Components to add").option("-a, --all", "Install all available components").option("-f, --force", "Overwrite existing files").option("-r, --registry <type>", "Registry type: ui", "ui").option("--dry-run", "Show what would be installed without installing").option("--retry", "Aggressive retry mode (3 attempts per CDN request)").option("--registry-url <url>", "Override CDN registry base URL").option("--registry-version <version>", "Override registry @latest version").option("--strict-cdn", "Disable fallback CDN providers when override is provided").action(addCommand);
 program.command("scan").description("Scan and generate registry from existing components").option("-r, --registry <type|path>", "Registry type (ui) or custom path", "ui").option("-o, --output <file>", "Output registry file").option("-s, --source <dir>", "Source directory to scan").action(async (options) => {
   await scanCommand(options);