@teambit/ipc-events 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { IpcEventsAspect } from './ipc-events.aspect';
+export type { IpcEventsMain } from './ipc-events.main.runtime';
+export default IpcEventsAspect;
+export { IpcEventsAspect };

package/dist/index.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "IpcEventsAspect", {
+  enumerable: true,
+  get: function () {
+    return _ipcEvents().IpcEventsAspect;
+  }
+});
+exports.default = void 0;
+function _ipcEvents() {
+  const data = require("./ipc-events.aspect");
+  _ipcEvents = function () {
+    return data;
+  };
+  return data;
+}
+var _default = _ipcEvents().IpcEventsAspect;
+exports.default = _default;
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["IpcEventsAspect"],"sources":["index.ts"],"sourcesContent":["import { IpcEventsAspect } from './ipc-events.aspect';\n\nexport type { IpcEventsMain } from './ipc-events.main.runtime';\nexport default IpcEventsAspect;\nexport { IpcEventsAspect };\n"],"mappings":";;;;;;;;;;;;AAAA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AAAsD,eAGvCA,4BAAe;AAAA"}

package/dist/ipc-events.aspect.d.ts

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

package/dist/ipc-events.aspect.js

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

package/dist/ipc-events.aspect.js.map

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

package/dist/ipc-events.main.runtime.d.ts

@@ -0,0 +1,38 @@
+import { ScopeMain } from '@teambit/scope';
+import { SlotRegistry } from '@teambit/harmony';
+declare type EventName = 'onPostInstall';
+declare type GotEvent = (eventName: EventName) => Promise<void>;
+declare type GotEventSlot = SlotRegistry<GotEvent>;
+/**
+ * imagine you have multiple processes running in the background, such as `bit watch`, `bit start`, `bit server`.
+ * the user is running `bit install` from the cli, how do you let these processes know that the installation is complete?
+ * `bit start` for instance could use ths info to clear the "component issues" of the components that were missing packages.
+ *
+ * this class provides a mechanism to achieve this by writing the event into the filesystem (`.bit/events/event-name`),
+ * while each one of the processes has a watcher in the background watch this file. once they got the data from the watcher,
+ * they can act upon it.
+ *
+ * in the previous example, when the user is running `bit install`, the install aspect runs `this.publishIpcEvent` to
+ * write `.bit/events/onPostInstall` to the filesystem. then, the watcher of `bit start` process got a notification
+ * that this file has changed/added and it runs `triggerGotEvent` to run all aspects registered to its gotEventSlot.
+ * the installer in turn is registered to this slot and once its function is triggered, it check whether the eventName
+ * is onPostInstall and then triggers its own OnPostInstall slot.
+ */
+export declare class IpcEventsMain {
+    private scope;
+    private gotEventSlot;
+    constructor(scope: ScopeMain, gotEventSlot: GotEventSlot);
+    registerGotEventSlot(fn: GotEvent): void;
+    triggerGotEvent(eventName: EventName): Promise<void>;
+    /**
+     * write event data into the filesystem, so then other processes, such as "bit start", "bit watch", could use the
+     * watcher to get the event data.
+     */
+    publishIpcEvent(eventName: EventName, data?: Record<string, any>): Promise<void>;
+    get eventsDir(): string;
+    static slots: ((registerFn: () => string) => SlotRegistry<GotEventSlot>)[];
+    static dependencies: import("@teambit/harmony").Aspect[];
+    static runtime: import("@teambit/harmony").RuntimeDefinition;
+    static provider([scope]: [ScopeMain], _: any, [gotEventSlot]: [GotEventSlot]): Promise<IpcEventsMain>;
+}
+export default IpcEventsMain;

package/dist/ipc-events.main.runtime.js

