trix-ui 0.2.8 → 0.2.10

package/dist/lib/install.js

@@ -1,56 +1,56 @@
-import path from "node:path";
-import { copyFileSafe, fileExists } from "./fs.js";
-import { resolveTargetPath, resolveTemplatePath, toPosix } from "./paths.js";
-import { resolveRegistrySource } from "./registry.js";
-export async function installRegistryEntries(options) {
-    const { cwd, config, entries, names, lockEntries, force, itemLabel } = options;
-    const installed = [];
-    const skipped = [];
-    const npmDependencies = new Set();
-    const { templatesPath } = resolveRegistrySource(config, cwd);
-    const unique = [...new Set(names.map((name) => name.trim()))].filter(Boolean);
-    const entryMap = new Map(entries.map((entry) => [entry.name, entry]));
-    const missing = unique.filter((name) => !entryMap.has(name));
-    if (missing.length) {
-        throw new Error(`Unknown ${itemLabel}: ${missing.join(", ")}`);
-    }
-    for (const name of unique) {
-        const entry = entryMap.get(name);
-        if (!entry) {
-            continue;
-        }
-        if (lockEntries[name] && !force) {
-            skipped.push(name);
-            continue;
-        }
-        const targetFiles = entry.files.map((file) => resolveTargetPath(cwd, file.target, config.paths));
-        if (!force) {
-            const alreadyExists = await Promise.all(targetFiles.map((target) => fileExists(target)));
-            if (alreadyExists.some(Boolean)) {
-                skipped.push(name);
-                continue;
-            }
-        }
-        for (const file of entry.files) {
-            const source = resolveTemplatePath(file.source, templatesPath);
-            const target = resolveTargetPath(cwd, file.target, config.paths);
-            await copyFileSafe(source, target, Boolean(force));
-        }
-        lockEntries[name] = {
-            version: "1",
-            files: normalizeLockFiles(cwd, targetFiles),
-            dependencies: entry.dependencies?.local,
-            installedAt: new Date().toISOString()
-        };
-        entry.dependencies?.npm?.forEach((dep) => npmDependencies.add(dep));
-        installed.push(name);
-    }
-    return { installed, skipped, npmDependencies };
-}
-function normalizeLockFiles(cwd, files) {
-    return files.map((filePath) => {
-        const relativePath = path.relative(cwd, filePath);
-        return toPosix(relativePath);
-    });
-}
+import path from "node:path";
+import { copyFileSafe, fileExists } from "./fs.js";
+import { resolveTargetPath, resolveTemplatePath, toPosix } from "./paths.js";
+import { resolveRegistrySource } from "./registry.js";
+export async function installRegistryEntries(options) {
+    const { cwd, config, entries, names, lockEntries, force, itemLabel } = options;
+    const installed = [];
+    const skipped = [];
+    const npmDependencies = new Set();
+    const { templatesPath } = resolveRegistrySource(config, cwd);
+    const unique = [...new Set(names.map((name) => name.trim()))].filter(Boolean);
+    const entryMap = new Map(entries.map((entry) => [entry.name, entry]));
+    const missing = unique.filter((name) => !entryMap.has(name));
+    if (missing.length) {
+        throw new Error(`Unknown ${itemLabel}: ${missing.join(", ")}`);
+    }
+    for (const name of unique) {
+        const entry = entryMap.get(name);
+        if (!entry) {
+            continue;
+        }
+        if (lockEntries[name] && !force) {
+            skipped.push(name);
+            continue;
+        }
+        const targetFiles = entry.files.map((file) => resolveTargetPath(cwd, file.target, config.paths));
+        if (!force) {
+            const alreadyExists = await Promise.all(targetFiles.map((target) => fileExists(target)));
+            if (alreadyExists.some(Boolean)) {
+                skipped.push(name);
+                continue;
+            }
+        }
+        for (const file of entry.files) {
+            const source = resolveTemplatePath(file.source, templatesPath);
+            const target = resolveTargetPath(cwd, file.target, config.paths);
+            await copyFileSafe(source, target, Boolean(force));
+        }
+        lockEntries[name] = {
+            version: "1",
+            files: normalizeLockFiles(cwd, targetFiles),
+            dependencies: entry.dependencies?.local,
+            installedAt: new Date().toISOString()
+        };
+        entry.dependencies?.npm?.forEach((dep) => npmDependencies.add(dep));
+        installed.push(name);
+    }
+    return { installed, skipped, npmDependencies };
+}
+function normalizeLockFiles(cwd, files) {
+    return files.map((filePath) => {
+        const relativePath = path.relative(cwd, filePath);
+        return toPosix(relativePath);
+    });
+}
 //# sourceMappingURL=install.js.map

