@fluffjs/cli 0.1.2 → 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

@@ -328,6 +328,9 @@ Examples:
             }
         }
         console.log('   Building with esbuild...');
+        const tsconfigRaw = target.tsConfigPath
+            ? fs.readFileSync(path.resolve(projectRoot, target.tsConfigPath), 'utf-8')
+            : '{}';
         const result = await esbuild.build({
             entryPoints: [entryPoint],
             bundle: true,
@@ -350,7 +353,7 @@ Examples:
             ],
             external: bundleOptions.external ?? [],
             logLevel: 'warning',
-            tsconfigRaw: '{}'
+            tsconfigRaw
         });
         const outputs = Object.keys(result.metafile?.outputs ?? {});
         const jsBundle = outputs.find(f => f.endsWith('.js'));
@@ -400,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!`);
     }
@@ -538,28 +514,12 @@ 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
+            ? fs.readFileSync(path.resolve(projectRoot, target.tsConfigPath), 'utf-8')
+            : '{}';
         const ctx = await esbuild.context({
             entryPoints: [entryPoint],
             bundle: true,
@@ -580,7 +540,8 @@ Examples:
                     production: false
                 })
             ],
-            logLevel: 'info'
+            logLevel: 'info',
+            tsconfigRaw
         });
         await ctx.watch();
         console.log('   Watching for changes...');
@@ -616,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);
                     }
                 }
@@ -625,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;
             }
         }
@@ -638,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/Generator.js

@@ -128,6 +128,7 @@ export class Generator {
                     srcDir: 'src',
                     outDir: 'dist',
                     componentsDir: 'app',
+                    tsConfigPath: 'tsconfig.json',
                     entryPoint: 'main.ts',
                     indexHtml: 'index.html',
                     components: ['**/*.component.ts'],

package/interfaces/FluffTarget.d.ts

@@ -5,6 +5,7 @@ export interface FluffTarget {
     srcDir: string;
     outDir: string;
     componentsDir?: string;
+    tsConfigPath?: string;
     entryPoint?: string;
     indexHtml?: string;
     components: string[];

package/package.json

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