@nu-art/build-and-install 0.204.82 → 0.204.84

package/build-and-install.js

@@ -13,7 +13,7 @@ runner
     .then(() => {
     ts_common_1.StaticLogger.logInfo('completed');
     //TODO: make it an array of non exit params
-    if (!params_1.RuntimeParams.launch)
+    if (!params_1.RuntimeParams.launch && !params_1.RuntimeParams.watch)
         process.exit(0);
 })
     .catch(err => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nu-art/build-and-install",
-  "version": "0.204.82",
+  "version": "0.204.84",
   "description": "",
   "keywords": [
     "TacB0sS",

package/v2/phase-runner/PhaseRunnerDispatcher.d.ts

@@ -1,7 +1,7 @@
 import { FunctionKeys, ParamResolver } from '@nu-art/ts-common';
 import { Phase } from '../phase/types';
 import { BaseUnit } from '../unit/core';
-declare class PhaseRunnerDispatcher<T, K extends FunctionKeys<T> = FunctionKeys<T>, P extends ParamResolver<T, K> = ParamResolver<T, K>> {
+export declare class PhaseRunnerDispatcher<T, K extends FunctionKeys<T> = FunctionKeys<T>, P extends ParamResolver<T, K> = ParamResolver<T, K>> {
     private readonly method;
     constructor(method: K);
     private listeners;
@@ -21,4 +21,3 @@ export interface PhaseRunner_OnUnitsChange {
     __onUnitsChange: (data: BaseUnit[]) => void;
 }
 export declare const dispatcher_UnitChange: PhaseRunnerDispatcher<PhaseRunner_OnUnitsChange, "__onUnitsChange", [data: BaseUnit<import("../unit/core").BaseUnit_Config, import("../unit/core").BaseUnit_RuntimeConfig>[]]>;
-export {};

package/v2/phase-runner/PhaseRunnerDispatcher.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dispatcher_UnitChange = exports.dispatcher_UnitStatusChange = exports.dispatcher_PhaseChange = void 0;
+exports.dispatcher_UnitChange = exports.dispatcher_UnitStatusChange = exports.dispatcher_PhaseChange = exports.PhaseRunnerDispatcher = void 0;
 const ts_common_1 = require("@nu-art/ts-common");
 class PhaseRunnerDispatcher {
     constructor(method) {
@@ -24,6 +24,7 @@ class PhaseRunnerDispatcher {
         });
     }
 }
+exports.PhaseRunnerDispatcher = PhaseRunnerDispatcher;
 exports.dispatcher_PhaseChange = new PhaseRunnerDispatcher('__onPhaseChange');
 exports.dispatcher_UnitStatusChange = new PhaseRunnerDispatcher('__onUnitStatusChange');
 exports.dispatcher_UnitChange = new PhaseRunnerDispatcher('__onUnitsChange');

package/v2/unit/consts.d.ts

@@ -0,0 +1,6 @@
+import { WatchEventType } from './types';
+export declare const WatchEvent_Add: WatchEventType;
+export declare const WatchEvent_Update: WatchEventType;
+export declare const WatchEvent_RemoveDir: WatchEventType;
+export declare const WatchEvent_RemoveFile: WatchEventType;
+export declare const WatchEvent_Ready: WatchEventType;

package/v2/unit/consts.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WatchEvent_Ready = exports.WatchEvent_RemoveFile = exports.WatchEvent_RemoveDir = exports.WatchEvent_Update = exports.WatchEvent_Add = void 0;
+exports.WatchEvent_Add = 'add';
+exports.WatchEvent_Update = 'update';
+exports.WatchEvent_RemoveDir = 'remove_dir';
+exports.WatchEvent_RemoveFile = 'remove_file';
+exports.WatchEvent_Ready = 'ready';

package/v2/unit/core/Unit_TypescriptLib.d.ts

@@ -1,6 +1,7 @@
 import { Unit_Typescript, Unit_Typescript_Config, Unit_Typescript_RuntimeConfig } from './Unit_Typescript';
-import { UnitPhaseImplementor } from '../types';
+import { UnitPhaseImplementor, WatchEventType } from '../types';
 import { Phase_CheckCyclicImports, Phase_Compile, Phase_Lint, Phase_PreCompile, Phase_PrintDependencyTree, Phase_Purge } from '../../phase';
+import { OnWatchEvent } from '../runner-dispatchers';
 export type Unit_TypescriptLib_Config = Unit_Typescript_Config & {
     customTSConfig?: boolean;
     output: string;
@@ -18,14 +19,23 @@ export declare class Unit_TypescriptLib<C extends Unit_TypescriptLib_Config = Un
     Phase_CheckCyclicImports,
     Phase_Purge,
     Phase_Lint
-]> {
+]>, OnWatchEvent {
+    private compilationError;
     constructor(config: Unit_TypescriptLib<C, RTC>['config']);
+    __onWatchEvent(type: WatchEventType, path?: string): Promise<void>;
     protected init(setInitialized?: boolean): Promise<void>;
     protected resolveTSConfig(): Promise<void>;
     protected clearOutputDir(): Promise<void>;
     protected compileImpl(): Promise<void>;
     protected copyAssetsToOutput(): Promise<void>;
     protected copyPackageJSONToOutput(): Promise<void>;
+    protected handleWatchChange(path: string, shouldRemoveDist?: boolean): Promise<void>;
+    /**
+     * Remove the deleted file/folder from the dist folder on watch remove file event
+     * @param path The path of the currently removed file/folder
+     * @private
+     */
+    private removeSpecificFileFromDist;
     preCompile(): Promise<void>;
     compile(): Promise<void>;
     purge(): Promise<void>;

package/v2/unit/core/Unit_TypescriptLib.js

@@ -34,6 +34,8 @@ const RunnerParams_1 = require("../../phase-runner/RunnerParams");
 const cli_1 = require("@nu-art/commando/core/cli");
 const consts_1 = require("../../../core/consts");
 const params_1 = require("../../../core/params/params");
+const runner_dispatchers_1 = require("../runner-dispatchers");
+const consts_2 = require("../consts");
 const extensionsToLint = ['.ts', '.tsx'];
 const assetExtensions = [
     'json',
@@ -48,7 +50,14 @@ const assetExtensions = [
 class Unit_TypescriptLib extends Unit_Typescript_1.Unit_Typescript {
     constructor(config) {
         super(config);
+        this.compilationError = false;
         this.addToClassStack(Unit_TypescriptLib);
+        runner_dispatchers_1.dispatcher_WatchEvent.addListener(this);
+    }
+    async __onWatchEvent(type, path) {
+        if (type === consts_2.WatchEvent_Ready)
+            return this.setStatus('Watching');
+        await this.handleWatchChange(path, [consts_2.WatchEvent_RemoveFile, consts_2.WatchEvent_RemoveDir].includes(type));
     }
     async init(setInitialized = true) {
         await super.init(false);
@@ -90,12 +99,25 @@ class Unit_TypescriptLib extends Unit_Typescript_1.Unit_Typescript {
     async compileImpl() {
         const pathToCompile = `${this.runtime.pathTo.pkg}/src/main`;
         const pathToTSConfig = `${pathToCompile}/tsconfig.json`;
-        await nvm_1.NVM
-            .createCommando(basic_1.Cli_Basic)
-            .setUID(this.config.key)
-            .cd(this.runtime.pathTo.pkg)
-            .append(`tsc -p "${pathToTSConfig}" --rootDir "${pathToCompile}" --outDir "${this.runtime.pathTo.output}"`)
-            .execute();
+        try {
+            await nvm_1.NVM
+                .createCommando(basic_1.Cli_Basic)
+                .setUID(this.config.key)
+                .cd(this.runtime.pathTo.pkg)
+                .append(`tsc -p "${pathToTSConfig}" --rootDir "${pathToCompile}" --outDir "${this.runtime.pathTo.output}"`)
+                .execute();
+            // set compilation error status on success
+            this.compilationError = false;
+        }
+        catch (e) {
+            //In order to finish compile when running watch we just log the error instead of throwing it
+            if (params_1.RuntimeParams.watch) {
+                // set compilation error status on error
+                this.compilationError = true;
+                return this.logError(e);
+            }
+            throw e;
+        }
     }
     async copyAssetsToOutput() {
         const command = `find . \\( -name ${assetExtensions.map(suffix => `'*.${suffix}'`).join(' -o -name ')} \\) | cpio -pdmuv "${this.runtime.pathTo.output}" > /dev/null 2>&1`;
@@ -113,6 +135,43 @@ class Unit_TypescriptLib extends Unit_Typescript_1.Unit_Typescript {
         const fileContent = JSON.stringify(this.packageJson.dist, null, 2);
         await fs_1.promises.writeFile(targetPath, fileContent, { encoding: 'utf-8' });
     }
+    async handleWatchChange(path, shouldRemoveDist = false) {
+        // ignore if path doesn't related to unit
+        if (!path.startsWith(this.config.pathToPackage))
+            return;
+        this.setStatus('Compile');
+        // check if dist folder must be cleared
+        if (shouldRemoveDist)
+            await this.removeSpecificFileFromDist(path);
+        // perform all watch actions
+        await this.compileImpl();
+        await this.copyAssetsToOutput();
+        this.setStatus(`Watching${this.compilationError ? ' with error' : ''}`);
+        // dispatch unit post compile
+        runner_dispatchers_1.dispatcher_UnitWatchCompile.dispatch(this);
+    }
+    /**
+     * Remove the deleted file/folder from the dist folder on watch remove file event
+     * @param path The path of the currently removed file/folder
+     * @private
+     */
+    async removeSpecificFileFromDist(path) {
+        const distPathBase = path.replace('src/main', 'dist').replace(/\.ts$/, '');
+        const pathsToDelete = [
+            `${distPathBase}.js`,
+            `${distPathBase}.d.ts`,
+            `${distPathBase}.js.map`,
+            distPathBase // in case it's a directory
+        ];
+        // try to remove all path options from dist
+        for (const path of pathsToDelete) {
+            if (!fs.existsSync(path)) {
+                this.logDebug(`no file in path ${path}`);
+                continue;
+            }
+            await fs_1.promises.rm(path, { recursive: true, force: true });
+        }
+    }
     //######################### Phase Implementations #########################
     async preCompile() {
         if (!fs.existsSync(`${this.config.pathToPackage}/prebuild.sh`))
@@ -130,7 +189,7 @@ class Unit_TypescriptLib extends Unit_Typescript_1.Unit_Typescript {
         await this.compileImpl();
         await this.copyAssetsToOutput();
         await this.copyPackageJSONToOutput();
-        this.setStatus('Compiled');
+        this.setStatus(`Compiled${this.compilationError ? ' with error' : ''}`);
     }
     async purge() {
         await fs_1.promises.rm(this.runtime.pathTo.output, { recursive: true, force: true });

package/v2/unit/core/Unit_TypescriptProject.d.ts

@@ -1,15 +1,29 @@
 import { UnitPhaseImplementor } from '../types';
 import { Unit_Typescript, Unit_Typescript_Config, Unit_Typescript_RuntimeConfig } from './Unit_Typescript';
-import { Phase_Install } from '../../phase';
+import { Phase_Install, Phase_Watch } from '../../phase';
 import { StringMap } from '@nu-art/ts-common/utils/types';
 type Unit_TypescriptProject_Config = Unit_Typescript_Config & {
     globalPackages?: StringMap;
 };
 type Unit_TypescriptProject_RuntimeConfig = Unit_Typescript_RuntimeConfig & {};
-export declare class Unit_TypescriptProject<C extends Unit_TypescriptProject_Config = Unit_TypescriptProject_Config, RTC extends Unit_TypescriptProject_RuntimeConfig = Unit_TypescriptProject_RuntimeConfig> extends Unit_Typescript<C, RTC> implements UnitPhaseImplementor<[Phase_Install]> {
+export declare class Unit_TypescriptProject<C extends Unit_TypescriptProject_Config = Unit_TypescriptProject_Config, RTC extends Unit_TypescriptProject_RuntimeConfig = Unit_TypescriptProject_RuntimeConfig> extends Unit_Typescript<C, RTC> implements UnitPhaseImplementor<[Phase_Install, Phase_Watch]> {
+    private readonly suffixesToWatch;
     constructor(config: Unit_TypescriptProject<C>['config']);
     private installGlobals;
     private installPackages;
+    /**
+     * Resolve all paths to watch in all project libs
+     * @private
+     * @returns string[]
+     */
+    private prepareWatchPaths;
+    /**
+     * Init watch events and attach default watch callback with correct params to each of them
+     * @private
+     */
+    private initWatch;
+    private watchImpl;
     install(): Promise<void>;
+    watch(): Promise<void>;
 }
 export {};

package/v2/unit/core/Unit_TypescriptProject.js

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Unit_TypescriptProject = void 0;
 const Unit_Typescript_1 = require("./Unit_Typescript");
@@ -7,9 +30,21 @@ const ts_common_1 = require("@nu-art/ts-common");
 const nvm_1 = require("@nu-art/commando/cli/nvm");
 const pnpm_1 = require("@nu-art/commando/cli/pnpm");
 const consts_1 = require("../../phase-runner/consts");
+const chokidar = __importStar(require("chokidar"));
+const runner_dispatchers_1 = require("../runner-dispatchers");
+const consts_2 = require("../consts");
+const Unit_TypescriptLib_1 = require("./Unit_TypescriptLib");
+const firebase_units_1 = require("../firebase-units");
 class Unit_TypescriptProject extends Unit_Typescript_1.Unit_Typescript {
     constructor(config) {
         super(config);
+        this.suffixesToWatch = [
+            'ts',
+            'tsx',
+            'scss',
+            'json',
+            'svg'
+        ];
         this.addToClassStack(Unit_TypescriptProject);
     }
     //######################### Internal Logic #########################
@@ -33,10 +68,71 @@ class Unit_TypescriptProject extends Unit_Typescript_1.Unit_Typescript {
         await pnpm_1.PNPM.createWorkspace(packages);
         await pnpm_1.PNPM.installPackages(nvm_1.NVM.createCommando());
     }
+    /**
+     * Resolve all paths to watch in all project libs
+     * @private
+     * @returns string[]
+     */
+    prepareWatchPaths() {
+        // Using phase runner instance to resolve all project libs to watch
+        const cantBeInstanceOf = [firebase_units_1.Unit_FirebaseHostingApp, firebase_units_1.Unit_FirebaseFunctionsApp];
+        const projectLibs = consts_1.MemKey_PhaseRunner.get()
+            .getUnits().filter(unit => unit.isInstanceOf(Unit_TypescriptLib_1.Unit_TypescriptLib) && cantBeInstanceOf.every(_instance => !unit.isInstanceOf(_instance)));
+        //return all paths to watch
+        return projectLibs.map(lib => {
+            const sourceFolder = `${lib.config.pathToPackage}/src/main`;
+            return { paths: this.suffixesToWatch.map(suffix => `${sourceFolder}/**/*.${suffix}`), unit: lib };
+        });
+    }
+    /**
+     * Init watch events and attach default watch callback with correct params to each of them
+     * @private
+     */
+    initWatch() {
+        const pathDeclarations = this.prepareWatchPaths();
+        const paths = pathDeclarations.flatMap(path => path.paths);
+        const watcher = chokidar.watch(paths);
+        // set all events to watch and handle them
+        return new Promise((resolve, error) => {
+            this.logInfo('Starting the watcher...');
+            watcher
+                .on('error', (error) => {
+                this.logError('Error while watching', error);
+            })
+                .on('ready', () => {
+                this.logInfo('Watching...');
+                runner_dispatchers_1.dispatcher_WatchEvent.dispatch(consts_2.WatchEvent_Ready);
+                watcher
+                    .on('add', (path) => {
+                    runner_dispatchers_1.dispatcher_WatchEvent.dispatch(consts_2.WatchEvent_Add, path);
+                })
+                    .on('change', (path) => {
+                    runner_dispatchers_1.dispatcher_WatchEvent.dispatch(consts_2.WatchEvent_Update, path);
+                })
+                    .on('unlinkDir', (path) => {
+                    runner_dispatchers_1.dispatcher_WatchEvent.dispatch(consts_2.WatchEvent_RemoveDir, path);
+                })
+                    .on('unlink', (path) => {
+                    runner_dispatchers_1.dispatcher_WatchEvent.dispatch(consts_2.WatchEvent_RemoveFile, path);
+                });
+            });
+            process.on('SIGINT', async (status) => {
+                await watcher.close();
+                process.exit(0);
+                resolve();
+            });
+        });
+    }
+    async watchImpl() {
+        await this.initWatch();
+    }
     //######################### Phase Implementation #########################
     async install() {
         await this.installGlobals();
         await this.installPackages();
     }
+    async watch() {
+        await this.watchImpl();
+    }
 }
 exports.Unit_TypescriptProject = Unit_TypescriptProject;

package/v2/unit/firebase-units/Unit_FirebaseFunctionsApp.d.ts

@@ -1,12 +1,13 @@
-import { Unit_TypescriptLib, Unit_TypescriptLib_Config } from '../core';
+import { BaseUnit, Unit_TypescriptLib, Unit_TypescriptLib_Config } from '../core';
 import { UnitPhaseImplementor } from '../types';
 import { Phase_DeployBackend, Phase_Launch, Phase_ResolveConfigs } from '../../phase';
 import { FirebasePackageConfig } from '../../../core/types';
+import { OnUnitWatchCompiled } from '../runner-dispatchers';
 export type Unit_FirebaseFunctionsApp_Config = Unit_TypescriptLib_Config & {
     firebaseConfig: FirebasePackageConfig;
     sources?: string[];
 };
-export declare class Unit_FirebaseFunctionsApp<C extends Unit_FirebaseFunctionsApp_Config = Unit_FirebaseFunctionsApp_Config> extends Unit_TypescriptLib<C> implements UnitPhaseImplementor<[Phase_ResolveConfigs, Phase_Launch, Phase_DeployBackend]> {
+export declare class Unit_FirebaseFunctionsApp<C extends Unit_FirebaseFunctionsApp_Config = Unit_FirebaseFunctionsApp_Config> extends Unit_TypescriptLib<C> implements UnitPhaseImplementor<[Phase_ResolveConfigs, Phase_Launch, Phase_DeployBackend]>, OnUnitWatchCompiled {
     static staggerCount: number;
     private readonly PROXY_PID_LOG;
     private readonly PROXY_KILL_LOG;
@@ -14,6 +15,7 @@ export declare class Unit_FirebaseFunctionsApp<C extends Unit_FirebaseFunctionsA
     private readonly EMULATOR_KILL_LOG;
     private launchCommandos;
     private listeners;
+    __onUnitWatchCompiled(unit: BaseUnit): Promise<void>;
     constructor(config: Unit_FirebaseFunctionsApp<C>['config']);
     resolveConfigs(): Promise<void>;
     compile(): Promise<void>;

package/v2/unit/firebase-units/Unit_FirebaseFunctionsApp.js

@@ -12,8 +12,18 @@ const cli_1 = require("@nu-art/commando/core/cli");
 const basic_1 = require("@nu-art/commando/cli/basic");
 const nvm_1 = require("@nu-art/commando/cli/nvm");
 const consts_3 = require("../../phase-runner/consts");
+const runner_dispatchers_1 = require("../runner-dispatchers");
 const CONST_VersionApp = 'version-app.json';
 class Unit_FirebaseFunctionsApp extends core_1.Unit_TypescriptLib {
+    async __onUnitWatchCompiled(unit) {
+        if (this.runtime.unitDependencyNames.includes(unit.runtime.dependencyName)) {
+            this.setStatus('Compile');
+            await this.compileImpl();
+            await this.copyAssetsToOutput();
+            await this.createDependenciesDir();
+            this.setStatus('Compiled');
+        }
+    }
     constructor(config) {
         super(config);
         this.PROXY_PID_LOG = '_PROXY_PID_';
@@ -21,6 +31,8 @@ class Unit_FirebaseFunctionsApp extends core_1.Unit_TypescriptLib {
         this.EMULATOR_PID_LOG = '_EMULATOR_PID_';
         this.EMULATOR_KILL_LOG = '_EMULATOR_KILLED_';
         this.addToClassStack(Unit_FirebaseFunctionsApp);
+        runner_dispatchers_1.dispatcher_WatchEvent.removeListener(this);
+        runner_dispatchers_1.dispatcher_UnitWatchCompile.addListener(this);
     }
     //######################### Phase Implementations #########################
     async resolveConfigs() {

package/v2/unit/firebase-units/Unit_FirebaseHostingApp.js

@@ -11,6 +11,7 @@ const nvm_1 = require("@nu-art/commando/cli/nvm");
 const basic_1 = require("@nu-art/commando/cli/basic");
 const RunnerParams_1 = require("../../phase-runner/RunnerParams");
 const cli_1 = require("@nu-art/commando/core/cli");
+const runner_dispatchers_1 = require("../runner-dispatchers");
 const CONST_VersionApp = 'version-app.json';
 class Unit_FirebaseHostingApp extends core_1.Unit_TypescriptLib {
     constructor(config) {
@@ -18,6 +19,7 @@ class Unit_FirebaseHostingApp extends core_1.Unit_TypescriptLib {
         this.APP_PID_LOG = '_APP_PID_';
         this.APP_KILL_LOG = '_APP_KILLED_';
         this.addToClassStack(Unit_FirebaseHostingApp);
+        runner_dispatchers_1.dispatcher_WatchEvent.removeListener(this);
     }
     //######################### Phase Implementations #########################
     async resolveConfigs() {

package/v2/unit/runner-dispatchers.d.ts

@@ -0,0 +1,11 @@
+import { PhaseRunnerDispatcher } from '../phase-runner/PhaseRunnerDispatcher';
+import { WatchEventType } from './types';
+import { BaseUnit } from './core';
+export interface OnWatchEvent {
+    __onWatchEvent: (type: WatchEventType, path?: string) => void;
+}
+export declare const dispatcher_WatchEvent: PhaseRunnerDispatcher<OnWatchEvent, "__onWatchEvent", [type: WatchEventType, path?: string | undefined]>;
+export interface OnUnitWatchCompiled {
+    __onUnitWatchCompiled: (init: BaseUnit) => void;
+}
+export declare const dispatcher_UnitWatchCompile: PhaseRunnerDispatcher<OnUnitWatchCompiled, "__onUnitWatchCompiled", [init: BaseUnit<import("./core").BaseUnit_Config, import("./core").BaseUnit_RuntimeConfig>]>;

package/v2/unit/runner-dispatchers.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatcher_UnitWatchCompile = exports.dispatcher_WatchEvent = void 0;
+const PhaseRunnerDispatcher_1 = require("../phase-runner/PhaseRunnerDispatcher");
+exports.dispatcher_WatchEvent = new PhaseRunnerDispatcher_1.PhaseRunnerDispatcher('__onWatchEvent');
+exports.dispatcher_UnitWatchCompile = new PhaseRunnerDispatcher_1.PhaseRunnerDispatcher('__onUnitWatchCompiled');

package/v2/unit/types.d.ts

@@ -5,3 +5,4 @@ export type Unit<P extends Phase<string>[]> = BaseUnit & UnitPhaseImplementor<P>
 export type UnitPhaseImplementor<P extends Phase<string>[]> = {
     [K in P[number]['method']]: AsyncVoidFunction;
 };
+export type WatchEventType = 'update' | 'add' | 'remove_file' | 'remove_dir' | 'ready';