trix-ui 0.2.7 → 0.2.9

package/dist/commands/add/__tests__/add.test.js

@@ -1,141 +1,141 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { addCommand } from "../../add.js";
-import "./__mocks__/cli-mocks.js";
-import "./add.mocks.js";
-import { analyzeDependencies, directoryExists, getComponentNames, installComponents, loadConfig, loadLockfile, loadRegistry, validateComponents } from "./add.mocks.js";
-describe("add command", () => {
-    beforeEach(() => {
-        vi.resetAllMocks();
-    });
-    it("exits if directory does not exist", async () => {
-        directoryExists.mockResolvedValue(false);
-        await addCommand.parseAsync(["node", "cli", "add", "button"]);
-        expect(process.exit).toHaveBeenCalledWith(1);
-    });
-    it("exits if component does not exist", async () => {
-        directoryExists.mockResolvedValue(true);
-        loadConfig.mockResolvedValue({});
-        loadRegistry.mockResolvedValue({});
-        loadLockfile.mockResolvedValue({});
-        validateComponents.mockReturnValue({
-            valid: [],
-            invalid: ["button"],
-            suggestions: []
-        });
-        await addCommand.parseAsync(["node", "cli", "add", "button"]);
-        expect(process.exit).toHaveBeenCalledWith(1);
-    });
-    it("installs a valid component successfully", async () => {
-        directoryExists.mockResolvedValue(true);
-        loadConfig.mockResolvedValue({ barrel: false });
-        loadRegistry.mockResolvedValue({});
-        loadLockfile.mockResolvedValue({});
-        validateComponents.mockReturnValue({
-            valid: ["button"],
-            invalid: [],
-            suggestions: []
-        });
-        analyzeDependencies.mockReturnValue({
-            components: ["button"],
-            dependencies: new Set(),
-            npmDependencies: new Set(),
-            conflicts: [],
-            totalToInstall: 1,
-            missingDependencies: []
-        });
-        installComponents.mockResolvedValue({
-            installed: ["button"],
-            failed: [],
-            npmDependencies: new Set()
-        });
-        await addCommand.parseAsync(["node", "cli", "add", "button", "--yes"]);
-        expect(installComponents).toHaveBeenCalled();
-    });
-    it("installs all components when 'all' is used", async () => {
-        directoryExists.mockResolvedValue(true);
-        loadConfig.mockResolvedValue({});
-        loadRegistry.mockResolvedValue({});
-        loadLockfile.mockResolvedValue({});
-        getComponentNames.mockReturnValue(["button", "card"]);
-        validateComponents.mockReturnValue({
-            valid: ["button", "card"],
-            invalid: [],
-            suggestions: []
-        });
-        analyzeDependencies.mockReturnValue({
-            components: ["button", "card"],
-            dependencies: new Set(),
-            npmDependencies: new Set(),
-            conflicts: [],
-            totalToInstall: 2,
-            missingDependencies: []
-        });
-        installComponents.mockResolvedValue({
-            installed: ["button", "card"],
-            failed: [],
-            npmDependencies: new Set()
-        });
-        await addCommand.parseAsync(["node", "cli", "add", "all", "--yes"]);
-        expect(installComponents).toHaveBeenCalled();
-    });
-    it("forces overwrite when --force is passed", async () => {
-        directoryExists.mockResolvedValue(true);
-        loadConfig.mockResolvedValue({});
-        loadRegistry.mockResolvedValue({});
-        loadLockfile.mockResolvedValue({});
-        validateComponents.mockReturnValue({
-            valid: ["button"],
-            invalid: [],
-            suggestions: []
-        });
-        analyzeDependencies.mockReturnValue({
-            components: ["button"],
-            dependencies: new Set(),
-            npmDependencies: new Set(),
-            conflicts: ["button"],
-            totalToInstall: 0,
-            missingDependencies: []
-        });
-        installComponents.mockResolvedValue({
-            installed: ["button"],
-            failed: [],
-            npmDependencies: new Set()
-        });
-        await addCommand.parseAsync([
-            "node",
-            "cli",
-            "add",
-            "button",
-            "--force",
-            "--yes"
-        ]);
-        expect(installComponents).toHaveBeenCalled();
-    });
-    it("exits with failure if install fails", async () => {
-        directoryExists.mockResolvedValue(true);
-        loadConfig.mockResolvedValue({});
-        loadRegistry.mockResolvedValue({});
-        loadLockfile.mockResolvedValue({});
-        validateComponents.mockReturnValue({
-            valid: ["button"],
-            invalid: [],
-            suggestions: []
-        });
-        analyzeDependencies.mockReturnValue({
-            components: ["hbutton"],
-            dependencies: new Set(),
-            npmDependencies: new Set(),
-            conflicts: [],
-            totalToInstall: 1,
-            missingDependencies: []
-        });
-        installComponents.mockResolvedValue({
-            installed: [],
-            failed: ["button"],
-            npmDependencies: new Set()
-        });
-        await addCommand.parseAsync(["node", "cli", "add", "button", "--yes"]);
-        expect(process.exit).toHaveBeenCalledWith(1);
-    });
-});
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { addCommand } from "../../add.js";
+import "./__mocks__/cli-mocks.js";
+import "./add.mocks.js";
+import { analyzeDependencies, directoryExists, getComponentNames, installComponents, loadConfig, loadLockfile, loadRegistry, validateComponents } from "./add.mocks.js";
+describe("add command", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    it("exits if directory does not exist", async () => {
+        directoryExists.mockResolvedValue(false);
+        await addCommand.parseAsync(["node", "cli", "add", "button"]);
+        expect(process.exit).toHaveBeenCalledWith(1);
+    });
+    it("exits if component does not exist", async () => {
+        directoryExists.mockResolvedValue(true);
+        loadConfig.mockResolvedValue({});
+        loadRegistry.mockResolvedValue({});
+        loadLockfile.mockResolvedValue({});
+        validateComponents.mockReturnValue({
+            valid: [],
+            invalid: ["button"],
+            suggestions: []
+        });
+        await addCommand.parseAsync(["node", "cli", "add", "button"]);
+        expect(process.exit).toHaveBeenCalledWith(1);
+    });
+    it("installs a valid component successfully", async () => {
+        directoryExists.mockResolvedValue(true);
+        loadConfig.mockResolvedValue({ barrel: false });
+        loadRegistry.mockResolvedValue({});
+        loadLockfile.mockResolvedValue({});
+        validateComponents.mockReturnValue({
+            valid: ["button"],
+            invalid: [],
+            suggestions: []
+        });
+        analyzeDependencies.mockReturnValue({
+            components: ["button"],
+            dependencies: new Set(),
+            npmDependencies: new Set(),
+            conflicts: [],
+            totalToInstall: 1,
+            missingDependencies: []
+        });
+        installComponents.mockResolvedValue({
+            installed: ["button"],
+            failed: [],
+            npmDependencies: new Set()
+        });
+        await addCommand.parseAsync(["node", "cli", "add", "button", "--yes"]);
+        expect(installComponents).toHaveBeenCalled();
+    });
+    it("installs all components when 'all' is used", async () => {
+        directoryExists.mockResolvedValue(true);
+        loadConfig.mockResolvedValue({});
+        loadRegistry.mockResolvedValue({});
+        loadLockfile.mockResolvedValue({});
+        getComponentNames.mockReturnValue(["button", "card"]);
+        validateComponents.mockReturnValue({
+            valid: ["button", "card"],
+            invalid: [],
+            suggestions: []
+        });
+        analyzeDependencies.mockReturnValue({
+            components: ["button", "card"],
+            dependencies: new Set(),
+            npmDependencies: new Set(),
+            conflicts: [],
+            totalToInstall: 2,
+            missingDependencies: []
+        });
+        installComponents.mockResolvedValue({
+            installed: ["button", "card"],
+            failed: [],
+            npmDependencies: new Set()
+        });
+        await addCommand.parseAsync(["node", "cli", "add", "all", "--yes"]);
+        expect(installComponents).toHaveBeenCalled();
+    });
+    it("forces overwrite when --force is passed", async () => {
+        directoryExists.mockResolvedValue(true);
+        loadConfig.mockResolvedValue({});
+        loadRegistry.mockResolvedValue({});
+        loadLockfile.mockResolvedValue({});
+        validateComponents.mockReturnValue({
+            valid: ["button"],
+            invalid: [],
+            suggestions: []
+        });
+        analyzeDependencies.mockReturnValue({
+            components: ["button"],
+            dependencies: new Set(),
+            npmDependencies: new Set(),
+            conflicts: ["button"],
+            totalToInstall: 0,
+            missingDependencies: []
+        });
+        installComponents.mockResolvedValue({
+            installed: ["button"],
+            failed: [],
+            npmDependencies: new Set()
+        });
+        await addCommand.parseAsync([
+            "node",
+            "cli",
+            "add",
+            "button",
+            "--force",
+            "--yes"
+        ]);
+        expect(installComponents).toHaveBeenCalled();
+    });
+    it("exits with failure if install fails", async () => {
+        directoryExists.mockResolvedValue(true);
+        loadConfig.mockResolvedValue({});
+        loadRegistry.mockResolvedValue({});
+        loadLockfile.mockResolvedValue({});
+        validateComponents.mockReturnValue({
+            valid: ["button"],
+            invalid: [],
+            suggestions: []
+        });
+        analyzeDependencies.mockReturnValue({
+            components: ["hbutton"],
+            dependencies: new Set(),
+            npmDependencies: new Set(),
+            conflicts: [],
+            totalToInstall: 1,
+            missingDependencies: []
+        });
+        installComponents.mockResolvedValue({
+            installed: [],
+            failed: ["button"],
+            npmDependencies: new Set()
+        });
+        await addCommand.parseAsync(["node", "cli", "add", "button", "--yes"]);
+        expect(process.exit).toHaveBeenCalledWith(1);
+    });
+});
 //# sourceMappingURL=add.test.js.map

