@teambit/watcher 0.0.1

package/dist/check-types.d.ts

@@ -0,0 +1,5 @@
+export declare enum CheckTypes {
+    None = 0,
+    EntireProject = 1,
+    ChangedFile = 2
+}

package/dist/check-types.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CheckTypes = void 0;
+let CheckTypes;
+exports.CheckTypes = CheckTypes;
+(function (CheckTypes) {
+  CheckTypes[CheckTypes["None"] = 0] = "None";
+  CheckTypes[CheckTypes["EntireProject"] = 1] = "EntireProject";
+  CheckTypes[CheckTypes["ChangedFile"] = 2] = "ChangedFile";
+})(CheckTypes || (exports.CheckTypes = CheckTypes = {}));
+
+//# sourceMappingURL=check-types.js.map

package/dist/check-types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["CheckTypes"],"sources":["check-types.ts"],"sourcesContent":["export enum CheckTypes {\n  None, // keep this. it equals zero. this way we can do \"if checkTypes() ... \"\n  EntireProject,\n  ChangedFile,\n}\n"],"mappings":";;;;;;IAAYA,UAAU;AAAA;AAAA,WAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;AAAA,GAAVA,UAAU,0BAAVA,UAAU"}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { WatcherAspect } from './watcher.aspect';
+export { WatchOptions } from './watcher';
+export { CheckTypes } from './check-types';
+export type { WatcherMain } from './watcher.main.runtime';
+export default WatcherAspect;
+export { WatcherAspect };

package/dist/index.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "CheckTypes", {
+  enumerable: true,
+  get: function () {
+    return _checkTypes().CheckTypes;
+  }
+});
+Object.defineProperty(exports, "WatchOptions", {
+  enumerable: true,
+  get: function () {
+    return _watcher2().WatchOptions;
+  }
+});
+Object.defineProperty(exports, "WatcherAspect", {
+  enumerable: true,
+  get: function () {
+    return _watcher().WatcherAspect;
+  }
+});
+exports.default = void 0;
+function _watcher() {
+  const data = require("./watcher.aspect");
+  _watcher = function () {
+    return data;
+  };
+  return data;
+}
+function _watcher2() {
+  const data = require("./watcher");
+  _watcher2 = function () {
+    return data;
+  };
+  return data;
+}
+function _checkTypes() {
+  const data = require("./check-types");
+  _checkTypes = function () {
+    return data;
+  };
+  return data;
+}
+var _default = _watcher().WatcherAspect;
+exports.default = _default;
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["WatcherAspect"],"sources":["index.ts"],"sourcesContent":["import { WatcherAspect } from './watcher.aspect';\n\nexport { WatchOptions } from './watcher';\nexport { CheckTypes } from './check-types';\nexport type { WatcherMain } from './watcher.main.runtime';\nexport default WatcherAspect;\nexport { WatcherAspect };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAAA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AAEA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AAA2C,eAE5BA,wBAAa;AAAA"}

package/dist/output-formatter.d.ts

@@ -0,0 +1,9 @@
+import { OnComponentEventResult } from '@teambit/workspace';
+export declare const formatWatchPathsSortByComponent: (trackDirs: any) => string;
+/**
+ * todo: this was implemented incorrectly.
+ * the original idea of `SerializableResults` was to have each one of the aspects registered to the slot, the
+ * ability to have their own formatting to their results, and then `toString()` method to print them.
+ * Here, the printing is specifically to the Compiler aspect. It should move to where it belongs.
+ */
+export declare function formatCompileResults(compileResults: OnComponentEventResult[], verbose: boolean): string;

package/dist/output-formatter.js

