sigma-ui 1.1.1 → 1.1.2

package/dist/index.js

@@ -8,22 +8,80 @@ import process6 from "node:process";
 import { Command as Command4 } from "commander";
 
 // src/commands/add.ts
-import { execSync } from "node:child_process";
-import { existsSync as existsSync2, promises as fs3 } from "node:fs";
+import { existsSync as existsSync3, promises as fs3 } from "node:fs";
 import process3 from "node:process";
-import path4 from "pathe";
+import path5 from "pathe";
 import { consola as consola3 } from "consola";
 import { colors as colors2 } from "consola/utils";
 import { Command } from "commander";
 import ora from "ora";
 import prompts from "prompts";
 import { z as z2 } from "zod";
-import { addDependency, addDevDependency, detectPackageManager } from "nypm";
+
+// src/utils/package-manager.ts
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import path from "pathe";
+async function detectPackageManager(cwd) {
+  const lockFiles = [
+    { name: "pnpm", files: ["pnpm-lock.yaml", "pnpm-workspace.yaml"] },
+    { name: "yarn", files: ["yarn.lock"] },
+    { name: "bun", files: ["bun.lockb"] },
+    { name: "npm", files: ["package-lock.json"] }
+  ];
+  for (const pm of lockFiles) {
+    for (const file of pm.files) {
+      if (existsSync(path.join(cwd, file))) {
+        return { name: pm.name };
+      }
+    }
+  }
+  try {
+    const packageJsonPath = path.join(cwd, "package.json");
+    if (existsSync(packageJsonPath)) {
+      const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+      if (packageJson.packageManager) {
+        const [name, version] = packageJson.packageManager.split("@");
+        return { name, version };
+      }
+    }
+  } catch {
+  }
+  return { name: "pnpm" };
+}
+async function addDependency(dependencies, options8 = { cwd: process.cwd() }) {
+  await installPackages(dependencies, "dependencies", options8);
+}
+async function addDevDependency(dependencies, options8 = { cwd: process.cwd() }) {
+  await installPackages(dependencies, "devDependencies", options8);
+}
+async function installPackages(dependencies, type2, options8 = { cwd: process.cwd() }) {
+  const pm = await detectPackageManager(options8.cwd);
+  const devFlag = type2 === "devDependencies" ? "-D " : "";
+  let command = "";
+  switch (pm?.name) {
+    case "npm":
+      command = `npm install ${devFlag}${dependencies.join(" ")}`;
+      break;
+    case "yarn":
+      command = `yarn add ${devFlag}${dependencies.join(" ")}`;
+      break;
+    case "bun":
+      command = `bun add ${devFlag}${dependencies.join(" ")}`;
+      break;
+    case "pnpm":
+    default:
+      command = `pnpm add ${devFlag}${dependencies.join(" ")}`;
+      break;
+  }
+  const stdio = options8.silent ? "pipe" : "inherit";
+  execSync(command, { cwd: options8.cwd, stdio });
+}
 
 // src/utils/transformers/index.ts
 import { promises as fs } from "node:fs";
 import { tmpdir } from "node:os";
-import path from "pathe";
+import path2 from "pathe";
 import { Project, ScriptKind } from "ts-morph";
 
 // src/utils/transformers/transform-import.ts
