@git.zone/tswatch 2.3.12 → 3.0.0

package/dist_ts/tswatch.classes.tswatch.js

@@ -2,184 +2,154 @@ import * as plugins from './tswatch.plugins.js';
 import * as paths from './tswatch.paths.js';
 import * as interfaces from './interfaces/index.js';
 import { Watcher } from './tswatch.classes.watcher.js';
+import { ConfigHandler } from './tswatch.classes.confighandler.js';
 import { logger } from './tswatch.logging.js';
-// Create smartfs instance for directory operations
-const smartfs = new plugins.smartfs.SmartFs(new plugins.smartfs.SmartFsProviderNode());
 /**
- * Lists all folders in a directory
+ * TsWatch - Config-driven file watcher
+ *
+ * Reads configuration from npmextra.json under the key '@git.zone/tswatch'
+ * and sets up watchers, bundles, and dev server accordingly.
  */
-const listFolders = async (dirPath) => {
-    const entries = await smartfs.directory(dirPath).list();
-    return entries
-        .filter((entry) => entry.isDirectory)
-        .map((entry) => entry.name);
-};
 export class TsWatch {
-    constructor(watchmodeArg) {
+    constructor(configArg) {
         this.watcherMap = new plugins.lik.ObjectMap();
-        this.watchmode = watchmodeArg;
+        this.typedserver = null;
+        this.tsbundle = new plugins.tsbundle.TsBundle();
+        this.htmlHandler = new plugins.tsbundle.HtmlHandler();
+        this.assetsHandler = new plugins.tsbundle.AssetsHandler();
+        this.config = configArg;
+    }
+    /**
+     * Create TsWatch from npmextra.json configuration
+     */
+    static fromConfig(cwdArg) {
+        const configHandler = new ConfigHandler(cwdArg);
+        const config = configHandler.loadConfig();
+        if (!config) {
+            return null;
+        }
+        return new TsWatch(config);
     }
     /**
      * starts the TsWatch instance
      */
     async start() {
-        const tsbundle = new plugins.tsbundle.TsBundle();
-        const assetsHandler = new plugins.tsbundle.AssetsHandler();
-        const htmlHandler = new plugins.tsbundle.HtmlHandler();
-        switch (this.watchmode) {
-            case 'test':
-                /**
-                 * this strategy runs test whenever there is a change in the ts directory
-                 */
-                this.watcherMap.add(new Watcher({
-                    filePathToWatch: paths.cwd,
-                    commandToExecute: 'npm run test2',
-                    timeout: null,
-                }));
-                break;
-            case 'node':
-                this.watcherMap.add(new Watcher({
-                    filePathToWatch: paths.cwd,
-                    commandToExecute: 'npm run test',
-                    timeout: null,
-                }));
-                break;
-            case 'element':
-                await (async () => {
-                    /**
-                     * this strategy runs a standard server and bundles the ts files to a dist_watch directory
-                     */
-                    // lets create a standard server
-                    logger.log('info', 'bundling TypeScript files to "dist_watch" Note: This is for development only!');
-                    this.typedserver = new plugins.typedserver.TypedServer({
-                        cors: true,
-                        injectReload: true,
-                        serveDir: plugins.path.join(paths.cwd, './dist_watch/'),
-                        port: 3002,
-                        compression: true,
-                        spaFallback: true,
-                        securityHeaders: {
-                            crossOriginOpenerPolicy: 'same-origin',
-                            crossOriginEmbedderPolicy: 'require-corp',
-                        },
-                    });
-                    const bundleAndReloadElement = async () => {
-                        await tsbundle.build(paths.cwd, './html/index.ts', './dist_watch/bundle.js', {
-                            bundler: 'esbuild',
-                        });
-                        await this.typedserver.reload();
-                    };
-                    this.watcherMap.add(new Watcher({
-                        filePathToWatch: plugins.path.join(paths.cwd, './ts_web/'),
-                        functionToCall: async () => {
-                            await bundleAndReloadElement();
-                        },
-                        timeout: null,
-                    }));
-                    // lets get the other ts folders
-                    let tsfolders = await listFolders(paths.cwd);
-                    tsfolders = tsfolders.filter((itemArg) => itemArg.startsWith('ts') && itemArg !== 'ts_web');
-                    const smartshellInstance = new plugins.smartshell.Smartshell({
-                        executor: 'bash',
-                    });
-                    for (const tsfolder of tsfolders) {
-                        logger.log('info', `creating watcher for folder ${tsfolder}`);
-                        this.watcherMap.add(new Watcher({
-                            filePathToWatch: plugins.path.join(paths.cwd, `./${tsfolder}/`),
-                            functionToCall: async () => {
-                                logger.log('info', `building ${tsfolder}`);
-                                await smartshellInstance.exec(`(cd ${paths.cwd} && npm run build)`);
-                                await bundleAndReloadElement();
-                            },
-                            timeout: null,
-                        }));
-                    }
-                    this.watcherMap.add(new Watcher({
-                        filePathToWatch: plugins.path.join(paths.cwd, './html/'),
-                        functionToCall: async () => {
-                            await htmlHandler.processHtml({
-                                from: plugins.path.join(paths.cwd, './html/index.html'),
-                                to: plugins.path.join(paths.cwd, './dist_watch/index.html'),
-                                minify: false,
-                            });
-                            await bundleAndReloadElement();
-                        },
-                        timeout: null,
-                    }));
-                })();
-                break;
-            case 'website':
-                await (async () => {
-                    const websiteExecution = new plugins.smartshell.SmartExecution('npm run startTs');
-                    const bundleAndReloadWebsite = async () => {
-                        await tsbundle.build(paths.cwd, './ts_web/index.ts', './dist_serve/bundle.js', {
-                            bundler: 'esbuild',
-                        });
-                    };
-                    let tsfolders = await listFolders(paths.cwd);
-                    tsfolders = tsfolders.filter((itemArg) => itemArg.startsWith('ts') && itemArg !== 'ts_web');
-                    for (const tsfolder of tsfolders) {
-                        this.watcherMap.add(new Watcher({
-                            filePathToWatch: plugins.path.join(paths.cwd, `./${tsfolder}/`),
-                            functionToCall: async () => {
-                                await websiteExecution.restart();
-                                await bundleAndReloadWebsite();
-                            },
-                            timeout: null,
-                        }));
-                    }
-                    this.watcherMap.add(new Watcher({
-                        filePathToWatch: plugins.path.join(paths.cwd, './ts_web/'),
-                        functionToCall: async () => {
-                            await bundleAndReloadWebsite();
-                        },
-                        timeout: null,
-                    }));
-                    this.watcherMap.add(new Watcher({
-                        filePathToWatch: plugins.path.join(paths.cwd, './html/'),
-                        functionToCall: async () => {
-                            await htmlHandler.processHtml({
-                                from: plugins.path.join(paths.cwd, './html/index.html'),
-                                to: plugins.path.join(paths.cwd, './dist_serve/index.html'),
-                                minify: false,
-                            });
-                            await bundleAndReloadWebsite();
-                        },
-                        timeout: null,
-                    }));
-                    this.watcherMap.add(new Watcher({
-                        filePathToWatch: plugins.path.join(paths.cwd, './assets/'),
-                        functionToCall: async () => {
-                            await assetsHandler.processAssets();
-                            await bundleAndReloadWebsite();
-                        },
-                        timeout: null,
-                    }));
-                })();
-                break;
-            case 'service':
-                this.watcherMap.add(new Watcher({
-                    filePathToWatch: plugins.path.join(paths.cwd, './ts/'),
-                    commandToExecute: 'npm run startTs',
-                    timeout: null,
-                }));
-                break;
-            case 'echo':
-                const tsWatchInstanceEchoSomething = new Watcher({
-                    filePathToWatch: plugins.path.join(paths.cwd, './ts'),
-                    commandToExecute: 'npm -v',
-                    timeout: null,
-                });
-                this.watcherMap.add(tsWatchInstanceEchoSomething);
-                break;
-            default:
-                break;
+        logger.log('info', 'Starting tswatch with config-driven mode');
+        // Start server if configured
+        if (this.config.server?.enabled) {
+            await this.startServer();
         }
-        this.watcherMap.forEach(async (watcher) => {
+        // Setup bundles and their watchers
+        if (this.config.bundles && this.config.bundles.length > 0) {
+            await this.setupBundles();
+        }
+        // Setup watchers from config
+        if (this.config.watchers && this.config.watchers.length > 0) {
+            await this.setupWatchers();
+        }
+        // Start all watchers
+        await this.watcherMap.forEach(async (watcher) => {
             await watcher.start();
         });
+        // Start server after watchers are ready
         if (this.typedserver) {
             await this.typedserver.start();
+            logger.log('ok', `Dev server started on port ${this.config.server?.port || 3002}`);
+        }
+    }
+    /**
+     * Start the development server
+     */
+    async startServer() {
+        const serverConfig = this.config.server;
+        const port = serverConfig.port || 3002;
+        const serveDir = serverConfig.serveDir || './dist_watch/';
+        logger.log('info', `Setting up dev server on port ${port}, serving ${serveDir}`);
+        this.typedserver = new plugins.typedserver.TypedServer({
+            cors: true,
+            injectReload: serverConfig.liveReload !== false,
+            serveDir: plugins.path.join(paths.cwd, serveDir),
+            port: port,
+            compression: true,
+            spaFallback: true,
+            securityHeaders: {
+                crossOriginOpenerPolicy: 'same-origin',
+                crossOriginEmbedderPolicy: 'require-corp',
+            },
+        });
+    }
+    /**
+     * Setup bundle watchers
+     */
+    async setupBundles() {
+        for (const bundleConfig of this.config.bundles) {
+            const name = bundleConfig.name || `bundle-${bundleConfig.from}`;
+            logger.log('info', `Setting up bundle: ${name}`);
+            // Determine what patterns to watch
+            const watchPatterns = bundleConfig.watchPatterns || [
+                plugins.path.dirname(bundleConfig.from) + '/**/*',
+            ];
+            // Create the bundle function
+            const bundleFunction = async () => {
+                logger.log('info', `[${name}] bundling...`);
+                // Determine bundle type based on file extension
+                const fromPath = bundleConfig.from;
+                const toPath = bundleConfig.to;
+                if (fromPath.endsWith('.html')) {
+                    // HTML processing
+                    await this.htmlHandler.processHtml({
+                        from: plugins.path.join(paths.cwd, fromPath),
+                        to: plugins.path.join(paths.cwd, toPath),
+                        minify: false,
+                    });
+                }
+                else if (fromPath.endsWith('/') || !fromPath.includes('.')) {
+                    // Assets directory copy
+                    await this.assetsHandler.processAssets();
+                }
+                else {
+                    // TypeScript bundling
+                    await this.tsbundle.build(paths.cwd, fromPath, toPath, {
+                        bundler: 'esbuild',
+                    });
+                }
+                logger.log('ok', `[${name}] bundle complete`);
+                // Trigger reload if configured and server is running
+                if (bundleConfig.triggerReload !== false && this.typedserver) {
+                    await this.typedserver.reload();
+                }
+            };
+            // Run initial bundle
+            await bundleFunction();
+            // Create watcher for this bundle
+            this.watcherMap.add(new Watcher({
+                name: name,
+                filePathToWatch: watchPatterns.map((p) => plugins.path.join(paths.cwd, p)),
+                functionToCall: bundleFunction,
+                runOnStart: false, // Already ran above
+                debounce: 300,
+            }));
+        }
+    }
+    /**
+     * Setup watchers from config
+     */
+    async setupWatchers() {
+        for (const watcherConfig of this.config.watchers) {
+            logger.log('info', `Setting up watcher: ${watcherConfig.name}`);
+            // Convert watch paths to absolute
+            const watchPaths = Array.isArray(watcherConfig.watch)
+                ? watcherConfig.watch
+                : [watcherConfig.watch];
+            const absolutePaths = watchPaths.map((p) => plugins.path.join(paths.cwd, p));
+            this.watcherMap.add(new Watcher({
+                name: watcherConfig.name,
+                filePathToWatch: absolutePaths,
+                commandToExecute: watcherConfig.command,
+                restart: watcherConfig.restart ?? true,
+                debounce: watcherConfig.debounce ?? 300,
+                runOnStart: watcherConfig.runOnStart ?? true,
+            }));
         }
     }
     /**
@@ -189,9 +159,9 @@ export class TsWatch {
         if (this.typedserver) {
             await this.typedserver.stop();
         }
-        this.watcherMap.forEach(async (watcher) => {
+        await this.watcherMap.forEach(async (watcher) => {
             await watcher.stop();
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tswatch.classes.tswatch.js","sourceRoot":"","sources":["../ts/tswatch.classes.tswatch.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/tswatch.classes.watcher.d.ts

@@ -1,8 +1,21 @@
+import * as interfaces from './interfaces/index.js';
 export interface IWatcherConstructorOptions {
-    filePathToWatch: string;
+    /** Name for this watcher (used in logging) */
+    name?: string;
+    /** Path(s) to watch - can be a single path or array */
+    filePathToWatch: string | string[];
+    /** Shell command to execute on changes */
     commandToExecute?: string;
+    /** Function to call on changes */
     functionToCall?: () => Promise<any>;
+    /** Timeout for the watcher */
     timeout?: number;
+    /** If true, kill previous process before restarting (default: true) */
+    restart?: boolean;
+    /** Debounce delay in ms (default: 300) */
+    debounce?: number;
+    /** If true, run the command immediately on start (default: true) */
+    runOnStart?: boolean;
 }
 /**
  * A watcher keeps track of one child execution
@@ -15,15 +28,30 @@ export declare class Watcher {
     private currentExecution;
     private smartwatchInstance;
     private options;
+    private debounceTimer;
+    private isExecuting;
+    private pendingExecution;
     constructor(optionsArg: IWatcherConstructorOptions);
+    /**
+     * Create a Watcher from config
+     */
+    static fromConfig(config: interfaces.IWatcherConfig): Watcher;
+    /**
+     * Get the watcher name for logging
+     */
+    private getName;
     /**
      * start the file
      */
     start(): Promise<void>;
     /**
-     * updates the current execution
+     * Handle file change with debouncing
+     */
+    private handleChange;
+    /**
+     * Execute the command or function
      */
-    private updateCurrentExecution;
+    private executeCommand;
     /**
      * this method sets up a clean exit strategy
      */

package/dist_ts/tswatch.classes.watcher.js

@@ -1,4 +1,5 @@
 import * as plugins from './tswatch.plugins.js';
+import * as interfaces from './interfaces/index.js';
 import { logger } from './tswatch.logging.js';
 /**
  * A watcher keeps track of one child execution
@@ -12,50 +13,126 @@ export class Watcher {
             executor: 'bash',
         });
         this.smartwatchInstance = new plugins.smartwatch.Smartwatch([]);
-        this.options = optionsArg;
+        this.debounceTimer = null;
+        this.isExecuting = false;
+        this.pendingExecution = false;
+        this.options = {
+            restart: true,
+            debounce: 300,
+            runOnStart: true,
+            ...optionsArg,
+        };
+    }
+    /**
+     * Create a Watcher from config
+     */
+    static fromConfig(config) {
+        const watchPaths = Array.isArray(config.watch) ? config.watch : [config.watch];
+        return new Watcher({
+            name: config.name,
+            filePathToWatch: watchPaths,
+            commandToExecute: config.command,
+            restart: config.restart ?? true,
+            debounce: config.debounce ?? 300,
+            runOnStart: config.runOnStart ?? true,
+        });
+    }
+    /**
+     * Get the watcher name for logging
+     */
+    getName() {
+        return this.options.name || 'unnamed';
     }
     /**
      * start the file
      */
     async start() {
-        logger.log('info', `trying to start watcher for ${this.options.filePathToWatch}`);
+        const name = this.getName();
+        logger.log('info', `[${name}] starting watcher`);
         await this.setupCleanup();
-        console.log(`Looking at ${this.options.filePathToWatch} for changes`);
-        // Convert directory path to glob pattern for smartwatch
-        const watchPath = this.options.filePathToWatch.endsWith('/')
-            ? `${this.options.filePathToWatch}**/*`
-            : `${this.options.filePathToWatch}/**/*`;
-        this.smartwatchInstance.add([watchPath]);
+        // Convert paths to glob patterns
+        const paths = Array.isArray(this.options.filePathToWatch)
+            ? this.options.filePathToWatch
+            : [this.options.filePathToWatch];
+        const watchPatterns = paths.map((p) => {
+            // Convert directory path to glob pattern for smartwatch
+            if (p.endsWith('/')) {
+                return `${p}**/*`;
+            }
+            // If it's already a glob pattern, use as-is
+            if (p.includes('*')) {
+                return p;
+            }
+            // Otherwise assume it's a directory
+            return `${p}/**/*`;
+        });
+        logger.log('info', `[${name}] watching patterns: ${watchPatterns.join(', ')}`);
+        this.smartwatchInstance.add(watchPatterns);
         await this.smartwatchInstance.start();
         const changeObservable = await this.smartwatchInstance.getObservableFor('change');
         changeObservable.subscribe(() => {
-            this.updateCurrentExecution();
+            this.handleChange();
         });
-        await this.updateCurrentExecution();
-        logger.log('info', `watcher started for ${this.options.filePathToWatch}`);
+        // Run on start if configured
+        if (this.options.runOnStart) {
+            await this.executeCommand();
+        }
+        logger.log('info', `[${name}] watcher started`);
     }
     /**
-     * updates the current execution
+     * Handle file change with debouncing
      */
-    async updateCurrentExecution() {
+    handleChange() {
+        const name = this.getName();
+        // Clear existing debounce timer
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+        }
+        // Set new debounce timer
+        this.debounceTimer = setTimeout(async () => {
+            this.debounceTimer = null;
+            // If currently executing and not in restart mode, mark pending
+            if (this.isExecuting && !this.options.restart) {
+                logger.log('info', `[${name}] change detected, queuing execution`);
+                this.pendingExecution = true;
+                return;
+            }
+            await this.executeCommand();
+            // If there was a pending execution, run it
+            if (this.pendingExecution) {
+                this.pendingExecution = false;
+                await this.executeCommand();
+            }
+        }, this.options.debounce);
+    }
+    /**
+     * Execute the command or function
+     */
+    async executeCommand() {
+        const name = this.getName();
         if (this.options.commandToExecute) {
-            if (this.currentExecution) {
-                logger.log('ok', `reexecuting ${this.options.commandToExecute}`);
+            if (this.currentExecution && this.options.restart) {
+                logger.log('ok', `[${name}] restarting: ${this.options.commandToExecute}`);
                 this.currentExecution.kill();
             }
-            else {
-                logger.log('ok', `executing ${this.options.commandToExecute} for the first time`);
+            else if (!this.currentExecution) {
+                logger.log('ok', `[${name}] executing: ${this.options.commandToExecute}`);
             }
+            this.isExecuting = true;
             this.currentExecution = await this.smartshellInstance.execStreaming(this.options.commandToExecute);
-        }
-        else {
-            console.log('no executionCommand set');
+            // Track when execution completes
+            this.currentExecution.childProcess.on('exit', () => {
+                this.isExecuting = false;
+            });
         }
         if (this.options.functionToCall) {
-            this.options.functionToCall();
-        }
-        else {
-            console.log('no functionToCall set.');
+            this.isExecuting = true;
+            try {
+                await this.options.functionToCall();
+            }
+            finally {
+                this.isExecuting = false;
+            }
         }
     }
     /**
@@ -87,10 +164,13 @@ export class Watcher {
      * stops the watcher
      */
     async stop() {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+        }
         await this.smartwatchInstance.stop();
         if (this.currentExecution && !this.currentExecution.childProcess.killed) {
             this.currentExecution.kill();
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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