@@ -0,0 +1,119 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.promise.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.IpcEventsMain = void 0;
+function _defineProperty2() {
+  const data = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+  _defineProperty2 = function () {
+    return data;
+  };
+  return data;
+}
+function _scope() {
+  const data = _interopRequireDefault(require("@teambit/scope"));
+  _scope = function () {
+    return data;
+  };
+  return data;
+}
+function _harmony() {
+  const data = require("@teambit/harmony");
+  _harmony = function () {
+    return data;
+  };
+  return data;
+}
+function _pMapSeries() {
+  const data = _interopRequireDefault(require("p-map-series"));
+  _pMapSeries = function () {
+    return data;
+  };
+  return data;
+}
+function _cli() {
+  const data = require("@teambit/cli");
+  _cli = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _fsExtra() {
+  const data = _interopRequireDefault(require("fs-extra"));
+  _fsExtra = function () {
+    return data;
+  };
+  return data;
+}
+function _ipcEvents() {
+  const data = require("./ipc-events.aspect");
+  _ipcEvents = function () {
+    return data;
+  };
+  return data;
+}
+const EVENTS_DIR = 'events';
+
+/**
+ * imagine you have multiple processes running in the background, such as `bit watch`, `bit start`, `bit server`.
+ * the user is running `bit install` from the cli, how do you let these processes know that the installation is complete?
+ * `bit start` for instance could use ths info to clear the "component issues" of the components that were missing packages.
+ *
+ * this class provides a mechanism to achieve this by writing the event into the filesystem (`.bit/events/event-name`),
+ * while each one of the processes has a watcher in the background watch this file. once they got the data from the watcher,
+ * they can act upon it.
+ *
+ * in the previous example, when the user is running `bit install`, the install aspect runs `this.publishIpcEvent` to
+ * write `.bit/events/onPostInstall` to the filesystem. then, the watcher of `bit start` process got a notification
+ * that this file has changed/added and it runs `triggerGotEvent` to run all aspects registered to its gotEventSlot.
+ * the installer in turn is registered to this slot and once its function is triggered, it check whether the eventName
+ * is onPostInstall and then triggers its own OnPostInstall slot.
+ */
+class IpcEventsMain {
+  constructor(scope, gotEventSlot) {
+    this.scope = scope;
+    this.gotEventSlot = gotEventSlot;
+  }
+  registerGotEventSlot(fn) {
+    this.gotEventSlot.register(fn);
+  }
+  async triggerGotEvent(eventName) {
+    await (0, _pMapSeries().default)(this.gotEventSlot.values(), fn => fn(eventName));
+  }
+
+  /**
+   * write event data into the filesystem, so then other processes, such as "bit start", "bit watch", could use the
+   * watcher to get the event data.
+   */
+  async publishIpcEvent(eventName, data) {
+    const filename = _path().default.join(this.eventsDir, eventName);
+    const content = data ? JSON.stringify(data, undefined, 2) : '';
+    await _fsExtra().default.outputFile(filename, content);
+  }
+  get eventsDir() {
+    return _path().default.join(this.scope.path, EVENTS_DIR);
+  }
+  static async provider([scope], _, [gotEventSlot]) {
+    return new IpcEventsMain(scope, gotEventSlot);
+  }
+}
+exports.IpcEventsMain = IpcEventsMain;
+(0, _defineProperty2().default)(IpcEventsMain, "slots", [_harmony().Slot.withType()]);
+(0, _defineProperty2().default)(IpcEventsMain, "dependencies", [_scope().default]);
+(0, _defineProperty2().default)(IpcEventsMain, "runtime", _cli().MainRuntime);
+_ipcEvents().IpcEventsAspect.addRuntime(IpcEventsMain);
+var _default = IpcEventsMain;
+exports.default = _default;
+
+//# sourceMappingURL=ipc-events.main.runtime.js.map

package/dist/ipc-events.main.runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["EVENTS_DIR","IpcEventsMain","constructor","scope","gotEventSlot","registerGotEventSlot","fn","register","triggerGotEvent","eventName","pMapSeries","values","publishIpcEvent","data","filename","path","join","eventsDir","content","JSON","stringify","undefined","fs","outputFile","provider","_","Slot","withType","ScopeAspect","MainRuntime","IpcEventsAspect","addRuntime"],"sources":["ipc-events.main.runtime.ts"],"sourcesContent":["import ScopeAspect, { ScopeMain } from '@teambit/scope';\nimport { Slot, SlotRegistry } from '@teambit/harmony';\nimport pMapSeries from 'p-map-series';\nimport { MainRuntime } from '@teambit/cli';\nimport path from 'path';\nimport fs from 'fs-extra';\nimport { IpcEventsAspect } from './ipc-events.aspect';\n\ntype EventName = 'onPostInstall';\n\ntype GotEvent = (eventName: EventName) => Promise<void>;\ntype GotEventSlot = SlotRegistry<GotEvent>;\n\nconst EVENTS_DIR = 'events';\n\n/**\n * imagine you have multiple processes running in the background, such as `bit watch`, `bit start`, `bit server`.\n * the user is running `bit install` from the cli, how do you let these processes know that the installation is complete?\n * `bit start` for instance could use ths info to clear the \"component issues\" of the components that were missing packages.\n *\n * this class provides a mechanism to achieve this by writing the event into the filesystem (`.bit/events/event-name`),\n * while each one of the processes has a watcher in the background watch this file. once they got the data from the watcher,\n * they can act upon it.\n *\n * in the previous example, when the user is running `bit install`, the install aspect runs `this.publishIpcEvent` to\n * write `.bit/events/onPostInstall` to the filesystem. then, the watcher of `bit start` process got a notification\n * that this file has changed/added and it runs `triggerGotEvent` to run all aspects registered to its gotEventSlot.\n * the installer in turn is registered to this slot and once its function is triggered, it check whether the eventName\n * is onPostInstall and then triggers its own OnPostInstall slot.\n */\nexport class IpcEventsMain {\n  constructor(private scope: ScopeMain, private gotEventSlot: GotEventSlot) {}\n\n  registerGotEventSlot(fn: GotEvent) {\n    this.gotEventSlot.register(fn);\n  }\n\n  async triggerGotEvent(eventName: EventName) {\n    await pMapSeries(this.gotEventSlot.values(), (fn) => fn(eventName));\n  }\n\n  /**\n   * write event data into the filesystem, so then other processes, such as \"bit start\", \"bit watch\", could use the\n   * watcher to get the event data.\n   */\n  async publishIpcEvent(eventName: EventName, data?: Record<string, any>) {\n    const filename = path.join(this.eventsDir, eventName);\n    const content = data ? JSON.stringify(data, undefined, 2) : '';\n    await fs.outputFile(filename, content);\n  }\n\n  get eventsDir() {\n    return path.join(this.scope.path, EVENTS_DIR);\n  }\n\n  static slots = [Slot.withType<GotEventSlot>()];\n  static dependencies = [ScopeAspect];\n  static runtime = MainRuntime;\n\n  static async provider([scope]: [ScopeMain], _, [gotEventSlot]: [GotEventSlot]) {\n    return new IpcEventsMain(scope, gotEventSlot);\n  }\n}\n\nIpcEventsAspect.addRuntime(IpcEventsMain);\n\nexport default IpcEventsMain;\n"],"mappings":";;;;;;;;;;;;;;;;AAAA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AAOA,MAAMA,UAAU,GAAG,QAAQ;;AAE3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMC,aAAa,CAAC;EACzBC,WAAW,CAASC,KAAgB,EAAUC,YAA0B,EAAE;IAAA,KAAtDD,KAAgB,GAAhBA,KAAgB;IAAA,KAAUC,YAA0B,GAA1BA,YAA0B;EAAG;EAE3EC,oBAAoB,CAACC,EAAY,EAAE;IACjC,IAAI,CAACF,YAAY,CAACG,QAAQ,CAACD,EAAE,CAAC;EAChC;EAEA,MAAME,eAAe,CAACC,SAAoB,EAAE;IAC1C,MAAM,IAAAC,qBAAU,EAAC,IAAI,CAACN,YAAY,CAACO,MAAM,EAAE,EAAGL,EAAE,IAAKA,EAAE,CAACG,SAAS,CAAC,CAAC;EACrE;;EAEA;AACF;AACA;AACA;EACE,MAAMG,eAAe,CAACH,SAAoB,EAAEI,IAA0B,EAAE;IACtE,MAAMC,QAAQ,GAAGC,eAAI,CAACC,IAAI,CAAC,IAAI,CAACC,SAAS,EAAER,SAAS,CAAC;IACrD,MAAMS,OAAO,GAAGL,IAAI,GAAGM,IAAI,CAACC,SAAS,CAACP,IAAI,EAAEQ,SAAS,EAAE,CAAC,CAAC,GAAG,EAAE;IAC9D,MAAMC,kBAAE,CAACC,UAAU,CAACT,QAAQ,EAAEI,OAAO,CAAC;EACxC;EAEA,IAAID,SAAS,GAAG;IACd,OAAOF,eAAI,CAACC,IAAI,CAAC,IAAI,CAACb,KAAK,CAACY,IAAI,EAAEf,UAAU,CAAC;EAC/C;EAMA,aAAawB,QAAQ,CAAC,CAACrB,KAAK,CAAc,EAAEsB,CAAC,EAAE,CAACrB,YAAY,CAAiB,EAAE;IAC7E,OAAO,IAAIH,aAAa,CAACE,KAAK,EAAEC,YAAY,CAAC;EAC/C;AACF;AAAC;AAAA,gCAhCYH,aAAa,WAyBT,CAACyB,eAAI,CAACC,QAAQ,EAAgB,CAAC;AAAA,gCAzBnC1B,aAAa,kBA0BF,CAAC2B,gBAAW,CAAC;AAAA,gCA1BxB3B,aAAa,aA2BP4B,kBAAW;AAO9BC,4BAAe,CAACC,UAAU,CAAC9B,aAAa,CAAC;AAAC,eAE3BA,aAAa;AAAA"}

