@fluffjs/cli 0.1.3 → 0.1.4

package/Cli.d.ts

@@ -26,6 +26,10 @@ export declare class Cli {
     private findFiles;
     private matchesPatterns;
     private matchGlob;
+    private copyAssets;
+    private copyAssetsForServe;
+    private copyDirectoryRecursive;
+    private copyDirectoryRecursiveSync;
     static parseArgs(argv: string[]): {
         options: CliOptions;
         args: string[];

package/Cli.js

@@ -403,34 +403,7 @@ Examples:
             }
         }
         if (target.assets) {
-            const compiler = new ComponentCompiler();
-            const assetFiles = this.findFiles(srcDir, target.assets);
-            for (const filePath of assetFiles) {
-                if (filePath.endsWith('.component.ts'))
-                    continue;
-                if (filePath.endsWith('.component.html'))
-                    continue;
-                if (filePath.endsWith('.component.css'))
-                    continue;
-                if (target.indexHtml && filePath.endsWith(target.indexHtml))
-                    continue;
-                const relativePath = path.relative(srcDir, filePath);
-                const outPath = path.join(outDir, relativePath);
-                const outFileDir = path.dirname(outPath);
-                if (!fs.existsSync(outFileDir)) {
-                    fs.mkdirSync(outFileDir, { recursive: true });
-                }
-                if (filePath.endsWith('.ts')) {
-                    let content = fs.readFileSync(filePath, 'utf-8');
-                    content = await compiler.stripTypeScript(content, filePath);
-                    fs.writeFileSync(outPath.replace('.ts', '.js'), content);
-                    console.log(`   ✓ Processed ${relativePath}`);
-                }
-                else {
-                    fs.copyFileSync(filePath, outPath);
-                    console.log(`   ✓ Copied ${relativePath}`);
-                }
-            }
+            await this.copyAssets(target.assets, projectRoot, srcDir, outDir);
         }
         console.log(`✅ Target '${target.name}' built successfully!`);
     }
@@ -541,26 +514,7 @@ Examples:
             }
         }
         if (target.assets) {
-            const assetFiles = this.findFiles(srcDir, target.assets);
-            for (const filePath of assetFiles) {
-                if (filePath.endsWith('.component.ts'))
-                    continue;
-                if (filePath.endsWith('.component.html'))
-                    continue;
-                if (filePath.endsWith('.component.css'))
-                    continue;
-                if (target.indexHtml && filePath.endsWith(target.indexHtml))
-                    continue;
-                if (filePath.endsWith('.ts'))
-                    continue;
-                const relativePath = path.relative(srcDir, filePath);
-                const outPath = path.join(outDir, relativePath);
-                const outFileDir = path.dirname(outPath);
-                if (!fs.existsSync(outFileDir)) {
-                    fs.mkdirSync(outFileDir, { recursive: true });
-                }
-                fs.copyFileSync(filePath, outPath);
-            }
+            this.copyAssetsForServe(target.assets, projectRoot, srcDir, outDir);
         }
         console.log(`🚀 Starting dev server for '${target.name}'...`);
         const tsconfigRaw = target.tsConfigPath
@@ -623,7 +577,7 @@ Examples:
                 }
                 else if (entry.isFile()) {
                     const relativePath = path.relative(dir, fullPath);
-                    if (this.matchesPatterns(relativePath, patterns)) {
+                    if (this.matchesPatterns(relativePath, patterns, dir)) {
                         files.push(fullPath);
                     }
                 }
@@ -632,9 +586,17 @@ Examples:
         walk(dir);
         return files;
     }
