diff --git a/dist_ts/index.d.ts b/dist_ts/index.d.ts new file mode 100644 index 0000000..e09c5c6 --- /dev/null +++ b/dist_ts/index.d.ts @@ -0,0 +1,2 @@ +export * from './tswatch.classes.tswatch'; +import './tswatch.cli'; diff --git a/dist_ts/index.js b/dist_ts/index.js new file mode 100644 index 0000000..ff72164 --- /dev/null +++ b/dist_ts/index.js @@ -0,0 +1,18 @@ +"use strict"; +function __export(m) { + for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p]; +} +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; + result["default"] = mod; + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const early = __importStar(require("@pushrocks/early")); +early.start('tswatch'); +__export(require("./tswatch.classes.tswatch")); +require("./tswatch.cli"); +early.stop(); +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFBQSx3REFBMEM7QUFDMUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxTQUFTLENBQUMsQ0FBQztBQUN2QiwrQ0FBMEM7QUFDMUMseUJBQXVCO0FBQ3ZCLEtBQUssQ0FBQyxJQUFJLEVBQUUsQ0FBQyJ9 \ No newline at end of file diff --git a/dist_ts/interfaces/index.d.ts b/dist_ts/interfaces/index.d.ts new file mode 100644 index 0000000..d7457dd --- /dev/null +++ b/dist_ts/interfaces/index.d.ts @@ -0,0 +1 @@ +export * from './interfaces.watchmodes'; diff --git a/dist_ts/interfaces/index.js b/dist_ts/interfaces/index.js new file mode 100644 index 0000000..7e5f8f6 --- /dev/null +++ b/dist_ts/interfaces/index.js @@ -0,0 +1,3 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9pbnRlcmZhY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ== \ No newline at end of file diff --git a/dist_ts/interfaces/interfaces.watchmodes.d.ts b/dist_ts/interfaces/interfaces.watchmodes.d.ts new file mode 100644 index 0000000..382e32e --- /dev/null +++ b/dist_ts/interfaces/interfaces.watchmodes.d.ts @@ -0,0 +1 @@ +export declare type TWatchModes = 'test' | 'gitzone_npm' | 'gitzone_service' | 'gitzone_element' | 'gitzone_website' | 'echoSomething'; diff --git a/dist_ts/interfaces/interfaces.watchmodes.js b/dist_ts/interfaces/interfaces.watchmodes.js new file mode 100644 index 0000000..73e0fd7 --- /dev/null +++ b/dist_ts/interfaces/interfaces.watchmodes.js @@ -0,0 +1,3 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy53YXRjaG1vZGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvaW50ZXJmYWNlcy9pbnRlcmZhY2VzLndhdGNobW9kZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9 \ No newline at end of file diff --git a/dist_ts/tswatch.classes.parcel.d.ts b/dist_ts/tswatch.classes.parcel.d.ts new file mode 100644 index 0000000..cb6be9d --- /dev/null +++ b/dist_ts/tswatch.classes.parcel.d.ts @@ -0,0 +1,3 @@ +export declare class Parcel { + start(): Promise; +} diff --git a/dist_ts/tswatch.classes.parcel.js b/dist_ts/tswatch.classes.parcel.js new file mode 100644 index 0000000..c3ec5b4 --- /dev/null +++ b/dist_ts/tswatch.classes.parcel.js @@ -0,0 +1,44 @@ +"use strict"; +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; + result["default"] = mod; + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const plugins = __importStar(require("./tswatch.plugins")); +const paths = __importStar(require("./tswatch.paths")); +class Parcel { + async start() { + const entryFiles = plugins.path.join(paths.cwd, './html/index.html'); + // Bundler options + const options = { + outDir: './dist_watch', + outFile: 'index.html', + publicUrl: '/', + watch: true, + cache: true, + cacheDir: '.nogit/.parcelcache', + contentHash: false, + global: 'moduleName', + minify: false, + scopeHoist: false, + target: 'browser', + bundleNodeModules: true, + https: null, + logLevel: 3, + hmr: true, + hmrPort: 3003, + sourceMaps: true, + hmrHostname: '', + detailedReport: false // Prints a detailed report of the bundles, assets, filesizes and times, defaults to false, reports are only printed if watch is disabled + }; + const bundler = new plugins.parcel(entryFiles, options); + // Run the bundler, this returns the main bundle + // Use the events if you're using watch mode as this promise will only trigger once and not for every rebuild + const bundle = await bundler.serve(3002); + } +} +exports.Parcel = Parcel; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHN3YXRjaC5jbGFzc2VzLnBhcmNlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3Rzd2F0Y2guY2xhc3Nlcy5wYXJjZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7O0FBQUEsMkRBQTZDO0FBQzdDLHVEQUF5QztBQUV6QyxNQUFhLE1BQU07SUFDVixLQUFLLENBQUMsS0FBSztRQUNoQixNQUFNLFVBQVUsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxFQUFFLG1CQUFtQixDQUFDLENBQUM7UUFFckUsa0JBQWtCO1FBQ2xCLE1BQU0sT0FBTyxHQUFpQztZQUM1QyxNQUFNLEVBQUUsY0FBYztZQUN0QixPQUFPLEVBQUUsWUFBWTtZQUNyQixTQUFTLEVBQUUsR0FBRztZQUNkLEtBQUssRUFBRSxJQUFJO1lBQ1gsS0FBSyxFQUFFLElBQUk7WUFDWCxRQUFRLEVBQUUscUJBQXFCO1lBQy9CLFdBQVcsRUFBRSxLQUFLO1lBQ2xCLE1BQU0sRUFBRSxZQUFZO1lBQ3BCLE1BQU0sRUFBRSxLQUFLO1lBQ2IsVUFBVSxFQUFFLEtBQUs7WUFDakIsTUFBTSxFQUFFLFNBQVM7WUFDakIsaUJBQWlCLEVBQUUsSUFBSTtZQUN2QixLQUFLLEVBQUUsSUFBSTtZQUNYLFFBQVEsRUFBRSxDQUFDO1lBQ1gsR0FBRyxFQUFFLElBQUk7WUFDVCxPQUFPLEVBQUUsSUFBSTtZQUNiLFVBQVUsRUFBRSxJQUFJO1lBQ2hCLFdBQVcsRUFBRSxFQUFFO1lBQ2YsY0FBYyxFQUFFLEtBQUssQ0FBQyx5SUFBeUk7U0FDaEssQ0FBQztRQUVGLE1BQU0sT0FBTyxHQUFHLElBQUksT0FBTyxDQUFDLE1BQU0sQ0FBQyxVQUFVLEVBQUUsT0FBTyxDQUFDLENBQUM7UUFFeEQsZ0RBQWdEO1FBQ2hELDZHQUE2RztRQUM3RyxNQUFNLE1BQU0sR0FBRyxNQUFNLE9BQU8sQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDM0MsQ0FBQztDQUNGO0FBakNELHdCQWlDQyJ9 \ No newline at end of file diff --git a/dist_ts/tswatch.classes.tswatch.d.ts b/dist_ts/tswatch.classes.tswatch.d.ts new file mode 100644 index 0000000..3ce9aa5 --- /dev/null +++ b/dist_ts/tswatch.classes.tswatch.d.ts @@ -0,0 +1,17 @@ +import * as plugins from './tswatch.plugins'; +import * as interfaces from './interfaces'; +import { Watcher } from './tswatch.classes.watcher'; +export declare class TsWatch { + watchmode: interfaces.TWatchModes; + watcherMap: plugins.lik.ObjectMap; + smartserve: plugins.smartserve.SmartServe; + constructor(watchmodeArg: interfaces.TWatchModes); + /** + * starts the TsWatch instance + */ + start(): Promise; + /** + * stops the execution of any active Watchers + */ + stop(): Promise; +} diff --git a/dist_ts/tswatch.classes.tswatch.js b/dist_ts/tswatch.classes.tswatch.js new file mode 100644 index 0000000..c221f2f --- /dev/null +++ b/dist_ts/tswatch.classes.tswatch.js @@ -0,0 +1,95 @@ +"use strict"; +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; + result["default"] = mod; + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const plugins = __importStar(require("./tswatch.plugins")); +const paths = __importStar(require("./tswatch.paths")); +const tswatch_classes_watcher_1 = require("./tswatch.classes.watcher"); +const tswatch_classes_parcel_1 = require("./tswatch.classes.parcel"); +class TsWatch { + constructor(watchmodeArg) { + this.watcherMap = new plugins.lik.ObjectMap(); + this.watchmode = watchmodeArg; + } + /** + * starts the TsWatch instance + */ + async start() { + switch (this.watchmode) { + case 'test': + this.watcherMap.add(new tswatch_classes_watcher_1.Watcher({ + filePathToWatch: paths.cwd, + commandToExecute: 'npm run test2', + timeout: null + })); + break; + case 'gitzone_npm': + this.watcherMap.add(new tswatch_classes_watcher_1.Watcher({ + filePathToWatch: paths.cwd, + commandToExecute: 'npm run test', + timeout: null + })); + break; + case 'gitzone_element': + // lets create a standard server + console.log('bundling TypeScript files to "dist_watch" Note: This is for development only!'); + const parcel = new tswatch_classes_parcel_1.Parcel(); + await parcel.start(); + break; + case 'gitzone_website': + this.watcherMap.add(new tswatch_classes_watcher_1.Watcher({ + filePathToWatch: plugins.path.join(paths.cwd, './ts/'), + commandToExecute: 'npm run startTs', + timeout: null + })); + // client directory + this.watcherMap.add(new tswatch_classes_watcher_1.Watcher({ + filePathToWatch: plugins.path.join(paths.cwd, './ts_web/'), + commandToExecute: 'npm run build', + timeout: null + })); + break; + case 'gitzone_service': + this.watcherMap.add(new tswatch_classes_watcher_1.Watcher({ + filePathToWatch: plugins.path.join(paths.cwd, './ts/'), + commandToExecute: 'npm run startTs', + timeout: null + })); + break; + case 'echoSomething': + const tsWatchInstanceEchoSomething = new tswatch_classes_watcher_1.Watcher({ + filePathToWatch: plugins.path.join(paths.cwd, './ts'), + commandToExecute: 'npm -v', + timeout: null + }); + this.watcherMap.add(tsWatchInstanceEchoSomething); + break; + default: + break; + } + this.watcherMap.forEach(async (watcher) => { + await watcher.start(); + }); + if (this.smartserve) { + await this.smartserve.start(); + } + } + /** + * stops the execution of any active Watchers + */ + async stop() { + if (this.smartserve) { + await this.smartserve.stop(); + } + this.watcherMap.forEach(async (watcher) => { + await watcher.stop(); + }); + } +} +exports.TsWatch = TsWatch; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHN3YXRjaC5jbGFzc2VzLnRzd2F0Y2guanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy90c3dhdGNoLmNsYXNzZXMudHN3YXRjaC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7QUFBQSwyREFBNkM7QUFDN0MsdURBQXlDO0FBR3pDLHVFQUFvRDtBQUNwRCxxRUFBa0Q7QUFFbEQsTUFBYSxPQUFPO0lBS2xCLFlBQVksWUFBb0M7UUFIekMsZUFBVSxHQUFHLElBQUksT0FBTyxDQUFDLEdBQUcsQ0FBQyxTQUFTLEVBQVcsQ0FBQztRQUl2RCxJQUFJLENBQUMsU0FBUyxHQUFHLFlBQVksQ0FBQztJQUNoQyxDQUFDO0lBRUQ7O09BRUc7SUFDSSxLQUFLLENBQUMsS0FBSztRQUNoQixRQUFRLElBQUksQ0FBQyxTQUFTLEVBQUU7WUFDdEIsS0FBSyxNQUFNO2dCQUNULElBQUksQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUNqQixJQUFJLGlDQUFPLENBQUM7b0JBQ1YsZUFBZSxFQUFFLEtBQUssQ0FBQyxHQUFHO29CQUMxQixnQkFBZ0IsRUFBRSxlQUFlO29CQUNqQyxPQUFPLEVBQUUsSUFBSTtpQkFDZCxDQUFDLENBQ0gsQ0FBQztnQkFDRixNQUFNO1lBQ1IsS0FBSyxhQUFhO2dCQUNoQixJQUFJLENBQUMsVUFBVSxDQUFDLEdBQUcsQ0FDakIsSUFBSSxpQ0FBTyxDQUFDO29CQUNWLGVBQWUsRUFBRSxLQUFLLENBQUMsR0FBRztvQkFDMUIsZ0JBQWdCLEVBQUUsY0FBYztvQkFDaEMsT0FBTyxFQUFFLElBQUk7aUJBQ2QsQ0FBQyxDQUNILENBQUM7Z0JBQ0YsTUFBTTtZQUNSLEtBQUssaUJBQWlCO2dCQUNwQixnQ0FBZ0M7Z0JBQ2hDLE9BQU8sQ0FBQyxHQUFHLENBQ1QsK0VBQStFLENBQ2hGLENBQUM7Z0JBQ0YsTUFBTSxNQUFNLEdBQUcsSUFBSSwrQkFBTSxFQUFFLENBQUM7Z0JBQzVCLE1BQU0sTUFBTSxDQUFDLEtBQUssRUFBRSxDQUFDO2dCQUNyQixNQUFNO1lBQ1IsS0FBSyxpQkFBaUI7Z0JBQ3BCLElBQUksQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUNqQixJQUFJLGlDQUFPLENBQUM7b0JBQ1YsZUFBZSxFQUFFLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLEVBQUUsT0FBTyxDQUFDO29CQUN0RCxnQkFBZ0IsRUFBRSxpQkFBaUI7b0JBQ25DLE9BQU8sRUFBRSxJQUFJO2lCQUNkLENBQUMsQ0FDSCxDQUFDO2dCQUVGLG1CQUFtQjtnQkFDbkIsSUFBSSxDQUFDLFVBQVUsQ0FBQyxHQUFHLENBQ2pCLElBQUksaUNBQU8sQ0FBQztvQkFDVixlQUFlLEVBQUUsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsRUFBRSxXQUFXLENBQUM7b0JBQzFELGdCQUFnQixFQUFFLGVBQWU7b0JBQ2pDLE9BQU8sRUFBRSxJQUFJO2lCQUNkLENBQUMsQ0FDSCxDQUFDO2dCQUNGLE1BQU07WUFDUixLQUFLLGlCQUFpQjtnQkFDcEIsSUFBSSxDQUFDLFVBQVUsQ0FBQyxHQUFHLENBQ2pCLElBQUksaUNBQU8sQ0FBQztvQkFDVixlQUFlLEVBQUUsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsRUFBRSxPQUFPLENBQUM7b0JBQ3RELGdCQUFnQixFQUFFLGlCQUFpQjtvQkFDbkMsT0FBTyxFQUFFLElBQUk7aUJBQ2QsQ0FBQyxDQUNILENBQUM7Z0JBQ0YsTUFBTTtZQUNSLEtBQUssZUFBZTtnQkFDbEIsTUFBTSw0QkFBNEIsR0FBRyxJQUFJLGlDQUFPLENBQUM7b0JBQy9DLGVBQWUsRUFBRSxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxFQUFFLE1BQU0sQ0FBQztvQkFDckQsZ0JBQWdCLEVBQUUsUUFBUTtvQkFDMUIsT0FBTyxFQUFFLElBQUk7aUJBQ2QsQ0FBQyxDQUFDO2dCQUNILElBQUksQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUFDLDRCQUE0QixDQUFDLENBQUM7Z0JBQ2xELE1BQU07WUFDUjtnQkFDRSxNQUFNO1NBQ1Q7UUFDRCxJQUFJLENBQUMsVUFBVSxDQUFDLE9BQU8sQ0FBQyxLQUFLLEVBQUMsT0FBTyxFQUFDLEVBQUU7WUFDdEMsTUFBTSxPQUFPLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDeEIsQ0FBQyxDQUFDLENBQUM7UUFDSCxJQUFJLElBQUksQ0FBQyxVQUFVLEVBQUU7WUFDbkIsTUFBTSxJQUFJLENBQUMsVUFBVSxDQUFDLEtBQUssRUFBRSxDQUFDO1NBQy9CO0lBQ0gsQ0FBQztJQUVEOztPQUVHO0lBQ0ksS0FBSyxDQUFDLElBQUk7UUFDZixJQUFJLElBQUksQ0FBQyxVQUFVLEVBQUU7WUFDbkIsTUFBTSxJQUFJLENBQUMsVUFBVSxDQUFDLElBQUksRUFBRSxDQUFDO1NBQzlCO1FBQ0QsSUFBSSxDQUFDLFVBQVUsQ0FBQyxPQUFPLENBQUMsS0FBSyxFQUFDLE9BQU8sRUFBQyxFQUFFO1lBQ3RDLE1BQU0sT0FBTyxDQUFDLElBQUksRUFBRSxDQUFDO1FBQ3ZCLENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztDQUNGO0FBakdELDBCQWlHQyJ9 \ No newline at end of file diff --git a/dist_ts/tswatch.classes.watcher.d.ts b/dist_ts/tswatch.classes.watcher.d.ts new file mode 100644 index 0000000..dba8b95 --- /dev/null +++ b/dist_ts/tswatch.classes.watcher.d.ts @@ -0,0 +1,35 @@ +export declare type TCommandFunction = () => Promise; +export interface IWatcherConstructorOptions { + filePathToWatch: string; + commandToExecute: string | TCommandFunction; + timeout?: number; +} +/** + * A watcher keeps track of one child execution + */ +export declare class Watcher { + /** + * used to execute shell commands + */ + private smartshellInstance; + private currentExecution; + private smartchokWatcher; + private options; + constructor(optionsArg: IWatcherConstructorOptions); + /** + * start the file + */ + start(): Promise; + /** + * updates the current execution + */ + private updateCurrentExecution; + /** + * this method sets up a clean exit strategy + */ + private setupCleanup; + /** + * stops the watcher + */ + stop(): Promise; +} diff --git a/dist_ts/tswatch.classes.watcher.js b/dist_ts/tswatch.classes.watcher.js new file mode 100644 index 0000000..f11c4f4 --- /dev/null +++ b/dist_ts/tswatch.classes.watcher.js @@ -0,0 +1,99 @@ +"use strict"; +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; + result["default"] = mod; + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const plugins = __importStar(require("./tswatch.plugins")); +const tswatch_logging_1 = require("./tswatch.logging"); +/** + * A watcher keeps track of one child execution + */ +class Watcher { + constructor(optionsArg) { + /** + * used to execute shell commands + */ + this.smartshellInstance = new plugins.smartshell.Smartshell({ + executor: 'bash' + }); + this.smartchokWatcher = new plugins.smartchok.Smartchok([], {}); + this.options = optionsArg; + } + /** + * start the file + */ + async start() { + await this.setupCleanup(); + console.log(`Looking at ${this.options.filePathToWatch} for changes`); + this.smartchokWatcher.add([this.options.filePathToWatch]); // __dirname refers to the directory of this very file + await this.smartchokWatcher.start(); + const changeObservable = await this.smartchokWatcher.getObservableFor('change'); + changeObservable.subscribe(() => { + this.updateCurrentExecution(); + }); + await this.updateCurrentExecution(); + } + /** + * updates the current execution + */ + async updateCurrentExecution() { + if (typeof this.options.commandToExecute === 'string') { + if (this.currentExecution) { + tswatch_logging_1.logger.log('ok', `reexecuting ${this.options.commandToExecute}`); + this.currentExecution.kill(); + } + else { + tswatch_logging_1.logger.log('ok', `executing ${this.options.commandToExecute} for the first time`); + } + this.currentExecution = await this.smartshellInstance.execStreaming(this.options.commandToExecute); + } + else { + console.log('cannot run execution task'); + } + } + /** + * this method sets up a clean exit strategy + */ + async setupCleanup() { + const cleanup = () => { + if (this.currentExecution) { + process.kill(-this.currentExecution.childProcess.pid); + } + }; + process.on('exit', () => { + console.log(''); + console.log('now exiting!'); + cleanup(); + process.exit(0); + }); + process.on('SIGINT', () => { + console.log(''); + console.log('ok! got SIGINT We are exiting! Just cleaning up to exit neatly :)'); + cleanup(); + process.exit(0); + }); + // handle timeout + if (this.options.timeout) { + plugins.smartdelay.delayFor(this.options.timeout).then(() => { + console.log(`timed out afer ${this.options.timeout} milliseconds! exiting!`); + cleanup(); + process.exit(0); + }); + } + } + /** + * stops the watcher + */ + async stop() { + await this.smartchokWatcher.stop(); + if (this.currentExecution && !this.currentExecution.childProcess.killed) { + process.kill(-this.currentExecution.childProcess.pid); + } + } +} +exports.Watcher = Watcher; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/dist_ts/tswatch.cli.d.ts b/dist_ts/tswatch.cli.d.ts new file mode 100644 index 0000000..cb0ff5c --- /dev/null +++ b/dist_ts/tswatch.cli.d.ts @@ -0,0 +1 @@ +export {}; diff --git a/dist_ts/tswatch.cli.js b/dist_ts/tswatch.cli.js new file mode 100644 index 0000000..84f4954 --- /dev/null +++ b/dist_ts/tswatch.cli.js @@ -0,0 +1,41 @@ +"use strict"; +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; + result["default"] = mod; + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const plugins = __importStar(require("./tswatch.plugins")); +const tswatch_logging_1 = require("./tswatch.logging"); +const tswatch_classes_tswatch_1 = require("./tswatch.classes.tswatch"); +const tswatchCli = new plugins.smartcli.Smartcli(); +// standard behaviour will assume gitzone setup +tswatchCli.addCommand('element').subscribe(async (argvArg) => { + tswatch_logging_1.logger.log('info', `running watch task for a gitzone element project`); + const tsWatch = new tswatch_classes_tswatch_1.TsWatch('gitzone_element'); + await tsWatch.start(); +}); +tswatchCli.addCommand('npm').subscribe(async (argvArg) => { + tswatch_logging_1.logger.log('info', `running watch task for a gitzone element project`); + const tsWatch = new tswatch_classes_tswatch_1.TsWatch('gitzone_npm'); + await tsWatch.start(); +}); +tswatchCli.addCommand('service').subscribe(async (argvArg) => { + tswatch_logging_1.logger.log('info', `running test task`); + const tsWatch = new tswatch_classes_tswatch_1.TsWatch('gitzone_service'); + await tsWatch.start(); +}); +tswatchCli.addCommand('test').subscribe(async (argvArg) => { + tswatch_logging_1.logger.log('info', `running test task`); + const tsWatch = new tswatch_classes_tswatch_1.TsWatch('test'); + await tsWatch.start(); +}); +tswatchCli.addCommand('website').subscribe(async (argvArg) => { + tswatch_logging_1.logger.log('info', `running watch task for a gitzone website project`); + const tsWatch = new tswatch_classes_tswatch_1.TsWatch('gitzone_website'); + await tsWatch.start(); +}); +tswatchCli.startParse(); +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHN3YXRjaC5jbGkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy90c3dhdGNoLmNsaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7QUFBQSwyREFBNkM7QUFFN0MsdURBQTJDO0FBRTNDLHVFQUFvRDtBQUVwRCxNQUFNLFVBQVUsR0FBRyxJQUFJLE9BQU8sQ0FBQyxRQUFRLENBQUMsUUFBUSxFQUFFLENBQUM7QUFFbkQsK0NBQStDO0FBRS9DLFVBQVUsQ0FBQyxVQUFVLENBQUMsU0FBUyxDQUFDLENBQUMsU0FBUyxDQUFDLEtBQUssRUFBQyxPQUFPLEVBQUMsRUFBRTtJQUN6RCx3QkFBTSxDQUFDLEdBQUcsQ0FBQyxNQUFNLEVBQUUsa0RBQWtELENBQUMsQ0FBQztJQUN2RSxNQUFNLE9BQU8sR0FBRyxJQUFJLGlDQUFPLENBQUMsaUJBQWlCLENBQUMsQ0FBQztJQUMvQyxNQUFNLE9BQU8sQ0FBQyxLQUFLLEVBQUUsQ0FBQztBQUN4QixDQUFDLENBQUMsQ0FBQztBQUVILFVBQVUsQ0FBQyxVQUFVLENBQUMsS0FBSyxDQUFDLENBQUMsU0FBUyxDQUFDLEtBQUssRUFBQyxPQUFPLEVBQUMsRUFBRTtJQUNyRCx3QkFBTSxDQUFDLEdBQUcsQ0FBQyxNQUFNLEVBQUUsa0RBQWtELENBQUMsQ0FBQztJQUN2RSxNQUFNLE9BQU8sR0FBRyxJQUFJLGlDQUFPLENBQUMsYUFBYSxDQUFDLENBQUM7SUFDM0MsTUFBTSxPQUFPLENBQUMsS0FBSyxFQUFFLENBQUM7QUFDeEIsQ0FBQyxDQUFDLENBQUM7QUFFSCxVQUFVLENBQUMsVUFBVSxDQUFDLFNBQVMsQ0FBQyxDQUFDLFNBQVMsQ0FBQyxLQUFLLEVBQUMsT0FBTyxFQUFDLEVBQUU7SUFDekQsd0JBQU0sQ0FBQyxHQUFHLENBQUMsTUFBTSxFQUFFLG1CQUFtQixDQUFDLENBQUM7SUFDeEMsTUFBTSxPQUFPLEdBQUcsSUFBSSxpQ0FBTyxDQUFDLGlCQUFpQixDQUFDLENBQUM7SUFDL0MsTUFBTSxPQUFPLENBQUMsS0FBSyxFQUFFLENBQUM7QUFDeEIsQ0FBQyxDQUFDLENBQUM7QUFFSCxVQUFVLENBQUMsVUFBVSxDQUFDLE1BQU0sQ0FBQyxDQUFDLFNBQVMsQ0FBQyxLQUFLLEVBQUMsT0FBTyxFQUFDLEVBQUU7SUFDdEQsd0JBQU0sQ0FBQyxHQUFHLENBQUMsTUFBTSxFQUFFLG1CQUFtQixDQUFDLENBQUM7SUFDeEMsTUFBTSxPQUFPLEdBQUcsSUFBSSxpQ0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQ3BDLE1BQU0sT0FBTyxDQUFDLEtBQUssRUFBRSxDQUFDO0FBQ3hCLENBQUMsQ0FBQyxDQUFDO0FBRUgsVUFBVSxDQUFDLFVBQVUsQ0FBQyxTQUFTLENBQUMsQ0FBQyxTQUFTLENBQUMsS0FBSyxFQUFDLE9BQU8sRUFBQyxFQUFFO0lBQ3pELHdCQUFNLENBQUMsR0FBRyxDQUFDLE1BQU0sRUFBRSxrREFBa0QsQ0FBQyxDQUFDO0lBQ3ZFLE1BQU0sT0FBTyxHQUFHLElBQUksaUNBQU8sQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDO0lBQy9DLE1BQU0sT0FBTyxDQUFDLEtBQUssRUFBRSxDQUFDO0FBQ3hCLENBQUMsQ0FBQyxDQUFDO0FBRUgsVUFBVSxDQUFDLFVBQVUsRUFBRSxDQUFDIn0= \ No newline at end of file diff --git a/dist_ts/tswatch.logging.d.ts b/dist_ts/tswatch.logging.d.ts new file mode 100644 index 0000000..be98b12 --- /dev/null +++ b/dist_ts/tswatch.logging.d.ts @@ -0,0 +1,2 @@ +import * as plugins from './tswatch.plugins'; +export declare const logger: plugins.smartlog.Smartlog; diff --git a/dist_ts/tswatch.logging.js b/dist_ts/tswatch.logging.js new file mode 100644 index 0000000..d6d3893 --- /dev/null +++ b/dist_ts/tswatch.logging.js @@ -0,0 +1,23 @@ +"use strict"; +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; + result["default"] = mod; + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const plugins = __importStar(require("./tswatch.plugins")); +exports.logger = new plugins.smartlog.Smartlog({ + logContext: { + company: 'Some Company', + companyunit: 'Some CompanyUnit', + containerName: 'Some Containername', + environment: 'local', + runtime: 'node', + zone: 'gitzone' + }, + minimumLogLevel: 'silly' +}); +exports.logger.addLogDestination(new plugins.smartlogDestinationLocal.DestinationLocal()); +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHN3YXRjaC5sb2dnaW5nLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvdHN3YXRjaC5sb2dnaW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7OztBQUFBLDJEQUE2QztBQUVoQyxRQUFBLE1BQU0sR0FBRyxJQUFJLE9BQU8sQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFDO0lBQ2xELFVBQVUsRUFBRTtRQUNWLE9BQU8sRUFBRSxjQUFjO1FBQ3ZCLFdBQVcsRUFBRSxrQkFBa0I7UUFDL0IsYUFBYSxFQUFFLG9CQUFvQjtRQUNuQyxXQUFXLEVBQUUsT0FBTztRQUNwQixPQUFPLEVBQUUsTUFBTTtRQUNmLElBQUksRUFBRSxTQUFTO0tBQ2hCO0lBQ0QsZUFBZSxFQUFFLE9BQU87Q0FDekIsQ0FBQyxDQUFDO0FBRUgsY0FBTSxDQUFDLGlCQUFpQixDQUFDLElBQUksT0FBTyxDQUFDLHdCQUF3QixDQUFDLGdCQUFnQixFQUFFLENBQUMsQ0FBQyJ9 \ No newline at end of file diff --git a/dist_ts/tswatch.paths.d.ts b/dist_ts/tswatch.paths.d.ts new file mode 100644 index 0000000..1a2eb4d --- /dev/null +++ b/dist_ts/tswatch.paths.d.ts @@ -0,0 +1 @@ +export declare const cwd: string; diff --git a/dist_ts/tswatch.paths.js b/dist_ts/tswatch.paths.js new file mode 100644 index 0000000..f781b8e --- /dev/null +++ b/dist_ts/tswatch.paths.js @@ -0,0 +1,4 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.cwd = process.cwd(); +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHN3YXRjaC5wYXRocy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3Rzd2F0Y2gucGF0aHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFFYSxRQUFBLEdBQUcsR0FBRyxPQUFPLENBQUMsR0FBRyxFQUFFLENBQUMifQ== \ No newline at end of file diff --git a/dist_ts/tswatch.plugins.d.ts b/dist_ts/tswatch.plugins.d.ts new file mode 100644 index 0000000..4b53fd1 --- /dev/null +++ b/dist_ts/tswatch.plugins.d.ts @@ -0,0 +1,14 @@ +import * as path from 'path'; +export { path }; +import * as lik from '@pushrocks/lik'; +import * as smartchok from '@pushrocks/smartchok'; +import * as smartcli from '@pushrocks/smartcli'; +import * as smartdelay from '@pushrocks/smartdelay'; +import * as smartlog from '@pushrocks/smartlog'; +import * as smartlogDestinationLocal from '@pushrocks/smartlog-destination-local'; +import * as smartserve from '@pushrocks/smartserve'; +import * as smartshell from '@pushrocks/smartshell'; +import * as taskbuffer from '@pushrocks/taskbuffer'; +export { lik, smartchok, smartcli, smartdelay, smartlog, smartlogDestinationLocal, smartserve, smartshell, taskbuffer }; +import parcel from 'parcel-bundler'; +export { parcel }; diff --git a/dist_ts/tswatch.plugins.js b/dist_ts/tswatch.plugins.js new file mode 100644 index 0000000..5d93361 --- /dev/null +++ b/dist_ts/tswatch.plugins.js @@ -0,0 +1,37 @@ +"use strict"; +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; + result["default"] = mod; + return result; +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const path = __importStar(require("path")); +exports.path = path; +// @pushrocks scope +const lik = __importStar(require("@pushrocks/lik")); +exports.lik = lik; +const smartchok = __importStar(require("@pushrocks/smartchok")); +exports.smartchok = smartchok; +const smartcli = __importStar(require("@pushrocks/smartcli")); +exports.smartcli = smartcli; +const smartdelay = __importStar(require("@pushrocks/smartdelay")); +exports.smartdelay = smartdelay; +const smartlog = __importStar(require("@pushrocks/smartlog")); +exports.smartlog = smartlog; +const smartlogDestinationLocal = __importStar(require("@pushrocks/smartlog-destination-local")); +exports.smartlogDestinationLocal = smartlogDestinationLocal; +const smartserve = __importStar(require("@pushrocks/smartserve")); +exports.smartserve = smartserve; +const smartshell = __importStar(require("@pushrocks/smartshell")); +exports.smartshell = smartshell; +const taskbuffer = __importStar(require("@pushrocks/taskbuffer")); +exports.taskbuffer = taskbuffer; +// third party scope +const parcel_bundler_1 = __importDefault(require("parcel-bundler")); +exports.parcel = parcel_bundler_1.default; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHN3YXRjaC5wbHVnaW5zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvdHN3YXRjaC5wbHVnaW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7OztBQUFBLDJDQUE2QjtBQUNwQixvQkFBSTtBQUViLG1CQUFtQjtBQUNuQixvREFBc0M7QUFXcEMsa0JBQUc7QUFWTCxnRUFBa0Q7QUFXaEQsOEJBQVM7QUFWWCw4REFBZ0Q7QUFXOUMsNEJBQVE7QUFWVixrRUFBb0Q7QUFXbEQsZ0NBQVU7QUFWWiw4REFBZ0Q7QUFXOUMsNEJBQVE7QUFWVixnR0FBa0Y7QUFXaEYsNERBQXdCO0FBVjFCLGtFQUFvRDtBQVdsRCxnQ0FBVTtBQVZaLGtFQUFvRDtBQVdsRCxnQ0FBVTtBQVZaLGtFQUFvRDtBQVdsRCxnQ0FBVTtBQUdaLG9CQUFvQjtBQUNwQixvRUFBb0M7QUFFM0IsaUJBRkYsd0JBQU0sQ0FFRSJ9 \ No newline at end of file diff --git a/ts/tswatch.classes.tswatch.ts b/ts/tswatch.classes.tswatch.ts index 19900ef..3eb948e 100644 --- a/ts/tswatch.classes.tswatch.ts +++ b/ts/tswatch.classes.tswatch.ts @@ -7,7 +7,7 @@ import { Parcel } from './tswatch.classes.parcel'; export class TsWatch { public watchmode: interfaces.TWatchModes; - public watcherMap = new plugins.lik.Objectmap(); + public watcherMap = new plugins.lik.ObjectMap(); public smartserve: plugins.smartserve.SmartServe; constructor(watchmodeArg: interfaces.TWatchModes) {