@@ -0,0 +1,54 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatCompileResults = formatCompileResults;
+exports.formatWatchPathsSortByComponent = void 0;
+function _chalk() {
+  const data = _interopRequireDefault(require("chalk"));
+  _chalk = function () {
+    return data;
+  };
+  return data;
+}
+const verboseComponentFilesArrayToString = componentFiles => {
+  return componentFiles.reduce((outputString, filePath) => `${outputString} \t - ${filePath}\n`, ``);
+};
+const resultsForExtensionArrayToString = (resultsForExtension, verbose) => {
+  return resultsForExtension.reduce((outputString, resultForExtension) => `${outputString}${_chalk().default.green('√')}SUCCESS\t${resultForExtension.component}\n
+     ${verbose ? resultForExtension.componentFilesAsString : ''}\n`, '');
+};
+const formatWatchPathsSortByComponent = trackDirs => {
+  return Object.keys(trackDirs).reduce((outputString, watchPath) => `${outputString}
+    ${_chalk().default.green('√')} SUCCESS\t${trackDirs[watchPath]}\n
+    \t - ${watchPath}\n\n`, ` ${_chalk().default.underline('STATUS\t\tCOMPONENT ID')}\n`);
+};
+
+/**
+ * todo: this was implemented incorrectly.
+ * the original idea of `SerializableResults` was to have each one of the aspects registered to the slot, the
+ * ability to have their own formatting to their results, and then `toString()` method to print them.
+ * Here, the printing is specifically to the Compiler aspect. It should move to where it belongs.
+ */
+exports.formatWatchPathsSortByComponent = formatWatchPathsSortByComponent;
+function formatCompileResults(compileResults, verbose) {
+  if (!compileResults.length || !Array.isArray(compileResults)) return '';
+  return compileResults.filter(compileResult => {
+    var _compileResult$result, _compileResult$result2;
+    return ((_compileResult$result = compileResult.results) === null || _compileResult$result === void 0 ? void 0 : _compileResult$result.results) && Array.isArray((_compileResult$result2 = compileResult.results) === null || _compileResult$result2 === void 0 ? void 0 : _compileResult$result2.results);
+  }).map(compileResult => {
+    var _compileResult$result3, _compileResult$result4;
+    return {
+      extensionId: compileResult.extensionId,
+      resultsForExtension: (_compileResult$result3 = compileResult.results) === null || _compileResult$result3 === void 0 ? void 0 : (_compileResult$result4 = _compileResult$result3.results) === null || _compileResult$result4 === void 0 ? void 0 : _compileResult$result4.map(resultForExtension => ({
+        component: resultForExtension.component,
+        componentFilesAsString: verboseComponentFilesArrayToString(resultForExtension.buildResults)
+      }))
+    };
+  }).reduce((outputString, compileResult) => `${outputString}
+  ${resultsForExtensionArrayToString(compileResult.resultsForExtension, verbose)}`, ` ${_chalk().default.underline('STATUS\tCOMPONENT ID')}`);
+}
+
+//# sourceMappingURL=output-formatter.js.map

