trix-ui 0.2.8 → 0.2.10

package/dist/lib/fs.js

@@ -1,303 +1,303 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { logger } from "./logger.js";
-/**
- * Check if a file exists
- */
-export async function fileExists(filePath) {
-    try {
-        await fs.access(filePath, fs.constants.F_OK);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Check if a directory exists
- */
-export async function directoryExists(dirPath) {
-    try {
-        const stat = await fs.stat(dirPath);
-        return stat.isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Ensure a directory exists, create if it doesn't
- */
-export async function ensureDir(dirPath) {
-    try {
-        await fs.mkdir(dirPath, { recursive: true });
-    }
-    catch (error) {
-        throw new Error(`Failed to create directory ${dirPath}: ${error.message}`);
-    }
-}
-/**
- * Read a file as a string with proper encoding and BOM handling
- */
-export async function readFile(filePath) {
-    try {
-        // Check if file exists first
-        if (!(await fileExists(filePath))) {
-            throw new Error(`File not found: ${filePath}`);
-        }
-        // Read with explicit UTF-8 encoding
-        let content = await fs.readFile(filePath, { encoding: "utf-8" });
-        // Remove BOM if present (UTF-8 BOM is EF BB BF)
-        if (content.charCodeAt(0) === 0xfeff) {
-            content = content.slice(1);
-        }
-        // Trim whitespace that might cause JSON parsing issues
-        content = content.trim();
-        // Check if file is empty
-        if (content.length === 0) {
-            throw new Error(`File is empty: ${filePath}`);
-        }
-        return content;
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            throw error;
-        }
-        throw new Error(`Failed to read file ${filePath}: ${error}`);
-    }
-}
-/**
- * Read and parse a JSON file with comprehensive error handling
- */
-export async function readJsonFile(filePath) {
-    try {
-        const content = await readFile(filePath);
-        // Attempt to parse JSON
-        try {
-            const parsed = JSON.parse(content);
-            return parsed;
-        }
-        catch (parseError) {
-            // Provide helpful error message with context
-            const errorMessage = parseError.message;
-            const preview = content.substring(0, 100);
-            throw new Error(`Invalid JSON in ${path.basename(filePath)}: ${errorMessage}\n` +
-                `Preview: ${preview}${content.length > 100 ? "..." : ""}`);
-        }
-    }
-    catch (error) {
-        throw error;
-    }
-}
-/**
- * Write content to a file
- */
-export async function writeFile(filePath, content) {
-    try {
-        // Ensure parent directory exists
-        const dir = path.dirname(filePath);
-        await ensureDir(dir);
-        // Write with UTF-8 encoding, no BOM
-        await fs.writeFile(filePath, content, { encoding: "utf-8" });
-    }
-    catch (error) {
-        throw new Error(`Failed to write file ${filePath}: ${error.message}`);
-    }
-}
-/**
- * Write content to a file only if it doesn't exist or force is true
- */
-export async function writeFileSafe(filePath, content, force = false) {
-    try {
-        const exists = await fileExists(filePath);
-        if (exists && !force) {
-            logger.warn(`File already exists, skipping: ${filePath}`);
-            return false;
-        }
-        await writeFile(filePath, content);
-        return true;
-    }
-    catch (error) {
-        throw new Error(`Failed to write file ${filePath}: ${error.message}`);
-    }
-}
-/**
- * Write JSON to a file with pretty formatting
- */
-export async function writeJsonFile(filePath, data, force = false) {
-    try {
-        const exists = await fileExists(filePath);
-        if (exists && !force) {
-            throw new Error(`File already exists: ${filePath}. Use --force to overwrite.`);
-        }
-        const content = JSON.stringify(data, null, 2) + "\n";
-        await writeFile(filePath, content);
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            throw error;
-        }
-        throw new Error(`Failed to write JSON file ${filePath}: ${error}`);
-    }
-}
-/**
- * Copy a file from source to destination
- */
-export async function copyFile(src, dest) {
-    try {
-        if (!(await fileExists(src))) {
-            throw new Error(`Source file not found: ${src}`);
-        }
-        // Ensure destination directory exists
-        const destDir = path.dirname(dest);
-        await ensureDir(destDir);
-        await fs.copyFile(src, dest);
-    }
-    catch (error) {
-        throw new Error(`Failed to copy file from ${src} to ${dest}: ${error.message}`);
-    }
-}
-/**
- * Copy a file only if destination doesn't exist or force is true
- */
-export async function copyFileSafe(src, dest, force = false) {
-    try {
-        const exists = await fileExists(dest);
-        if (exists && !force) {
-            logger.warn(`File already exists, skipping: ${dest}`);
-            return false;
-        }
-        await copyFile(src, dest);
-        return true;
-    }
-    catch (error) {
-        throw new Error(`Failed to copy file from ${src} to ${dest}: ${error.message}`);
-    }
-}
-/**
- * Delete a file
- */
-export async function deleteFile(filePath) {
-    try {
-        if (await fileExists(filePath)) {
-            await fs.unlink(filePath);
-        }
-    }
-    catch (error) {
-        throw new Error(`Failed to delete file ${filePath}: ${error.message}`);
-    }
-}
-/**
- * Delete a directory recursively
- */
-export async function deleteDirectory(dirPath) {
-    try {
-        if (await directoryExists(dirPath)) {
-            await fs.rm(dirPath, { recursive: true, force: true });
-        }
-    }
-    catch (error) {
-        throw new Error(`Failed to delete directory ${dirPath}: ${error.message}`);
-    }
-}
-/**
- * List files in a directory
- */
-export async function listFiles(dirPath, options) {
-    try {
-        if (!(await directoryExists(dirPath))) {
-            return [];
-        }
-        const files = [];
-        const entries = await fs.readdir(dirPath, { withFileTypes: true });
-        for (const entry of entries) {
-            const fullPath = path.join(dirPath, entry.name);
-            if (entry.isDirectory() && options?.recursive) {
-                const subFiles = await listFiles(fullPath, options);
-                files.push(...subFiles);
-            }
-            else if (entry.isFile()) {
-                if (options?.extension) {
-                    if (entry.name.endsWith(options.extension)) {
-                        files.push(fullPath);
-                    }
-                }
-                else {
-                    files.push(fullPath);
-                }
-            }
-        }
-        return files;
-    }
-    catch (error) {
-        throw new Error(`Failed to list files in ${dirPath}: ${error.message}`);
-    }
-}
-/**
- * Get file stats
- */
-export async function getFileStats(filePath) {
-    try {
-        return await fs.stat(filePath);
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Check if path is a file
- */
-export async function isFile(filePath) {
-    try {
-        const stat = await fs.stat(filePath);
-        return stat.isFile();
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Check if path is a directory
- */
-export async function isDirectory(dirPath) {
-    return directoryExists(dirPath);
-}
-/**
- * Read package.json with validation
- */
-export async function readPackageJson(cwd) {
-    const packageJsonPath = path.join(cwd, "package.json");
-    try {
-        const packageJson = await readJsonFile(packageJsonPath);
-        // Validate it's actually a package.json
-        if (!packageJson.name) {
-            throw new Error("Invalid package.json: missing 'name' field");
-        }
-        return packageJson;
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            throw new Error(`Failed to read package.json: ${error.message}`);
-        }
-        throw error;
-    }
-}
-/**
- * Update package.json dependencies
- */
-export async function updatePackageJsonDependencies(cwd, dependencies, dev = false) {
-    try {
-        const packageJson = await readPackageJson(cwd);
-        const depKey = dev ? "devDependencies" : "dependencies";
-        packageJson[depKey] = {
-            ...packageJson[depKey],
-            ...dependencies,
-        };
-        const packageJsonPath = path.join(cwd, "package.json");
-        await writeJsonFile(packageJsonPath, packageJson, true);
-    }
-    catch (error) {
-        throw new Error(`Failed to update package.json: ${error.message}`);
-    }
-}
+import fs from "node:fs/promises";
+import path from "node:path";
+import { logger } from "./logger.js";
+/**
+ * Check if a file exists
+ */
+export async function fileExists(filePath) {
+    try {
+        await fs.access(filePath, fs.constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if a directory exists
+ */
+export async function directoryExists(dirPath) {
+    try {
+        const stat = await fs.stat(dirPath);
+        return stat.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Ensure a directory exists, create if it doesn't
+ */
+export async function ensureDir(dirPath) {
+    try {
+        await fs.mkdir(dirPath, { recursive: true });
+    }
+    catch (error) {
+        throw new Error(`Failed to create directory ${dirPath}: ${error.message}`);
+    }
+}
+/**
+ * Read a file as a string with proper encoding and BOM handling
+ */
+export async function readFile(filePath) {
+    try {
+        // Check if file exists first
+        if (!(await fileExists(filePath))) {
+            throw new Error(`File not found: ${filePath}`);
+        }
+        // Read with explicit UTF-8 encoding
+        let content = await fs.readFile(filePath, { encoding: "utf-8" });
+        // Remove BOM if present (UTF-8 BOM is EF BB BF)
+        if (content.charCodeAt(0) === 0xfeff) {
+            content = content.slice(1);
+        }
+        // Trim whitespace that might cause JSON parsing issues
+        content = content.trim();
+        // Check if file is empty
+        if (content.length === 0) {
+            throw new Error(`File is empty: ${filePath}`);
+        }
+        return content;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw error;
+        }
+        throw new Error(`Failed to read file ${filePath}: ${error}`);
+    }
+}
+/**
+ * Read and parse a JSON file with comprehensive error handling
+ */
+export async function readJsonFile(filePath) {
+    try {
+        const content = await readFile(filePath);
+        // Attempt to parse JSON
+        try {
+            const parsed = JSON.parse(content);
+            return parsed;
+        }
+        catch (parseError) {
+            // Provide helpful error message with context
+            const errorMessage = parseError.message;
+            const preview = content.substring(0, 100);
+            throw new Error(`Invalid JSON in ${path.basename(filePath)}: ${errorMessage}\n` +
+                `Preview: ${preview}${content.length > 100 ? "..." : ""}`);
+        }
+    }
+    catch (error) {
+        throw error;
+    }
+}
+/**
+ * Write content to a file
+ */
+export async function writeFile(filePath, content) {
+    try {
+        // Ensure parent directory exists
+        const dir = path.dirname(filePath);
+        await ensureDir(dir);
+        // Write with UTF-8 encoding, no BOM
+        await fs.writeFile(filePath, content, { encoding: "utf-8" });
+    }
+    catch (error) {
+        throw new Error(`Failed to write file ${filePath}: ${error.message}`);
+    }
+}
+/**
+ * Write content to a file only if it doesn't exist or force is true
+ */
+export async function writeFileSafe(filePath, content, force = false) {
+    try {
+        const exists = await fileExists(filePath);
+        if (exists && !force) {
+            logger.warn(`File already exists, skipping: ${filePath}`);
+            return false;
+        }
+        await writeFile(filePath, content);
+        return true;
+    }
+    catch (error) {
+        throw new Error(`Failed to write file ${filePath}: ${error.message}`);
+    }
+}
+/**
+ * Write JSON to a file with pretty formatting
+ */
+export async function writeJsonFile(filePath, data, force = false) {
+    try {
+        const exists = await fileExists(filePath);
+        if (exists && !force) {
+            throw new Error(`File already exists: ${filePath}. Use --force to overwrite.`);
+        }
+        const content = JSON.stringify(data, null, 2) + "\n";
+        await writeFile(filePath, content);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw error;
+        }
+        throw new Error(`Failed to write JSON file ${filePath}: ${error}`);
+    }
+}
+/**
+ * Copy a file from source to destination
+ */
+export async function copyFile(src, dest) {
+    try {
+        if (!(await fileExists(src))) {
+            throw new Error(`Source file not found: ${src}`);
+        }
+        // Ensure destination directory exists
+        const destDir = path.dirname(dest);
+        await ensureDir(destDir);
+        await fs.copyFile(src, dest);
+    }
+    catch (error) {
+        throw new Error(`Failed to copy file from ${src} to ${dest}: ${error.message}`);
+    }
+}
+/**
+ * Copy a file only if destination doesn't exist or force is true
+ */
+export async function copyFileSafe(src, dest, force = false) {
+    try {
+        const exists = await fileExists(dest);
+        if (exists && !force) {
+            logger.warn(`File already exists, skipping: ${dest}`);
+            return false;
+        }
+        await copyFile(src, dest);
+        return true;
+    }
+    catch (error) {
+        throw new Error(`Failed to copy file from ${src} to ${dest}: ${error.message}`);
+    }
+}
+/**
+ * Delete a file
+ */
+export async function deleteFile(filePath) {
+    try {
+        if (await fileExists(filePath)) {
+            await fs.unlink(filePath);
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to delete file ${filePath}: ${error.message}`);
+    }
+}
+/**
+ * Delete a directory recursively
+ */
+export async function deleteDirectory(dirPath) {
+    try {
+        if (await directoryExists(dirPath)) {
+            await fs.rm(dirPath, { recursive: true, force: true });
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to delete directory ${dirPath}: ${error.message}`);
+    }
+}
+/**
+ * List files in a directory
+ */
+export async function listFiles(dirPath, options) {
+    try {
+        if (!(await directoryExists(dirPath))) {
+            return [];
+        }
+        const files = [];
+        const entries = await fs.readdir(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dirPath, entry.name);
+            if (entry.isDirectory() && options?.recursive) {
+                const subFiles = await listFiles(fullPath, options);
+                files.push(...subFiles);
+            }
+            else if (entry.isFile()) {
+                if (options?.extension) {
+                    if (entry.name.endsWith(options.extension)) {
+                        files.push(fullPath);
+                    }
+                }
+                else {
+                    files.push(fullPath);
+                }
+            }
+        }
+        return files;
+    }
+    catch (error) {
+        throw new Error(`Failed to list files in ${dirPath}: ${error.message}`);
+    }
+}
+/**
+ * Get file stats
+ */
+export async function getFileStats(filePath) {
+    try {
+        return await fs.stat(filePath);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if path is a file
+ */
+export async function isFile(filePath) {
+    try {
+        const stat = await fs.stat(filePath);
+        return stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if path is a directory
+ */
+export async function isDirectory(dirPath) {
+    return directoryExists(dirPath);
+}
+/**
+ * Read package.json with validation
+ */
+export async function readPackageJson(cwd) {
+    const packageJsonPath = path.join(cwd, "package.json");
+    try {
+        const packageJson = await readJsonFile(packageJsonPath);
+        // Validate it's actually a package.json
+        if (!packageJson.name) {
+            throw new Error("Invalid package.json: missing 'name' field");
+        }
+        return packageJson;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to read package.json: ${error.message}`);
+        }
+        throw error;
+    }
+}
+/**
+ * Update package.json dependencies
+ */
+export async function updatePackageJsonDependencies(cwd, dependencies, dev = false) {
+    try {
+        const packageJson = await readPackageJson(cwd);
+        const depKey = dev ? "devDependencies" : "dependencies";
+        packageJson[depKey] = {
+            ...packageJson[depKey],
+            ...dependencies,
+        };
+        const packageJsonPath = path.join(cwd, "package.json");
+        await writeJsonFile(packageJsonPath, packageJson, true);
+    }
+    catch (error) {
+        throw new Error(`Failed to update package.json: ${error.message}`);
+    }
+}
 //# sourceMappingURL=fs.js.map

package/dist/lib/highlighter.d.ts

@@ -1,6 +1,6 @@
-export declare const highlighter: {
-    error: typeof import("kleur/colors").print;
-    warn: typeof import("kleur/colors").print;
-    info: typeof import("kleur/colors").print;
-    success: typeof import("kleur/colors").print;
-};
+export declare const highlighter: {
+    error: typeof import("kleur/colors").print;
+    warn: typeof import("kleur/colors").print;
+    info: typeof import("kleur/colors").print;
+    success: typeof import("kleur/colors").print;
+};

package/dist/lib/highlighter.js

@@ -1,8 +1,8 @@
-import { cyan, green, red, yellow } from "kleur/colors";
-export const highlighter = {
-    error: red,
-    warn: yellow,
-    info: cyan,
-    success: green,
-};
+import { cyan, green, red, yellow } from "kleur/colors";
+export const highlighter = {
+    error: red,
+    warn: yellow,
+    info: cyan,
+    success: green,
+};
 //# sourceMappingURL=highlighter.js.map

package/dist/lib/install.d.ts

@@ -1,19 +1,19 @@
-import type { TrixUIConfig } from "./config.js";
-import { type LockfileComponent } from "./lockfile.js";
-import { type RegistryItem } from "./registry.js";
-export type InstallSummary = {
-    installed: string[];
-    skipped: string[];
-    npmDependencies: Set<string>;
-};
-type InstallOptions = {
-    cwd: string;
-    config: TrixUIConfig;
-    entries: RegistryItem[];
-    names: string[];
-    lockEntries: Record<string, LockfileComponent>;
-    force: boolean;
-    itemLabel: string;
-};
-export declare function installRegistryEntries(options: InstallOptions): Promise<InstallSummary>;
-export {};
+import type { TrixUIConfig } from "./config.js";
+import { type LockfileComponent } from "./lockfile.js";
+import { type RegistryItem } from "./registry.js";
+export type InstallSummary = {
+    installed: string[];
+    skipped: string[];
+    npmDependencies: Set<string>;
+};
+type InstallOptions = {
+    cwd: string;
+    config: TrixUIConfig;
+    entries: RegistryItem[];
+    names: string[];
+    lockEntries: Record<string, LockfileComponent>;
+    force: boolean;
+    itemLabel: string;
+};
+export declare function installRegistryEntries(options: InstallOptions): Promise<InstallSummary>;
+export {};