@@ -67,8 +125,8 @@ var project = new Project({
   compilerOptions: {}
 });
 async function createTempSourceFile(filename) {
-  const dir = await fs.mkdtemp(path.join(tmpdir(), "sigma-ui-"));
-  return path.join(dir, filename);
+  const dir = await fs.mkdtemp(path2.join(tmpdir(), "sigma-ui-"));
+  return path2.join(dir, filename);
 }
 async function transform(opts) {
   const tempFile = await createTempSourceFile(opts.filename);
@@ -82,9 +140,9 @@ async function transform(opts) {
 }
 
 // src/utils/get-config.ts
-import { existsSync } from "node:fs";
+import { existsSync as existsSync2 } from "node:fs";
 import process2 from "node:process";
-import path2 from "pathe";
+import path3 from "pathe";
 import { loadConfig as c12LoadConfig } from "c12";
 import { loadConfig } from "tsconfig-paths";
 import consola from "consola";
@@ -238,14 +296,14 @@ async function handleConfigIsMissing() {
 }
 async function resolveConfigPaths(cwd, config) {
   let tsConfig;
-  let tsConfigPath = path2.resolve(
+  let tsConfigPath = path3.resolve(
     cwd,
     config.tsConfigPath
   );
   tsConfig = loadConfig(tsConfigPath);
   if ("paths" in tsConfig && Object.keys(tsConfig.paths).length === 0) {
-    tsConfigPath = path2.resolve(cwd, "./tsconfig.app.json");
-    if (existsSync(tsConfigPath)) {
+    tsConfigPath = path3.resolve(cwd, "./tsconfig.app.json");
+    if (existsSync2(tsConfigPath)) {
       tsConfig = loadConfig(tsConfigPath);
     }
   }
@@ -257,8 +315,8 @@ async function resolveConfigPaths(cwd, config) {
   return configSchema.parse({
     ...config,
     resolvedPaths: {
-      tailwindConfig: path2.resolve(cwd, config.tailwind.config),
-      tailwindCss: path2.resolve(cwd, config.cssPath),
+      tailwindConfig: path3.resolve(cwd, config.tailwind.config),
+      tailwindCss: path3.resolve(cwd, config.cssPath),
       utils: resolveImport(config.aliases.utils, tsConfig),
       components: resolveImport(config.aliases.components, tsConfig)
     }
@@ -297,7 +355,7 @@ function handleError(error) {
 
 // src/utils/registry/index.ts
 import fs2 from "node:fs";
-import path3 from "pathe";
+import path4 from "pathe";
 
 // ../../apps/docs/src/lib/registry/themes.ts
 var themes = [
@@ -756,7 +814,7 @@ function getItemTargetPath(config, item, override) {
   if (!(parent in config.resolvedPaths)) {
     return null;
   }
-  return path3.join(
+  return path4.join(
     config.resolvedPaths[parent] ?? "",
     type2
   );
@@ -818,8 +876,8 @@ function parseOptions(components, opts) {
   });
 }
 function validateAndResolveCwd(cwd) {
-  const resolvedCwd = path4.resolve(cwd);
-  if (!existsSync2(resolvedCwd)) {
+  const resolvedCwd = path5.resolve(cwd);
+  if (!existsSync3(resolvedCwd)) {
     consola3.error(`The path ${resolvedCwd} does not exist. Try again.`);
     process3.exit(1);
   }
@@ -880,7 +938,7 @@ async function processPayload(payload, options8, config, baseColor, cwd, selecte
     const targetDir = getItemTargetPath(
       config,
       item,
-      options8.path ? path4.resolve(cwd, options8.path) : void 0
+      options8.path ? path5.resolve(cwd, options8.path) : void 0
     );
     if (!targetDir) {
       continue;
@@ -891,12 +949,12 @@ async function processPayload(payload, options8, config, baseColor, cwd, selecte
 }
 async function processItem(item, targetDir, options8, config, baseColor, cwd, selectedComponents, spinner) {
   try {
-    if (!existsSync2(targetDir)) {
+    if (!existsSync3(targetDir)) {
       await fs3.mkdir(targetDir, { recursive: true });
     }
-    const componentPath = path4.resolve(targetDir, item.name);
+    const componentPath = path5.resolve(targetDir, item.name);
     const existingComponent = item.files.filter(
-      (file) => existsSync2(path4.resolve(componentPath, file.name))
+      (file) => existsSync3(path5.resolve(componentPath, file.name))
     );
     if (existingComponent.length && !options8.overwrite) {
       if (selectedComponents.includes(item.name)) {
@@ -936,62 +994,25 @@ async function installDependencies(item, cwd) {
   ].filter(Boolean);
   for (const task of installTasks) {
     try {
-      consola3.info(`Attempting to install ${task.type} using nypm: ${task.deps.join(", ")}`);
+      consola3.info(`Installing ${task.type}: ${task.deps.join(", ")}`);
       await task.installer(task.deps, { cwd });
-      consola3.success(`Successfully installed ${task.type} using nypm.`);
+      consola3.success(`Successfully installed ${task.type}.`);
     } catch (error) {
-      consola3.warn(`nypm failed to install ${task.type}:`, error);
-      const isCorepackError = error instanceof Error && error.message?.includes("corepack");
-      if (isCorepackError) {
-        consola3.info(`Falling back to direct pnpm execution for ${task.type}...`);
-        const pm = await detectPackageManager(cwd);
-        let command = "";
-        const depsString = task.deps.join(" ");
-        const devFlag = task.type === "devDependencies" ? "-D " : "";
-        switch (pm?.name) {
-          case "npm":
-            command = `npm install ${devFlag}${depsString}`;
-            break;
-          case "yarn":
-            command = `yarn add ${devFlag}${depsString}`;
-            break;
-          case "bun":
-            command = `bun add ${devFlag}${depsString}`;
-            break;
-          case "pnpm":
-          default:
-            command = `pnpm add ${devFlag}${depsString}`;
-            break;
-        }
-        try {
-          consola3.info(`Running: ${command}`);
-          execSync(command, { cwd, stdio: "inherit" });
-          consola3.success(`Successfully installed ${task.type} using direct pnpm execution.`);
-        } catch (fallbackError) {
-          const errorMessage = fallbackError instanceof Error ? fallbackError.message : "Unknown error";
-          consola3.error(`Fallback pnpm execution failed for ${task.type}:`, errorMessage);
-          throw new ComponentInstallError(
-            `Failed to install ${task.type} (nypm and fallback failed): ${errorMessage}`,
-            item.name
-          );
-        }
-      } else {
-        const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        throw new ComponentInstallError(
-          `Failed to install ${task.type} using nypm: ${errorMessage}`,
-          item.name
-        );
-      }
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      throw new ComponentInstallError(
+        `Failed to install ${task.type}: ${errorMessage}`,
+        item.name
+      );
     }
   }
 }
 async function writeComponentFiles(item, componentDir, config, baseColor) {
-  if (!existsSync2(componentDir)) {
+  if (!existsSync3(componentDir)) {
     await fs3.mkdir(componentDir, { recursive: true });
   }
   const files = item.files.map((file) => ({
     ...file,
-    path: path4.resolve(componentDir, file.name)
+    path: path5.resolve(componentDir, file.name)
   }));
   for (const file of files) {
     const content = await transform({
@@ -1006,9 +1027,9 @@ async function writeComponentFiles(item, componentDir, config, baseColor) {
 }
 
 // src/commands/diff.ts
-import { existsSync as existsSync3, promises as fs4 } from "node:fs";
+import { existsSync as existsSync4, promises as fs4 } from "node:fs";
 import process4 from "node:process";
-import path5 from "pathe";
+import path6 from "pathe";
 import { consola as consola4 } from "consola";
 import { colors as colors3 } from "consola/utils";
 import { Command as Command2 } from "commander";
@@ -1039,8 +1060,8 @@ function parseOptions2(name, opts) {
   });
 }
 function validateAndResolveCwd2(cwd) {
-  const resolvedCwd = path5.resolve(cwd);
-  if (!existsSync3(resolvedCwd)) {
+  const resolvedCwd = path6.resolve(cwd);
+  if (!existsSync4(resolvedCwd)) {
     consola4.error(`The path ${resolvedCwd} does not exist. Try again.`);
     process4.exit(1);
   }
@@ -1068,8 +1089,8 @@ async function handleAllComponentsDiff(config, registryIndex) {
 function findProjectComponents(registryIndex, targetDir) {
   return registryIndex.filter((item) => {
     return item.files.some((file) => {
-      const fullPath = path5.resolve(targetDir, item.name, file);
-      return existsSync3(fullPath);
+      const fullPath = path6.resolve(targetDir, item.name, file);
+      return existsSync4(fullPath);
     });
   });
 }
@@ -1132,8 +1153,8 @@ async function diffComponent(component, config) {
 }
 async function processItemFiles(item, targetDir, config, baseColor, changes) {
   for (const file of item.files) {
-    const filePath = path5.resolve(targetDir, item.name, file.name);
-    if (!existsSync3(filePath)) {
+    const filePath = path6.resolve(targetDir, item.name, file.name);
+    if (!existsSync4(filePath)) {
       continue;
     }
     const fileContent = await fs4.readFile(filePath, "utf8");
@@ -1170,17 +1191,15 @@ function printDiff(diff3) {
 }
 
 // src/commands/init.ts
-import { existsSync as existsSync5, promises as fs8 } from "node:fs";
+import { existsSync as existsSync6, promises as fs8 } from "node:fs";
 import process5 from "node:process";
 import path14 from "pathe";
 import { Command as Command3 } from "commander";
 import { template } from "lodash-es";
 import ora2 from "ora";
 import prompts2 from "prompts";
-import { addDependency as addDependency2, addDevDependency as addDevDependency2, detectPackageManager as detectPackageManager2 } from "nypm";
 import { consola as consola5 } from "consola";
 import { colors as colors4 } from "consola/utils";
-import { execSync as execSync2 } from "node:child_process";
 
 // ../../node_modules/.pnpm/prettier@3.5.0/node_modules/prettier/index.mjs
 import { createRequire as __prettierCreateRequire } from "module";
@@ -1195,13 +1214,13 @@ import path42 from "path";
 import * as path32 from "path";
 import fs5 from "fs/promises";
 import path22 from "path";
-import * as path6 from "path";
+import * as path7 from "path";
 import path8 from "path";
 import fs22 from "fs/promises";
 import fs32 from "fs/promises";
 import { pathToFileURL as pathToFileURL2 } from "url";
 import fs42 from "fs/promises";
-import path7 from "path";
+import path72 from "path";
 import { pathToFileURL as pathToFileURL4 } from "url";
 import assert3 from "assert";
 import { statSync, realpathSync } from "fs";
@@ -13700,15 +13719,15 @@ async function isDirectory(directory, options8) {
   return stats.isDirectory();
 }
 var is_directory_default = isDirectory;
-var toAbsolutePath = (value) => path6.resolve(toPath(value));
+var toAbsolutePath = (value) => path7.resolve(toPath(value));
 function* iterateDirectoryUp(from, to) {
   from = toAbsolutePath(from);
-  const { root: root2 } = path6.parse(from);
+  const { root: root2 } = path7.parse(from);
   to = to ? toAbsolutePath(to) : root2;
   if (from !== to && !from.startsWith(to)) {
     return;
   }
-  for (let directory = from; directory !== to; directory = path6.dirname(directory)) {
+  for (let directory = from; directory !== to; directory = path7.dirname(directory)) {
     yield directory;
   }
   yield to;
@@ -19062,7 +19081,7 @@ async function loadExternalConfig(externalConfig, configFile) {
 }
 var load_external_config_default = loadExternalConfig;
 async function loadConfig2(configFile) {
-  const { base: fileName, ext: extension } = path7.parse(configFile);
+  const { base: fileName, ext: extension } = path72.parse(configFile);
   const load2 = fileName === "package.json" ? loadConfigFromPackageJson : fileName === "package.yaml" ? loadConfigFromPackageYaml : loaders_default[extension];
   if (!load2) {
     throw new Error(
@@ -24085,7 +24104,7 @@ var src_default = index_exports;
 import { Project as Project2, SyntaxKind as SyntaxKind2 } from "ts-morph";
 
 // src/utils/get-project-info.ts
-import { existsSync as existsSync4 } from "node:fs";
+import { existsSync as existsSync5 } from "node:fs";
 import path13 from "pathe";
 import fs7 from "fs-extra";
 import { readPackageJSON } from "pkg-types";
@@ -24101,16 +24120,16 @@ async function getProjectInfo() {
   };
   try {
     const tsconfig = await getTsConfig();
-    const isNuxt = existsSync4(path13.resolve("./nuxt.config.js")) || existsSync4(path13.resolve("./nuxt.config.ts"));
+    const isNuxt = existsSync5(path13.resolve("./nuxt.config.js")) || existsSync5(path13.resolve("./nuxt.config.ts"));
     const sigmaUiNuxtModuleInfo = isNuxt ? await getSigmaUiNuxtInfo() : void 0;
     return {
       tsconfig,
       isNuxt,
       sigmaUiNuxtModuleInfo,
-      isVueVite: existsSync4(path13.resolve("./vite.config.js")) || existsSync4(path13.resolve("./vite.config.ts")),
-      srcDir: existsSync4(path13.resolve("./src")),
-      srcComponentsUiDir: existsSync4(path13.resolve("./src/components/ui")),
-      componentsUiDir: existsSync4(path13.resolve("./components/ui"))
+      isVueVite: existsSync5(path13.resolve("./vite.config.js")) || existsSync5(path13.resolve("./vite.config.ts")),
+      srcDir: existsSync5(path13.resolve("./src")),
+      srcComponentsUiDir: existsSync5(path13.resolve("./src/components/ui")),
+      componentsUiDir: existsSync5(path13.resolve("./components/ui"))
     };
   } catch (error) {
     console.log(error);
@@ -24743,7 +24762,7 @@ var init = new Command3().name("init").description("initialize your project and
     const spinner = ora2("Fetching data...").start();
     const options8 = initOptionsSchema.parse(opts);
     const cwd = path14.resolve(options8.cwd);
-    if (!existsSync5(cwd)) {
+    if (!existsSync6(cwd)) {
       consola5.error(`The path ${cwd} does not exist. Please try again.`);
       process5.exit(1);
     }
@@ -24899,7 +24918,11 @@ async function handleNuxtProject() {
   const { isNuxt, sigmaUiNuxtModuleInfo } = await getProjectInfo();
   if (isNuxt) {
     consola5.log("");
-    sigmaUiNuxtModuleInfo ? consola5.info(`Detected a Nuxt project with 'sigma-ui-nuxt' v${sigmaUiNuxtModuleInfo.version}`) : consola5.warn(`Detected a Nuxt project without 'sigma-ui-nuxt' module. It's recommended to install it.`);
+    if (sigmaUiNuxtModuleInfo) {
+      consola5.info(`Detected a Nuxt project with 'sigma-ui-nuxt' v${sigmaUiNuxtModuleInfo.version}`);
+    } else {
+      consola5.warn(`Detected a Nuxt project without 'sigma-ui-nuxt' module. It's recommended to install it.`);
+    }
   }
 }
 async function runInit(cwd, config) {
@@ -25000,50 +25023,17 @@ async function installDependencies2(config, cwd) {
   const deps = [...baseDeps, ...PROJECT_DEPENDENCIES.sharedBase].filter(Boolean);
   const devDeps = baseDevDeps.filter(Boolean);
   const installTasks = [
-    config.framework === "nuxt" && PROJECT_DEPENDENCIES.nuxt.length && { type: "devDependencies", deps: PROJECT_DEPENDENCIES.nuxt, installer: addDevDependency2 },
-    deps.length && { type: "dependencies", deps, installer: addDependency2 },
-    devDeps.length && { type: "devDependencies", deps: devDeps, installer: addDevDependency2 }
+    config.framework === "nuxt" && PROJECT_DEPENDENCIES.nuxt.length && { type: "devDependencies", deps: PROJECT_DEPENDENCIES.nuxt, installer: addDevDependency },
+    deps.length && { type: "dependencies", deps, installer: addDependency },
+    devDeps.length && { type: "devDependencies", deps: devDeps, installer: addDevDependency }
   ].filter(Boolean);
   for (const task of installTasks) {
     try {
       dependenciesSpinner.text = `Installing ${task.type}...`;
       await task.installer(task.deps, { cwd, silent: true });
     } catch (error) {
-      consola5.warn(`nypm failed to install ${task.type}:`, error);
-      const isCorepackError = error instanceof Error && error.message?.includes("corepack");
-      if (isCorepackError) {
-        consola5.info(`Falling back to direct package manager execution for ${task.type}...`);
-        const pm = await detectPackageManager2(cwd);
-        let command = "";
-        const depsString = task.deps.join(" ");
-        const devFlag = task.type === "devDependencies" ? "-D " : "";
-        switch (pm?.name) {
-          case "npm":
-            command = `npm install ${devFlag}${depsString}`;
-            break;
-          case "yarn":
-            command = `yarn add ${devFlag}${depsString}`;
-            break;
-          case "bun":
-            command = `bun add ${devFlag}${depsString}`;
-            break;
-          case "pnpm":
-          default:
-            command = `pnpm add ${devFlag}${depsString}`;
-            break;
-        }
-        try {
-          consola5.info(`Running: ${command}`);
-          execSync2(command, { cwd, stdio: "inherit" });
-          consola5.success(`Successfully installed ${task.type} using direct package manager execution.`);
-        } catch (fallbackError) {
-          const errorMessage = fallbackError instanceof Error ? fallbackError.message : "Unknown error";
-          consola5.error(`Fallback package manager execution failed for ${task.type}:`, errorMessage);
-        }
-      } else {
-        const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        consola5.error(`Failed to install ${task.type} using nypm: ${errorMessage}`);
-      }
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      consola5.error(`Failed to install ${task.type}: ${errorMessage}`);
     }
   }
   dependenciesSpinner?.succeed();
@@ -25075,7 +25065,7 @@ async function getDirectoryPath(key2, resolvedPath) {
 }
 async function updateViteConfig() {
   const viteConfigPath = path14.join(process5.cwd(), "vite.config.ts");
-  if (!existsSync5(viteConfigPath)) {
+  if (!existsSync6(viteConfigPath)) {
     consola5.warn(`Vite config file not found at ${viteConfigPath}`);
     return;
   }