package/dist/output-formatter.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["verboseComponentFilesArrayToString","componentFiles","reduce","outputString","filePath","resultsForExtensionArrayToString","resultsForExtension","verbose","resultForExtension","chalk","green","component","componentFilesAsString","formatWatchPathsSortByComponent","trackDirs","Object","keys","watchPath","underline","formatCompileResults","compileResults","length","Array","isArray","filter","compileResult","results","map","extensionId","buildResults"],"sources":["output-formatter.ts"],"sourcesContent":["import { OnComponentEventResult } from '@teambit/workspace';\nimport chalk from 'chalk';\n\nconst verboseComponentFilesArrayToString = (componentFiles) => {\n  return componentFiles.reduce((outputString, filePath) => `${outputString} \\t - ${filePath}\\n`, ``);\n};\n\nconst resultsForExtensionArrayToString = (resultsForExtension, verbose) => {\n  return resultsForExtension.reduce(\n    (outputString, resultForExtension) =>\n      `${outputString}${chalk.green('√')}SUCCESS\\t${resultForExtension.component}\\n\n     ${verbose ? resultForExtension.componentFilesAsString : ''}\\n`,\n    ''\n  );\n};\n\nexport const formatWatchPathsSortByComponent = (trackDirs) => {\n  return Object.keys(trackDirs).reduce(\n    (outputString, watchPath) =>\n      `${outputString}\n    ${chalk.green('√')} SUCCESS\\t${trackDirs[watchPath]}\\n\n    \\t - ${watchPath}\\n\\n`,\n    ` ${chalk.underline('STATUS\\t\\tCOMPONENT ID')}\\n`\n  );\n};\n\n/**\n * todo: this was implemented incorrectly.\n * the original idea of `SerializableResults` was to have each one of the aspects registered to the slot, the\n * ability to have their own formatting to their results, and then `toString()` method to print them.\n * Here, the printing is specifically to the Compiler aspect. It should move to where it belongs.\n */\nexport function formatCompileResults(compileResults: OnComponentEventResult[], verbose: boolean) {\n  if (!compileResults.length || !Array.isArray(compileResults)) return '';\n  return compileResults\n    .filter((compileResult) => compileResult.results?.results && Array.isArray(compileResult.results?.results))\n    .map((compileResult) => ({\n      extensionId: compileResult.extensionId,\n      resultsForExtension: compileResult.results?.results?.map((resultForExtension) => ({\n        component: resultForExtension.component,\n        componentFilesAsString: verboseComponentFilesArrayToString(resultForExtension.buildResults),\n      })),\n    }))\n    .reduce(\n      (outputString, compileResult) =>\n        `${outputString}\n  ${resultsForExtensionArrayToString(compileResult.resultsForExtension, verbose)}`,\n      ` ${chalk.underline('STATUS\\tCOMPONENT ID')}`\n    );\n}\n"],"mappings":";;;;;;;;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AAEA,MAAMA,kCAAkC,GAAIC,cAAc,IAAK;EAC7D,OAAOA,cAAc,CAACC,MAAM,CAAC,CAACC,YAAY,EAAEC,QAAQ,KAAM,GAAED,YAAa,SAAQC,QAAS,IAAG,EAAG,EAAC,CAAC;AACpG,CAAC;AAED,MAAMC,gCAAgC,GAAG,CAACC,mBAAmB,EAAEC,OAAO,KAAK;EACzE,OAAOD,mBAAmB,CAACJ,MAAM,CAC/B,CAACC,YAAY,EAAEK,kBAAkB,KAC9B,GAAEL,YAAa,GAAEM,gBAAK,CAACC,KAAK,CAAC,GAAG,CAAE,YAAWF,kBAAkB,CAACG,SAAU;AACjF,OAAOJ,OAAO,GAAGC,kBAAkB,CAACI,sBAAsB,GAAG,EAAG,IAAG,EAC/D,EAAE,CACH;AACH,CAAC;AAEM,MAAMC,+BAA+B,GAAIC,SAAS,IAAK;EAC5D,OAAOC,MAAM,CAACC,IAAI,CAACF,SAAS,CAAC,CAACZ,MAAM,CAClC,CAACC,YAAY,EAAEc,SAAS,KACrB,GAAEd,YAAa;AACtB,MAAMM,gBAAK,CAACC,KAAK,CAAC,GAAG,CAAE,aAAYI,SAAS,CAACG,SAAS,CAAE;AACxD,WAAWA,SAAU,MAAK,EACrB,IAAGR,gBAAK,CAACS,SAAS,CAAC,wBAAwB,CAAE,IAAG,CAClD;AACH,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AALA;AAMO,SAASC,oBAAoB,CAACC,cAAwC,EAAEb,OAAgB,EAAE;EAC/F,IAAI,CAACa,cAAc,CAACC,MAAM,IAAI,CAACC,KAAK,CAACC,OAAO,CAACH,cAAc,CAAC,EAAE,OAAO,EAAE;EACvE,OAAOA,cAAc,CAClBI,MAAM,CAAEC,aAAa;IAAA;IAAA,OAAK,0BAAAA,aAAa,CAACC,OAAO,0DAArB,sBAAuBA,OAAO,KAAIJ,KAAK,CAACC,OAAO,2BAACE,aAAa,CAACC,OAAO,2DAArB,uBAAuBA,OAAO,CAAC;EAAA,EAAC,CAC1GC,GAAG,CAAEF,aAAa;IAAA;IAAA,OAAM;MACvBG,WAAW,EAAEH,aAAa,CAACG,WAAW;MACtCtB,mBAAmB,4BAAEmB,aAAa,CAACC,OAAO,qFAArB,uBAAuBA,OAAO,2DAA9B,uBAAgCC,GAAG,CAAEnB,kBAAkB,KAAM;QAChFG,SAAS,EAAEH,kBAAkB,CAACG,SAAS;QACvCC,sBAAsB,EAAEZ,kCAAkC,CAACQ,kBAAkB,CAACqB,YAAY;MAC5F,CAAC,CAAC;IACJ,CAAC;EAAA,CAAC,CAAC,CACF3B,MAAM,CACL,CAACC,YAAY,EAAEsB,aAAa,KACzB,GAAEtB,YAAa;AACxB,IAAIE,gCAAgC,CAACoB,aAAa,CAACnB,mBAAmB,EAAEC,OAAO,CAAE,EAAC,EAC3E,IAAGE,gBAAK,CAACS,SAAS,CAAC,sBAAsB,CAAE,EAAC,CAC9C;AACL"}

package/dist/preview-1676777489824.js

@@ -0,0 +1,7 @@
+;
+;
+
+export const compositions = [];
+export const overview = [];
+
+export const compositions_metadata = {"compositions":[]};

package/dist/watch-queue.d.ts

@@ -0,0 +1,8 @@
+import PQueue from 'p-queue';
+export declare class WatchQueue {
+    private queue;
+    constructor(concurrency?: number);
+    getQueue(): PQueue<import("p-queue/dist/priority-queue").default, import("p-queue").DefaultAddOptions>;
+    add<T>(fn: () => T, priority?: number): Promise<T>;
+    onIdle(): Promise<void>;
+}

package/dist/watch-queue.js