package/dist/lib/lockfile.d.ts

@@ -1,63 +1,63 @@
-import { TrixUIConfig } from "./config.js";
-export interface LockfileComponent {
-    version: string;
-    files: string[];
-    dependencies?: string[];
-    installedAt: string;
-}
-export interface Lockfile {
-    version: number;
-    components: Record<string, LockfileComponent>;
-    sections: Record<string, LockfileComponent>;
-    wrappers: Record<string, LockfileComponent>;
-    composites: Record<string, LockfileComponent>;
-    updatedAt?: string;
-}
-/**
- * Get the lockfile path
- */
-export declare function resolveLockfilePath(cwd: string): string;
-/**
- * Check if lockfile exists
- */
-export declare function lockfileExists(cwd: string): Promise<boolean>;
-/**
- * Create an empty lockfile
- */
-export declare function createEmptyLockfile(): Lockfile;
-/**
- * Load lockfile from disk
- */
-export declare function loadLockfile(cwd: string): Promise<Lockfile>;
-/**
- * Save lockfile to disk
- */
-export declare function saveLockfile(cwd: string, lockfile: Lockfile): Promise<void>;
-/**
- * Add component to lockfile
- */
-export declare function addComponentToLockfile(cwd: string, type: "components" | "sections" | "wrappers" | "composites", name: string, component: Omit<LockfileComponent, "installedAt">): Promise<void>;
-/**
- * Remove component from lockfile
- */
-export declare function removeComponentFromLockfile(cwd: string, type: "components" | "sections" | "wrappers" | "composites", name: string): Promise<void>;
-/**
- * Check if component is installed
- */
-export declare function isComponentInstalled(cwd: string, type: "components" | "sections" | "wrappers" | "composites", name: string): Promise<boolean>;
-/**
- * Get installed component info
- */
-export declare function getInstalledComponent(cwd: string, type: "components" | "sections" | "wrappers" | "composites", name: string): Promise<LockfileComponent | null>;
-/**
- * List all installed components
- */
-export declare function listInstalledComponents(cwd: string, type?: "components" | "sections" | "wrappers" | "composites"): Promise<Record<string, LockfileComponent>>;
-/**
- * Validate lockfile integrity
- */
-export declare function validateLockfile(cwd: string, config: TrixUIConfig): Promise<{
-    valid: boolean;
-    errors: string[];
-    warnings: string[];
-}>;
+import { TrixUIConfig } from "./config.js";
+export interface LockfileComponent {
+    version: string;
+    files: string[];
+    dependencies?: string[];
+    installedAt: string;
+}
+export interface Lockfile {
+    version: number;
+    components: Record<string, LockfileComponent>;
+    sections: Record<string, LockfileComponent>;
+    wrappers: Record<string, LockfileComponent>;
+    composites: Record<string, LockfileComponent>;
+    updatedAt?: string;
+}
+/**
+ * Get the lockfile path
+ */
+export declare function resolveLockfilePath(cwd: string): string;
+/**
+ * Check if lockfile exists
+ */
+export declare function lockfileExists(cwd: string): Promise<boolean>;
+/**
+ * Create an empty lockfile
+ */
+export declare function createEmptyLockfile(): Lockfile;
+/**
+ * Load lockfile from disk
+ */
+export declare function loadLockfile(cwd: string): Promise<Lockfile>;
+/**
+ * Save lockfile to disk
+ */
+export declare function saveLockfile(cwd: string, lockfile: Lockfile): Promise<void>;
+/**
+ * Add component to lockfile
+ */
+export declare function addComponentToLockfile(cwd: string, type: "components" | "sections" | "wrappers" | "composites", name: string, component: Omit<LockfileComponent, "installedAt">): Promise<void>;
+/**
+ * Remove component from lockfile
+ */
+export declare function removeComponentFromLockfile(cwd: string, type: "components" | "sections" | "wrappers" | "composites", name: string): Promise<void>;
+/**
+ * Check if component is installed
+ */
+export declare function isComponentInstalled(cwd: string, type: "components" | "sections" | "wrappers" | "composites", name: string): Promise<boolean>;
+/**
+ * Get installed component info
+ */
+export declare function getInstalledComponent(cwd: string, type: "components" | "sections" | "wrappers" | "composites", name: string): Promise<LockfileComponent | null>;
+/**
+ * List all installed components
+ */
+export declare function listInstalledComponents(cwd: string, type?: "components" | "sections" | "wrappers" | "composites"): Promise<Record<string, LockfileComponent>>;
+/**
+ * Validate lockfile integrity
+ */
+export declare function validateLockfile(cwd: string, config: TrixUIConfig): Promise<{
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+}>;