-    matchesPatterns(filePath, patterns) {
+    matchesPatterns(filePath, patterns, baseDir) {
         for (const pattern of patterns) {
-            if (this.matchGlob(filePath, pattern)) {
+            const patternPath = path.join(baseDir, pattern);
+            if (fs.existsSync(patternPath) && fs.statSync(patternPath).isDirectory()) {
+                const normalizedFile = filePath.replace(/\\/g, '/');
+                const normalizedPattern = pattern.replace(/\\/g, '/');
+                if (normalizedFile.startsWith(normalizedPattern + '/') || normalizedFile === normalizedPattern) {
+                    return true;
+                }
+            }
+            else if (this.matchGlob(filePath, pattern)) {
                 return true;
             }
         }
@@ -645,6 +607,116 @@ Examples:
         const isMatch = picomatch(pattern, { dot: false });
         return isMatch(normalizedPath);
     }
+    async copyAssets(assets, projectRoot, srcDir, outDir) {
+        const compiler = new ComponentCompiler();
+        for (const asset of assets) {
+            const assetPath = path.resolve(srcDir, asset);
+            if (fs.existsSync(assetPath) && fs.statSync(assetPath).isDirectory()) {
+                const dirName = path.basename(assetPath);
+                const targetDir = path.join(outDir, dirName);
+                await this.copyDirectoryRecursive(assetPath, targetDir, compiler);
+                console.log(`   ✓ Copied directory ${dirName}/`);
+            }
+            else {
+                const files = this.findFiles(srcDir, [asset]);
+                for (const filePath of files) {
+                    if (filePath.endsWith('.component.ts'))
+                        continue;
+                    if (filePath.endsWith('.component.html'))
+                        continue;
+                    if (filePath.endsWith('.component.css'))
+                        continue;
+                    const relativePath = path.relative(srcDir, filePath);
+                    const outPath = path.join(outDir, relativePath);
+                    const outFileDir = path.dirname(outPath);
+                    if (!fs.existsSync(outFileDir)) {
+                        fs.mkdirSync(outFileDir, { recursive: true });
+                    }
+                    if (filePath.endsWith('.ts')) {
+                        let content = fs.readFileSync(filePath, 'utf-8');
+                        content = await compiler.stripTypeScript(content, filePath);
+                        fs.writeFileSync(outPath.replace('.ts', '.js'), content);
+                        console.log(`   ✓ Processed ${relativePath}`);
+                    }
+                    else {
+                        fs.copyFileSync(filePath, outPath);
+                        console.log(`   ✓ Copied ${relativePath}`);
+                    }
+                }
+            }
+        }
+    }
+    copyAssetsForServe(assets, projectRoot, srcDir, outDir) {
+        for (const asset of assets) {
+            const assetPath = path.resolve(srcDir, asset);
+            if (fs.existsSync(assetPath) && fs.statSync(assetPath).isDirectory()) {
+                const dirName = path.basename(assetPath);
+                const targetDir = path.join(outDir, dirName);
+                this.copyDirectoryRecursiveSync(assetPath, targetDir);
+            }
+            else {
+                const files = this.findFiles(srcDir, [asset]);
+                for (const filePath of files) {
+                    if (filePath.endsWith('.component.ts'))
+                        continue;
+                    if (filePath.endsWith('.component.html'))
+                        continue;
+                    if (filePath.endsWith('.component.css'))
+                        continue;
+                    if (filePath.endsWith('.ts'))
+                        continue;
+                    const relativePath = path.relative(srcDir, filePath);
+                    const outPath = path.join(outDir, relativePath);
+                    const outFileDir = path.dirname(outPath);
+                    if (!fs.existsSync(outFileDir)) {
+                        fs.mkdirSync(outFileDir, { recursive: true });
+                    }
+                    fs.copyFileSync(filePath, outPath);
+                }
+            }
+        }
+    }
+    async copyDirectoryRecursive(srcPath, destPath, compiler) {
+        if (!fs.existsSync(destPath)) {
+            fs.mkdirSync(destPath, { recursive: true });
+        }
+        const entries = fs.readdirSync(srcPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const srcEntry = path.join(srcPath, entry.name);
+            const destEntry = path.join(destPath, entry.name);
+            if (entry.isDirectory()) {
+                await this.copyDirectoryRecursive(srcEntry, destEntry, compiler);
+            }
+            else if (entry.isFile()) {
+                if (srcEntry.endsWith('.ts')) {
+                    let content = fs.readFileSync(srcEntry, 'utf-8');
+                    content = await compiler.stripTypeScript(content, srcEntry);
+                    fs.writeFileSync(destEntry.replace('.ts', '.js'), content);
+                }
+                else {
+                    fs.copyFileSync(srcEntry, destEntry);
+                }
+            }
+        }
+    }
+    copyDirectoryRecursiveSync(srcPath, destPath) {
+        if (!fs.existsSync(destPath)) {
+            fs.mkdirSync(destPath, { recursive: true });
+        }
+        const entries = fs.readdirSync(srcPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const srcEntry = path.join(srcPath, entry.name);
+            const destEntry = path.join(destPath, entry.name);
+            if (entry.isDirectory()) {
+                this.copyDirectoryRecursiveSync(srcEntry, destEntry);
+            }
+            else if (entry.isFile()) {
+                if (!srcEntry.endsWith('.ts')) {
+                    fs.copyFileSync(srcEntry, destEntry);
+                }
+            }
+        }
+    }
     static parseArgs(argv) {
         const options = {};
         const args = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluffjs/cli",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "type": "module",
   "main": "./index.js",
   "module": "./index.js",