@@ -0,0 +1,44 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WatchQueue = void 0;
+function _defineProperty2() {
+  const data = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+  _defineProperty2 = function () {
+    return data;
+  };
+  return data;
+}
+function _pQueue() {
+  const data = _interopRequireDefault(require("p-queue"));
+  _pQueue = function () {
+    return data;
+  };
+  return data;
+}
+class WatchQueue {
+  constructor(concurrency = 1) {
+    (0, _defineProperty2().default)(this, "queue", void 0);
+    this.queue = new (_pQueue().default)({
+      concurrency,
+      autoStart: true
+    });
+  }
+  getQueue() {
+    return this.queue;
+  }
+  add(fn, priority) {
+    return this.queue.add(fn, {
+      priority
+    });
+  }
+  onIdle() {
+    return this.queue.onIdle();
+  }
+}
+exports.WatchQueue = WatchQueue;
+
+//# sourceMappingURL=watch-queue.js.map

package/dist/watch-queue.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["WatchQueue","constructor","concurrency","queue","PQueue","autoStart","getQueue","add","fn","priority","onIdle"],"sources":["watch-queue.ts"],"sourcesContent":["import PQueue from 'p-queue';\n\nexport class WatchQueue {\n  private queue: PQueue;\n  constructor(concurrency = 1) {\n    this.queue = new PQueue({ concurrency, autoStart: true });\n  }\n  getQueue() {\n    return this.queue;\n  }\n  add<T>(fn: () => T, priority?: number): Promise<T> {\n    return this.queue.add(fn, { priority });\n  }\n  onIdle(): Promise<void> {\n    return this.queue.onIdle();\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAAA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AAEO,MAAMA,UAAU,CAAC;EAEtBC,WAAW,CAACC,WAAW,GAAG,CAAC,EAAE;IAAA;IAC3B,IAAI,CAACC,KAAK,GAAG,KAAIC,iBAAM,EAAC;MAAEF,WAAW;MAAEG,SAAS,EAAE;IAAK,CAAC,CAAC;EAC3D;EACAC,QAAQ,GAAG;IACT,OAAO,IAAI,CAACH,KAAK;EACnB;EACAI,GAAG,CAAIC,EAAW,EAAEC,QAAiB,EAAc;IACjD,OAAO,IAAI,CAACN,KAAK,CAACI,GAAG,CAACC,EAAE,EAAE;MAAEC;IAAS,CAAC,CAAC;EACzC;EACAC,MAAM,GAAkB;IACtB,OAAO,IAAI,CAACP,KAAK,CAACO,MAAM,EAAE;EAC5B;AACF;AAAC"}

package/dist/watch.cmd.d.ts

@@ -0,0 +1,55 @@
+import { Command, CommandOptions } from '@teambit/cli';
+import type { Logger } from '@teambit/logger';
+import type { PubsubMain } from '@teambit/pubsub';
+import { OnComponentEventResult } from '@teambit/workspace';
+import { WatcherMain } from './watcher.main.runtime';
+export declare type WatchCmdOpts = {
+    verbose?: boolean;
+    skipPreCompilation?: boolean;
+    checkTypes?: string | boolean;
+};
+export declare class WatchCommand implements Command {
+    /**
+     * logger extension.
+     */
+    private pubsub;
+    /**
+     * logger extension.
+     */
+    private logger;
+    /**
+     * watcher extension.
+     */
+    private watcher;
+    msgs: {
+        onAll: (event: string, path: string) => void;
+        onStart: () => void;
+        onReady: (workspace: any, watchPathsSortByComponent: any, verbose: any) => void;
+        onChange: (filePaths: string[], buildResults: OnComponentEventResult[], verbose: boolean, duration: any, failureMsg?: string) => void;
+        onAdd: (filePaths: string[], buildResults: OnComponentEventResult[], verbose: boolean, duration: any, failureMsg?: string) => void;
+        onUnlink: (p: any) => void;
+        onError: (err: any) => void;
+    };
+    name: string;
+    description: string;
+    helpUrl: string;
+    alias: string;
+    group: string;
+    options: CommandOptions;
+    constructor(
+    /**
+     * logger extension.
+     */
+    pubsub: PubsubMain, 
+    /**
+     * logger extension.
+     */
+    logger: Logger, 
+    /**
+     * watcher extension.
+     */
+    watcher: WatcherMain);
+    private registerToEvents;
+    private eventsListener;
+    report(cliArgs: [], watchCmdOpts: WatchCmdOpts): Promise<string>;
+}

package/dist/watch.cmd.js