package/dist/lib/lockfile.js

@@ -1,174 +1,174 @@
-import path from "node:path";
-import { fileExists, readJsonFile, writeJsonFile } from "./fs.js";
-const LOCKFILE_VERSION = 1;
-const LOCKFILE_DIRNAME = ".ui";
-const LOCKFILE_FILENAME = "lock.json";
-const LEGACY_LOCKFILE_FILENAME = "trix-ui.lock.json";
-/**
- * Get the lockfile path
- */
-export function resolveLockfilePath(cwd) {
-    return path.join(cwd, LOCKFILE_DIRNAME, LOCKFILE_FILENAME);
-}
-function resolveLegacyLockfilePath(cwd) {
-    return path.join(cwd, LEGACY_LOCKFILE_FILENAME);
-}
-/**
- * Check if lockfile exists
- */
-export async function lockfileExists(cwd) {
-    const currentPath = resolveLockfilePath(cwd);
-    if (await fileExists(currentPath)) {
-        return true;
-    }
-    return fileExists(resolveLegacyLockfilePath(cwd));
-}
-/**
- * Create an empty lockfile
- */
-export function createEmptyLockfile() {
-    return {
-        version: LOCKFILE_VERSION,
-        components: {},
-        sections: {},
-        wrappers: {},
-        composites: {},
-        updatedAt: new Date().toISOString(),
-    };
-}
-/**
- * Load lockfile from disk
- */
-export async function loadLockfile(cwd) {
-    const lockfilePath = resolveLockfilePath(cwd);
-    let resolvedPath = lockfilePath;
-    if (!(await fileExists(lockfilePath))) {
-        const legacyPath = resolveLegacyLockfilePath(cwd);
-        if (await fileExists(legacyPath)) {
-            resolvedPath = legacyPath;
-        }
-        else {
-            // Return empty lockfile if it doesn't exist
-            return createEmptyLockfile();
-        }
-    }
-    try {
-        const lockfile = await readJsonFile(resolvedPath);
-        // Validate lockfile structure
-        if (typeof lockfile.version !== "number") {
-            throw new Error("Invalid lockfile: missing or invalid 'version' field");
-        }
-        if (lockfile.version > LOCKFILE_VERSION) {
-            throw new Error(`Lockfile version ${lockfile.version} is not supported. ` +
-                `Please update trix-ui to the latest version.`);
-        }
-        // Ensure all required fields exist
-        return {
-            version: lockfile.version,
-            components: lockfile.components || {},
-            sections: lockfile.sections || {},
-            wrappers: lockfile.wrappers || {},
-            composites: lockfile.composites || {},
-            updatedAt: lockfile.updatedAt,
-        };
-    }
-    catch (error) {
-        throw new Error(`Failed to load lockfile: ${error.message}\n` +
-            `The lockfile may be corrupted. Try deleting ${LOCKFILE_DIRNAME}/${LOCKFILE_FILENAME} and running 'trix-ui init' again.`);
-    }
-}
-/**
- * Save lockfile to disk
- */
-export async function saveLockfile(cwd, lockfile) {
-    const lockfilePath = resolveLockfilePath(cwd);
-    // Update timestamp
-    lockfile.updatedAt = new Date().toISOString();
-    try {
-        await writeJsonFile(lockfilePath, lockfile, true);
-    }
-    catch (error) {
-        throw new Error(`Failed to save lockfile: ${error.message}`);
-    }
-}
-/**
- * Add component to lockfile
- */
-export async function addComponentToLockfile(cwd, type, name, component) {
-    const lockfile = await loadLockfile(cwd);
-    lockfile[type][name] = {
-        ...component,
-        installedAt: new Date().toISOString(),
-    };
-    await saveLockfile(cwd, lockfile);
-}
-/**
- * Remove component from lockfile
- */
-export async function removeComponentFromLockfile(cwd, type, name) {
-    const lockfile = await loadLockfile(cwd);
-    delete lockfile[type][name];
-    await saveLockfile(cwd, lockfile);
-}
-/**
- * Check if component is installed
- */
-export async function isComponentInstalled(cwd, type, name) {
-    const lockfile = await loadLockfile(cwd);
-    return name in lockfile[type];
-}
-/**
- * Get installed component info
- */
-export async function getInstalledComponent(cwd, type, name) {
-    const lockfile = await loadLockfile(cwd);
-    return lockfile[type][name] || null;
-}
-/**
- * List all installed components
- */
-export async function listInstalledComponents(cwd, type) {
-    const lockfile = await loadLockfile(cwd);
-    if (type) {
-        return lockfile[type];
-    }
-    // Return all types combined
-    return {
-        ...lockfile.components,
-        ...lockfile.sections,
-        ...lockfile.wrappers,
-        ...lockfile.composites,
-    };
-}
-/**
- * Validate lockfile integrity
- */
-export async function validateLockfile(cwd, config) {
-    const errors = [];
-    const warnings = [];
-    try {
-        const lockfile = await loadLockfile(cwd);
-        // Check version compatibility
-        if (lockfile.version > LOCKFILE_VERSION) {
-            errors.push(`Lockfile version ${lockfile.version} is newer than supported version ${LOCKFILE_VERSION}`);
-        }
-        // Verify installed files exist
-        for (const [name, component] of Object.entries(lockfile.components)) {
-            for (const file of component.files || []) {
-                const filePath = path.join(cwd, config.paths.components, file);
-                if (!(await fileExists(filePath))) {
-                    warnings.push(`Component '${name}' file missing: ${file}`);
-                }
-            }
-        }
-    }
-    catch (error) {
-        errors.push(error.message);
-    }
-    return {
-        valid: errors.length === 0,
-        errors,
-        warnings,
-    };
-}
+import path from "node:path";
+import { fileExists, readJsonFile, writeJsonFile } from "./fs.js";
+const LOCKFILE_VERSION = 1;
+const LOCKFILE_DIRNAME = ".ui";
+const LOCKFILE_FILENAME = "lock.json";
+const LEGACY_LOCKFILE_FILENAME = "trix-ui.lock.json";
+/**
+ * Get the lockfile path
+ */
+export function resolveLockfilePath(cwd) {
+    return path.join(cwd, LOCKFILE_DIRNAME, LOCKFILE_FILENAME);
+}
+function resolveLegacyLockfilePath(cwd) {
+    return path.join(cwd, LEGACY_LOCKFILE_FILENAME);
+}
+/**
+ * Check if lockfile exists
+ */
+export async function lockfileExists(cwd) {
+    const currentPath = resolveLockfilePath(cwd);
+    if (await fileExists(currentPath)) {
+        return true;
+    }
+    return fileExists(resolveLegacyLockfilePath(cwd));
+}
+/**
+ * Create an empty lockfile
+ */
+export function createEmptyLockfile() {
+    return {
+        version: LOCKFILE_VERSION,
+        components: {},
+        sections: {},
+        wrappers: {},
+        composites: {},
+        updatedAt: new Date().toISOString(),
+    };
+}
+/**
+ * Load lockfile from disk
+ */
+export async function loadLockfile(cwd) {
+    const lockfilePath = resolveLockfilePath(cwd);
+    let resolvedPath = lockfilePath;
+    if (!(await fileExists(lockfilePath))) {
+        const legacyPath = resolveLegacyLockfilePath(cwd);
+        if (await fileExists(legacyPath)) {
+            resolvedPath = legacyPath;
+        }
+        else {
+            // Return empty lockfile if it doesn't exist
+            return createEmptyLockfile();
+        }
+    }
+    try {
+        const lockfile = await readJsonFile(resolvedPath);
+        // Validate lockfile structure
+        if (typeof lockfile.version !== "number") {
+            throw new Error("Invalid lockfile: missing or invalid 'version' field");
+        }
+        if (lockfile.version > LOCKFILE_VERSION) {
+            throw new Error(`Lockfile version ${lockfile.version} is not supported. ` +
+                `Please update trix-ui to the latest version.`);
+        }
+        // Ensure all required fields exist
+        return {
+            version: lockfile.version,
+            components: lockfile.components || {},
+            sections: lockfile.sections || {},
+            wrappers: lockfile.wrappers || {},
+            composites: lockfile.composites || {},
+            updatedAt: lockfile.updatedAt,
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to load lockfile: ${error.message}\n` +
+            `The lockfile may be corrupted. Try deleting ${LOCKFILE_DIRNAME}/${LOCKFILE_FILENAME} and running 'trix-ui init' again.`);
+    }
+}
+/**
+ * Save lockfile to disk
+ */
+export async function saveLockfile(cwd, lockfile) {
+    const lockfilePath = resolveLockfilePath(cwd);
+    // Update timestamp
+    lockfile.updatedAt = new Date().toISOString();
+    try {
+        await writeJsonFile(lockfilePath, lockfile, true);
+    }
+    catch (error) {
+        throw new Error(`Failed to save lockfile: ${error.message}`);
+    }
+}
+/**
+ * Add component to lockfile
+ */
+export async function addComponentToLockfile(cwd, type, name, component) {
+    const lockfile = await loadLockfile(cwd);
+    lockfile[type][name] = {
+        ...component,
+        installedAt: new Date().toISOString(),
+    };
+    await saveLockfile(cwd, lockfile);
+}
+/**
+ * Remove component from lockfile
+ */
+export async function removeComponentFromLockfile(cwd, type, name) {
+    const lockfile = await loadLockfile(cwd);
+    delete lockfile[type][name];
+    await saveLockfile(cwd, lockfile);
+}
+/**
+ * Check if component is installed
+ */
+export async function isComponentInstalled(cwd, type, name) {
+    const lockfile = await loadLockfile(cwd);
+    return name in lockfile[type];
+}
+/**
+ * Get installed component info
+ */
+export async function getInstalledComponent(cwd, type, name) {
+    const lockfile = await loadLockfile(cwd);
+    return lockfile[type][name] || null;
+}
+/**
+ * List all installed components
+ */
+export async function listInstalledComponents(cwd, type) {
+    const lockfile = await loadLockfile(cwd);
+    if (type) {
+        return lockfile[type];
+    }
+    // Return all types combined
+    return {
+        ...lockfile.components,
+        ...lockfile.sections,
+        ...lockfile.wrappers,
+        ...lockfile.composites,
+    };
+}
+/**
+ * Validate lockfile integrity
+ */
+export async function validateLockfile(cwd, config) {
+    const errors = [];
+    const warnings = [];
+    try {
+        const lockfile = await loadLockfile(cwd);
+        // Check version compatibility
+        if (lockfile.version > LOCKFILE_VERSION) {
+            errors.push(`Lockfile version ${lockfile.version} is newer than supported version ${LOCKFILE_VERSION}`);
+        }
+        // Verify installed files exist
+        for (const [name, component] of Object.entries(lockfile.components)) {
+            for (const file of component.files || []) {
+                const filePath = path.join(cwd, config.paths.components, file);
+                if (!(await fileExists(filePath))) {
+                    warnings.push(`Component '${name}' file missing: ${file}`);
+                }
+            }
+        }
+    }
+    catch (error) {
+        errors.push(error.message);
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
 //# sourceMappingURL=lockfile.js.map

package/dist/lib/logger.d.ts

@@ -1,8 +1,8 @@
-export declare const logger: {
-    error(...args: unknown[]): void;
-    warn(...args: unknown[]): void;
-    info(...args: unknown[]): void;
-    success(...args: unknown[]): void;
-    log(...args: unknown[]): void;
-    break(): void;
-};
+export declare const logger: {
+    error(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    success(...args: unknown[]): void;
+    log(...args: unknown[]): void;
+    break(): void;
+};