package/dist/preview-1689823719636.js

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

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@teambit/ipc-events",
+  "version": "0.0.1",
+  "main": "dist/index.js",
+  "componentId": {
+    "scope": "teambit.harmony",
+    "name": "ipc-events",
+    "version": "0.0.1"
+  },
+  "dependencies": {
+    "fs-extra": "10.0.0",
+    "p-map-series": "2.1.0",
+    "core-js": "^3.0.0",
+    "@babel/runtime": "7.20.0",
+    "@teambit/harmony": "0.4.6",
+    "@teambit/cli": "0.0.743",
+    "@teambit/scope": "0.0.1111"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "9.0.7",
+    "@types/mocha": "9.1.0",
+    "@types/node": "12.20.4",
+    "@types/react": "^17.0.8",
+    "@types/react-dom": "^17.0.5",
+    "@types/jest": "^26.0.0",
+    "@types/testing-library__jest-dom": "5.9.5"
+  },
+  "peerDependencies": {
+    "@teambit/legacy": "1.0.523",
+    "react": "^16.8.0 || ^17.0.0",
+    "react-dom": "^16.8.0 || ^17.0.0"
+  },
+  "license": "Apache-2.0",
+  "private": false,
+  "engines": {
+    "node": ">=12.22.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/teambit/bit"
+  },
+  "keywords": [
+    "bit",
+    "bit-aspect",
+    "components",
+    "collaboration",
+    "web",
+    "react",
+    "react-components",
+    "angular",
+    "angular-components"
+  ]
+}