@@ -0,0 +1,173 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+require("core-js/modules/es.promise.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WatchCommand = void 0;
+function _defineProperty2() {
+  const data = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+  _defineProperty2 = function () {
+    return data;
+  };
+  return data;
+}
+function _chalk() {
+  const data = _interopRequireDefault(require("chalk"));
+  _chalk = function () {
+    return data;
+  };
+  return data;
+}
+function _moment() {
+  const data = _interopRequireDefault(require("moment"));
+  _moment = function () {
+    return data;
+  };
+  return data;
+}
+function _compiler() {
+  const data = require("@teambit/compiler");
+  _compiler = function () {
+    return data;
+  };
+  return data;
+}
+function _outputFormatter() {
+  const data = require("./output-formatter");
+  _outputFormatter = function () {
+    return data;
+  };
+  return data;
+}
+function _checkTypes() {
+  const data = require("./check-types");
+  _checkTypes = function () {
+    return data;
+  };
+  return data;
+}
+// import IDs and events
+
+class WatchCommand {
+  constructor(
+  /**
+   * logger extension.
+   */
+  pubsub,
+  /**
+   * logger extension.
+   */
+  logger,
+  /**
+   * watcher extension.
+   */
+  watcher) {
+    this.pubsub = pubsub;
+    this.logger = logger;
+    this.watcher = watcher;
+    (0, _defineProperty2().default)(this, "msgs", {
+      onAll: (event, path) => this.logger.console(`Event: "${event}". Path: ${path}`),
+      onStart: () => {},
+      onReady: (workspace, watchPathsSortByComponent, verbose) => {
+        clearOutdatedData();
+        if (verbose) {
+          this.logger.console((0, _outputFormatter().formatWatchPathsSortByComponent)(watchPathsSortByComponent));
+        }
+        this.logger.console(_chalk().default.yellow(`Watching for component changes in workspace ${workspace.config.name} (${(0, _moment().default)().format('HH:mm:ss')})...\n`));
+      },
+      onChange: (filePaths, buildResults, verbose, duration, failureMsg) => {
+        const files = filePaths.join(', ');
+        // clearOutdatedData();
+        if (!buildResults.length) {
+          failureMsg = failureMsg || `The files ${files} have been changed, but nothing to compile`;
+          this.logger.console(`${failureMsg}\n\n`);
+          return;
+        }
+        this.logger.console(`The file(s) ${files} have been changed.\n\n`);
+        this.logger.console((0, _outputFormatter().formatCompileResults)(buildResults, verbose));
+        this.logger.console(`Finished. (${duration}ms)`);
+        this.logger.console(_chalk().default.yellow(`Watching for component changes (${(0, _moment().default)().format('HH:mm:ss')})...`));
+      },
+      onAdd: (filePaths, buildResults, verbose, duration, failureMsg) => {
+        const files = filePaths.join(', ');
+        // clearOutdatedData();
+        if (!buildResults.length) {
+          failureMsg = failureMsg || `The files ${files} have been added, but nothing to compile`;
+          this.logger.console(`${failureMsg}\n\n`);
+          return;
+        }
+        this.logger.console(`The file(s) ${filePaths} have been added.\n\n`);
+        this.logger.console((0, _outputFormatter().formatCompileResults)(buildResults, verbose));
+        this.logger.console(`Finished. (${duration}ms)`);
+        this.logger.console(_chalk().default.yellow(`Watching for component changes (${(0, _moment().default)().format('HH:mm:ss')})...`));
+      },
+      onUnlink: p => {
+        this.logger.console(`file ${p} has been removed`);
+      },
+      onError: err => {
+        this.logger.console(`Watcher error ${err}`);
+      }
+    });
+    (0, _defineProperty2().default)(this, "name", 'watch');
+    (0, _defineProperty2().default)(this, "description", 'automatically recompile modified components (on save)');
+    (0, _defineProperty2().default)(this, "helpUrl", 'reference/compiling/compiler-overview');
+    (0, _defineProperty2().default)(this, "alias", '');
+    (0, _defineProperty2().default)(this, "group", 'development');
+    (0, _defineProperty2().default)(this, "options", [['v', 'verbose', 'show npm verbose output for inspection and print the stack trace'], ['', 'skip-pre-compilation', 'skip the compilation step before starting to watch'], ['t', 'check-types [string]', 'EXPERIMENTAL. show errors/warnings for types. options are [file, project] to investigate only changed file or entire project. defaults to project']]);
+    (0, _defineProperty2().default)(this, "eventsListener", event => {
+      switch (event.type) {
+        case _compiler().CompilerErrorEvent.TYPE:
+          this.logger.console(`Watcher error ${event.data.error}, 'error'`);
+          break;
+        default:
+      }
+    });
+    this.registerToEvents();
+  }
+  registerToEvents() {
+    this.pubsub.sub(_compiler().CompilerAspect.id, this.eventsListener);
+  }
+  async report(cliArgs, watchCmdOpts) {
+    const {
+      verbose,
+      checkTypes
+    } = watchCmdOpts;
+    const getCheckTypesEnum = () => {
+      switch (checkTypes) {
+        case undefined:
+        case false:
+          return _checkTypes().CheckTypes.None;
+        case 'project':
+        case true:
+          // project is the default
+          return _checkTypes().CheckTypes.EntireProject;
+        case 'file':
+          return _checkTypes().CheckTypes.ChangedFile;
+        default:
+          throw new Error(`check-types can be either "file" or "project". got "${checkTypes}"`);
+      }
+    };
+    const watchOpts = {
+      msgs: this.msgs,
+      verbose,
+      preCompile: !watchCmdOpts.skipPreCompilation,
+      spawnTSServer: Boolean(checkTypes),
+      // if check-types is enabled, it must spawn the tsserver.
+      checkTypes: getCheckTypesEnum()
+    };
+    await this.watcher.watch(watchOpts);
+    return 'watcher terminated';
+  }
+}
+
+/**
+ * with console.clear() all history is deleted from the console. this function preserver the history.
+ */
+exports.WatchCommand = WatchCommand;
+function clearOutdatedData() {
+  process.stdout.write('\x1Bc');
+}
+
+//# sourceMappingURL=watch.cmd.js.map

package/dist/watch.cmd.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["WatchCommand","constructor","pubsub","logger","watcher","onAll","event","path","console","onStart","onReady","workspace","watchPathsSortByComponent","verbose","clearOutdatedData","formatWatchPathsSortByComponent","chalk","yellow","config","name","moment","format","onChange","filePaths","buildResults","duration","failureMsg","files","join","length","formatCompileResults","onAdd","onUnlink","p","onError","err","type","CompilerErrorEvent","TYPE","data","error","registerToEvents","sub","CompilerAspect","id","eventsListener","report","cliArgs","watchCmdOpts","checkTypes","getCheckTypesEnum","undefined","CheckTypes","None","EntireProject","ChangedFile","Error","watchOpts","msgs","preCompile","skipPreCompilation","spawnTSServer","Boolean","watch","process","stdout","write"],"sources":["watch.cmd.ts"],"sourcesContent":["import chalk from 'chalk';\nimport moment from 'moment';\nimport { Command, CommandOptions } from '@teambit/cli';\nimport type { Logger } from '@teambit/logger';\nimport type { BitBaseEvent, PubsubMain } from '@teambit/pubsub';\nimport { OnComponentEventResult } from '@teambit/workspace';\n\n// import IDs and events\nimport { CompilerAspect, CompilerErrorEvent } from '@teambit/compiler';\n\nimport { WatchOptions } from './watcher';\nimport { formatCompileResults, formatWatchPathsSortByComponent } from './output-formatter';\nimport { CheckTypes } from './check-types';\nimport { WatcherMain } from './watcher.main.runtime';\n\nexport type WatchCmdOpts = {\n  verbose?: boolean;\n  skipPreCompilation?: boolean;\n  checkTypes?: string | boolean;\n};\n\nexport class WatchCommand implements Command {\n  msgs = {\n    onAll: (event: string, path: string) => this.logger.console(`Event: \"${event}\". Path: ${path}`),\n    onStart: () => {},\n    onReady: (workspace, watchPathsSortByComponent, verbose) => {\n      clearOutdatedData();\n      if (verbose) {\n        this.logger.console(formatWatchPathsSortByComponent(watchPathsSortByComponent));\n      }\n      this.logger.console(\n        chalk.yellow(\n          `Watching for component changes in workspace ${workspace.config.name} (${moment().format('HH:mm:ss')})...\\n`\n        )\n      );\n    },\n    onChange: (\n      filePaths: string[],\n      buildResults: OnComponentEventResult[],\n      verbose: boolean,\n      duration,\n      failureMsg?: string\n    ) => {\n      const files = filePaths.join(', ');\n      // clearOutdatedData();\n      if (!buildResults.length) {\n        failureMsg = failureMsg || `The files ${files} have been changed, but nothing to compile`;\n        this.logger.console(`${failureMsg}\\n\\n`);\n        return;\n      }\n      this.logger.console(`The file(s) ${files} have been changed.\\n\\n`);\n      this.logger.console(formatCompileResults(buildResults, verbose));\n      this.logger.console(`Finished. (${duration}ms)`);\n      this.logger.console(chalk.yellow(`Watching for component changes (${moment().format('HH:mm:ss')})...`));\n    },\n    onAdd: (\n      filePaths: string[],\n      buildResults: OnComponentEventResult[],\n      verbose: boolean,\n      duration,\n      failureMsg?: string\n    ) => {\n      const files = filePaths.join(', ');\n      // clearOutdatedData();\n      if (!buildResults.length) {\n        failureMsg = failureMsg || `The files ${files} have been added, but nothing to compile`;\n        this.logger.console(`${failureMsg}\\n\\n`);\n        return;\n      }\n      this.logger.console(`The file(s) ${filePaths} have been added.\\n\\n`);\n      this.logger.console(formatCompileResults(buildResults, verbose));\n      this.logger.console(`Finished. (${duration}ms)`);\n      this.logger.console(chalk.yellow(`Watching for component changes (${moment().format('HH:mm:ss')})...`));\n    },\n    onUnlink: (p) => {\n      this.logger.console(`file ${p} has been removed`);\n    },\n    onError: (err) => {\n      this.logger.console(`Watcher error ${err}`);\n    },\n  };\n\n  name = 'watch';\n  description = 'automatically recompile modified components (on save)';\n  helpUrl = 'reference/compiling/compiler-overview';\n  alias = '';\n  group = 'development';\n  options = [\n    ['v', 'verbose', 'show npm verbose output for inspection and print the stack trace'],\n    ['', 'skip-pre-compilation', 'skip the compilation step before starting to watch'],\n    [\n      't',\n      'check-types [string]',\n      'EXPERIMENTAL. show errors/warnings for types. options are [file, project] to investigate only changed file or entire project. defaults to project',\n    ],\n  ] as CommandOptions;\n\n  constructor(\n    /**\n     * logger extension.\n     */\n    private pubsub: PubsubMain,\n\n    /**\n     * logger extension.\n     */\n    private logger: Logger,\n\n    /**\n     * watcher extension.\n     */\n    private watcher: WatcherMain\n  ) {\n    this.registerToEvents();\n  }\n\n  private registerToEvents() {\n    this.pubsub.sub(CompilerAspect.id, this.eventsListener);\n  }\n\n  private eventsListener = (event: BitBaseEvent<any>) => {\n    switch (event.type) {\n      case CompilerErrorEvent.TYPE:\n        this.logger.console(`Watcher error ${event.data.error}, 'error'`);\n        break;\n      default:\n    }\n  };\n\n  async report(cliArgs: [], watchCmdOpts: WatchCmdOpts) {\n    const { verbose, checkTypes } = watchCmdOpts;\n    const getCheckTypesEnum = () => {\n      switch (checkTypes) {\n        case undefined:\n        case false:\n          return CheckTypes.None;\n        case 'project':\n        case true: // project is the default\n          return CheckTypes.EntireProject;\n        case 'file':\n          return CheckTypes.ChangedFile;\n        default:\n          throw new Error(`check-types can be either \"file\" or \"project\". got \"${checkTypes}\"`);\n      }\n    };\n    const watchOpts: WatchOptions = {\n      msgs: this.msgs,\n      verbose,\n      preCompile: !watchCmdOpts.skipPreCompilation,\n      spawnTSServer: Boolean(checkTypes), // if check-types is enabled, it must spawn the tsserver.\n      checkTypes: getCheckTypesEnum(),\n    };\n    await this.watcher.watch(watchOpts);\n    return 'watcher terminated';\n  }\n}\n\n/**\n * with console.clear() all history is deleted from the console. this function preserver the history.\n */\nfunction clearOutdatedData() {\n  process.stdout.write('\\x1Bc');\n}\n"],"mappings":"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"}