package/dist/commands/add/analysis.d.ts

@@ -1,4 +1,4 @@
-import type { Lockfile } from "../../lib/lockfile.js";
-import type { RegistryIndex } from "../../lib/registry.js";
-import type { DependencyAnalysis } from "./types.js";
-export declare function analyzeDependencies(components: string[], registry: RegistryIndex, lockfile: Lockfile): DependencyAnalysis;
+import type { Lockfile } from "../../lib/lockfile.js";
+import type { RegistryIndex } from "../../lib/registry.js";
+import type { DependencyAnalysis } from "./types.js";
+export declare function analyzeDependencies(components: string[], registry: RegistryIndex, lockfile: Lockfile): DependencyAnalysis;

package/dist/commands/add/analysis.js

@@ -1,57 +1,57 @@
-import { createComponentMap } from "./registry.js";
-function collectLocalDependencies(entry) {
-    return entry.dependencies?.local ?? [];
-}
-function collectNpmDependencies(entry) {
-    return entry.dependencies?.npm ?? [];
-}
-export function analyzeDependencies(components, registry, lockfile) {
-    const componentMap = createComponentMap(registry);
-    const allComponents = new Set(components);
-    const dependencies = new Set();
-    const npmDependencies = new Set();
-    const missingDependencies = new Set();
-    const visited = new Set();
-    const resolveDependencies = (componentName) => {
-        if (visited.has(componentName)) {
-            return;
-        }
-        visited.add(componentName);
-        const entry = componentMap.get(componentName);
-        if (!entry) {
-            missingDependencies.add(componentName);
-            allComponents.delete(componentName);
-            dependencies.delete(componentName);
-            return;
-        }
-        for (const dep of collectLocalDependencies(entry)) {
-            if (!allComponents.has(dep)) {
-                allComponents.add(dep);
-                dependencies.add(dep);
-            }
-            resolveDependencies(dep);
-        }
-        for (const dep of collectNpmDependencies(entry)) {
-            npmDependencies.add(dep);
-        }
-    };
-    for (const component of components) {
-        resolveDependencies(component);
-    }
-    const conflicts = [];
-    for (const component of allComponents) {
-        if (lockfile.components[component]) {
-            conflicts.push(component);
-        }
-    }
-    const totalToInstall = Math.max(0, allComponents.size - conflicts.length);
-    return {
-        components: Array.from(allComponents),
-        dependencies,
-        npmDependencies,
-        conflicts,
-        totalToInstall,
-        missingDependencies: Array.from(missingDependencies).sort()
-    };
-}
+import { createComponentMap } from "./registry.js";
+function collectLocalDependencies(entry) {
+    return entry.dependencies?.local ?? [];
+}
+function collectNpmDependencies(entry) {
+    return entry.dependencies?.npm ?? [];
+}
+export function analyzeDependencies(components, registry, lockfile) {
+    const componentMap = createComponentMap(registry);
+    const allComponents = new Set(components);
+    const dependencies = new Set();
+    const npmDependencies = new Set();
+    const missingDependencies = new Set();
+    const visited = new Set();
+    const resolveDependencies = (componentName) => {
+        if (visited.has(componentName)) {
+            return;
+        }
+        visited.add(componentName);
+        const entry = componentMap.get(componentName);
+        if (!entry) {
+            missingDependencies.add(componentName);
+            allComponents.delete(componentName);
+            dependencies.delete(componentName);
+            return;
+        }
+        for (const dep of collectLocalDependencies(entry)) {
+            if (!allComponents.has(dep)) {
+                allComponents.add(dep);
+                dependencies.add(dep);
+            }
+            resolveDependencies(dep);
+        }
+        for (const dep of collectNpmDependencies(entry)) {
+            npmDependencies.add(dep);
+        }
+    };
+    for (const component of components) {
+        resolveDependencies(component);
+    }
+    const conflicts = [];
+    for (const component of allComponents) {
+        if (lockfile.components[component]) {
+            conflicts.push(component);
+        }
+    }
+    const totalToInstall = Math.max(0, allComponents.size - conflicts.length);
+    return {
+        components: Array.from(allComponents),
+        dependencies,
+        npmDependencies,
+        conflicts,
+        totalToInstall,
+        missingDependencies: Array.from(missingDependencies).sort()
+    };
+}
 //# sourceMappingURL=analysis.js.map

package/dist/commands/add/command.d.ts

@@ -1,2 +1,2 @@
-import { Command } from "commander";
-export declare const addCommand: Command;
+import { Command } from "commander";
+export declare const addCommand: Command;