package/tsconfig.json

@@ -0,0 +1,40 @@
+{
+  "compilerOptions": {
+    "lib": [
+      "es2019",
+      "DOM",
+      "ES6",
+      "DOM.Iterable",
+      "ScriptHost"
+    ],
+    "target": "es2015",
+    "module": "CommonJS",
+    "jsx": "react",
+    "allowJs": true,
+    "composite": true,
+    "declaration": true,
+    "sourceMap": true,
+    "skipLibCheck": true,
+    "experimentalDecorators": true,
+    "outDir": "dist",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "rootDir": ".",
+    "resolveJsonModule": true,
+    "emitDeclarationOnly": true,
+    "emitDecoratorMetadata": true,
+    "allowSyntheticDefaultImports": true,
+    "strictPropertyInitialization": false,
+    "strict": true,
+    "noImplicitAny": false,
+    "preserveConstEnums": true
+  },
+  "exclude": [
+    "dist",
+    "package.json"
+  ],
+  "include": [
+    "**/*",
+    "**/*.json"
+  ]
+}

package/types/asset.d.ts

@@ -0,0 +1,29 @@
+declare module '*.png' {
+  const value: any;
+  export = value;
+}
+declare module '*.svg' {
+  import type { FunctionComponent, SVGProps } from 'react';
+
+  export const ReactComponent: FunctionComponent<SVGProps<SVGSVGElement> & { title?: string }>;
+  const src: string;
+  export default src;
+}
+
+// @TODO Gilad
+declare module '*.jpg' {
+  const value: any;
+  export = value;
+}
+declare module '*.jpeg' {
+  const value: any;
+  export = value;
+}
+declare module '*.gif' {
+  const value: any;
+  export = value;
+}
+declare module '*.bmp' {
+  const value: any;
+  export = value;
+}

package/types/style.d.ts

@@ -0,0 +1,42 @@
+declare module '*.module.css' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+declare module '*.module.scss' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+declare module '*.module.sass' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.module.less' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.less' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.css' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.sass' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.scss' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.mdx' {
+  const component: any;
+  export default component;
+}