package/dist/watcher.aspect.d.ts

@@ -0,0 +1,2 @@
+import { Aspect } from '@teambit/harmony';
+export declare const WatcherAspect: Aspect;

package/dist/watcher.aspect.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WatcherAspect = void 0;
+function _harmony() {
+  const data = require("@teambit/harmony");
+  _harmony = function () {
+    return data;
+  };
+  return data;
+}
+const WatcherAspect = _harmony().Aspect.create({
+  id: 'teambit.workspace/watcher'
+});
+exports.WatcherAspect = WatcherAspect;
+
+//# sourceMappingURL=watcher.aspect.js.map

package/dist/watcher.aspect.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["WatcherAspect","Aspect","create","id"],"sources":["watcher.aspect.ts"],"sourcesContent":["import { Aspect } from '@teambit/harmony';\n\nexport const WatcherAspect = Aspect.create({\n  id: 'teambit.workspace/watcher',\n});\n"],"mappings":";;;;;;AAAA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AAEO,MAAMA,aAAa,GAAGC,iBAAM,CAACC,MAAM,CAAC;EACzCC,EAAE,EAAE;AACN,CAAC,CAAC;AAAC"}

package/dist/watcher.d.ts

@@ -0,0 +1,110 @@
+/// <reference types="node" />
+import { PubsubMain } from '@teambit/pubsub';
+import { ComponentID } from '@teambit/component';
+import { BitId } from '@teambit/legacy-bit-id';
+import { Consumer } from '@teambit/legacy/dist/consumer';
+import { ChildProcess } from 'child_process';
+import { PathLinux } from '@teambit/legacy/dist/utils/path';
+import { CompilationInitiator } from '@teambit/compiler';
+import { Workspace } from '@teambit/workspace';
+import { CheckTypes } from './check-types';
+import { WatcherMain } from './watcher.main.runtime';
+export declare type WatcherProcessData = {
+    watchProcess: ChildProcess;
+    compilerId: BitId;
+    componentIds: BitId[];
+};
+export declare type EventMessages = {
+    onAll: Function;
+    onStart: Function;
+    onReady: Function;
+    onChange: Function;
+    onAdd: Function;
+    onUnlink: Function;
+    onError: Function;
+};
+export declare type WatchOptions = {
+    msgs?: EventMessages;
+    initiator?: CompilationInitiator;
+    verbose?: boolean;
+    spawnTSServer?: boolean;
+    checkTypes?: CheckTypes;
+    preCompile?: boolean;
+};
+export declare class Watcher {
+    private workspace;
+    private pubsub;
+    private watcherMain;
+    private trackDirs;
+    private verbose;
+    private multipleWatchers;
+    private fsWatcher;
+    private changedFilesPerComponent;
+    private watchQueue;
+    private bitMapChangesInProgress;
+    constructor(workspace: Workspace, pubsub: PubsubMain, watcherMain: WatcherMain, trackDirs?: {
+        [dir: PathLinux]: ComponentID;
+    }, verbose?: boolean, multipleWatchers?: WatcherProcessData[]);
+    get consumer(): Consumer;
+    watchAll(opts: WatchOptions): Promise<unknown>;
+    /**
+     * *** DEBOUNCING ***
+     * some actions trigger multiple files changes at (almost) the same time. e.g. "git pull".
+     * this causes some performance and instability issues. a debouncing mechanism was implemented to help with this.
+     * the way how it works is that the first file of the same component starts the execution with a delay (e.g. 200ms).
+     * if, in the meanwhile, another file of the same component was changed, it won't start a new execution, instead,
+     * it'll only add the file to `this.changedFilesPerComponent` prop.
+     * once the execution starts, it'll delete this component-id from the `this.changedFilesPerComponent` array,
+     * indicating the next file-change to start a new execution.
+     *
+     * implementation wise, `lodash.debounce` doesn't help here, because:
+     * A) it doesn't return the results, unless "leading" option is true. here, it must be false, otherwise, it'll start
+     * the execution immediately.
+     * B) it debounces the method regardless the param passes to it. so it'll disregard the component-id and will delay
+     * other components undesirably.
+     *
+     * *** QUEUE ***
+     * the debouncing helps to not execute the same component multiple times concurrently. however, multiple components
+     * and .bitmap changes execution can still be processed concurrently.
+     * the following example explains why this is an issue.
+     * compA is changed in the .bitmap file from version 0.0.1 to 0.0.2. its files were changed as well.
+     * all these changes get pulled at the same time by "git pull", as a result, the execution of compA and the .bitmap
+     * happen at the same time.
+     * during the execution of compA, the component id is parsed as compA@0.0.1, later, it asks for the Workspace for this
+     * id. while the workspace is looking for this id, the .bitmap execution reloaded the consumer and changed all versions.
+     * after this change, the workspace doesn't have this id anymore, which will trigger an error.
+     * to ensure this won't happen, we keep a flag to indicate whether the .bitmap execution is running, and if so, all
+     * other executions are paused until the queue is empty (this is done by awaiting for queue.onIdle).
+     * once the queue is empty, we know the .bitmap process was done and the workspace has all new ids.
+     * in the example above, at this stage, the id will be resolved to compA@0.0.2.
+     * one more thing, the queue is configured to have concurrency of 1. to make sure two components are not processed at
+     * the same time. (the same way is done when loading all components from the filesystem/scope).
+     * this way we can also ensure that if compA was started before the .bitmap execution, it will complete before the
+     * .bitmap execution starts.
+     */
+    private handleChange;
+    private sleep;
+    /**
+     * if a file was added/remove, once the component is loaded, it changes .bitmap, and then the
+     * entire cache is invalidated and the consumer is reloaded.
+     * when a file just changed, no need to reload the consumer, it is enough to just delete the
+     * component from the cache (both, workspace and consumer)
+     */
+    private triggerCompChanges;
+    /**
+     * if .bitmap changed, it's possible that a new component has been added. trigger onComponentAdd.
+     */
+    private handleBitmapChanges;
+    private executeWatchOperationsOnRemove;
+    private executeWatchOperationsOnComponent;
+    private creatOnComponentRemovedEvent;
+    private creatOnComponentChangeEvent;
+    private creatOnComponentAddEvent;
+    private isComponentWatchedExternally;
+    private getComponentIdByPath;
+    private getRelativePathLinux;
+    private findTrackDirByFilePathRecursively;
+    private createWatcher;
+    setTrackDirs(): Promise<void>;
+    private getPathsToWatch;
+}