@botpress/adk-cli 1.3.0 → 1.4.0

package/dist/bp-cli/dist/utils/case-utils.js

@@ -0,0 +1,84 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to2, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to2, key) && key !== except)
+        __defProp(to2, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to2;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var case_utils_exports = {};
+__export(case_utils_exports, {
+  is: () => is,
+  to: () => to
+});
+module.exports = __toCommonJS(case_utils_exports);
+var import_lodash = __toESM(require("lodash"));
+const specialChars = /[^a-zA-Z0-9_-]/g;
+const capitalizeFirstLetter = (text) => text.charAt(0).toUpperCase() + text.slice(1).toLowerCase();
+const splitChar = (char) => (tokens) => tokens.flatMap((token) => token.split(char));
+const splitRegex = (regex) => (tokens) => tokens.flatMap((token) => token.split(regex));
+const splitCaseChange = (tokens) => tokens.flatMap((token) => token.split(/(?<=[a-z])(?=[A-Z])/));
+const splitTokens = (tokens) => {
+  return [splitRegex(specialChars), splitChar("-"), splitChar("_"), splitCaseChange].reduce(
+    (acc, step) => step(acc),
+    tokens
+  );
+};
+const filterOutEmpty = (tokens) => tokens.filter((token) => token.length > 0);
+const filterOutRegex = (regex) => (tokens) => tokens.filter((token) => !regex.test(token));
+const filterTokens = (tokens) => {
+  return [filterOutEmpty, filterOutRegex(specialChars)].reduce((acc, step) => step(acc), tokens);
+};
+const fromTokens = {
+  pascalCase: (tokens) => {
+    return tokens.map(capitalizeFirstLetter).join("");
+  },
+  kebabCase: (tokens) => {
+    return tokens.map((token) => token.toLowerCase()).join("-");
+  },
+  snakeCase: (tokens) => {
+    return tokens.map((token) => token.toLowerCase()).join("_");
+  },
+  screamingSnakeCase: (tokens) => {
+    return tokens.map((token) => token.toUpperCase()).join("_");
+  },
+  camelCase: (tokens) => {
+    const [first, ...others] = tokens;
+    return [first.toLowerCase(), ...others.map(capitalizeFirstLetter)].join("");
+  }
+};
+const to = import_lodash.default.mapValues(fromTokens, (fn) => (text) => {
+  let tokens = splitTokens([text]);
+  tokens = filterTokens(tokens);
+  return fn(tokens);
+});
+const is = import_lodash.default.mapValues(to, (fn) => (text) => {
+  const result = fn(text);
+  return result === text;
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  is,
+  to
+});
+//# sourceMappingURL=case-utils.js.map

package/dist/bp-cli/dist/utils/case-utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/case-utils.ts"],
+  "sourcesContent": ["import _ from 'lodash'\n\nconst specialChars = /[^a-zA-Z0-9_-]/g\n\nconst capitalizeFirstLetter = (text: string) => text.charAt(0).toUpperCase() + text.slice(1).toLowerCase()\n\nconst splitChar = (char: string) => (tokens: string[]) => tokens.flatMap((token) => token.split(char))\nconst splitRegex = (regex: RegExp) => (tokens: string[]) => tokens.flatMap((token) => token.split(regex))\nconst splitCaseChange = (tokens: string[]) => tokens.flatMap((token) => token.split(/(?<=[a-z])(?=[A-Z])/))\nconst splitTokens = (tokens: string[]) => {\n  return [splitRegex(specialChars), splitChar('-'), splitChar('_'), splitCaseChange].reduce(\n    (acc, step) => step(acc),\n    tokens\n  )\n}\n\nconst filterOutEmpty = (tokens: string[]) => tokens.filter((token) => token.length > 0)\nconst filterOutRegex = (regex: RegExp) => (tokens: string[]) => tokens.filter((token) => !regex.test(token))\nconst filterTokens = (tokens: string[]) => {\n  return [filterOutEmpty, filterOutRegex(specialChars)].reduce((acc, step) => step(acc), tokens)\n}\n\ntype SupportedCase = `${'pascal' | 'kebab' | 'snake' | 'screamingSnake' | 'camel'}Case`\n\nconst fromTokens = {\n  pascalCase: (tokens: string[]) => {\n    return tokens.map(capitalizeFirstLetter).join('')\n  },\n  kebabCase: (tokens: string[]) => {\n    return tokens.map((token) => token.toLowerCase()).join('-')\n  },\n  snakeCase: (tokens: string[]) => {\n    return tokens.map((token) => token.toLowerCase()).join('_')\n  },\n  screamingSnakeCase: (tokens: string[]) => {\n    return tokens.map((token) => token.toUpperCase()).join('_')\n  },\n  camelCase: (tokens: string[]) => {\n    const [first, ...others] = tokens\n    return [first!.toLowerCase(), ...others.map(capitalizeFirstLetter)].join('')\n  },\n} as Record<SupportedCase, (tokens: string[]) => string>\n\nexport const to = _.mapValues(fromTokens, (fn) => (text: string) => {\n  let tokens = splitTokens([text])\n  tokens = filterTokens(tokens)\n  return fn(tokens)\n}) satisfies Record<SupportedCase, (text: string) => string>\n\nexport const is = _.mapValues(to, (fn) => (text: string) => {\n  const result = fn(text)\n  return result === text\n}) satisfies Record<SupportedCase, (text: string) => boolean>\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAc;AAEd,MAAM,eAAe;AAErB,MAAM,wBAAwB,CAAC,SAAiB,KAAK,OAAO,CAAC,EAAE,YAAY,IAAI,KAAK,MAAM,CAAC,EAAE,YAAY;AAEzG,MAAM,YAAY,CAAC,SAAiB,CAAC,WAAqB,OAAO,QAAQ,CAAC,UAAU,MAAM,MAAM,IAAI,CAAC;AACrG,MAAM,aAAa,CAAC,UAAkB,CAAC,WAAqB,OAAO,QAAQ,CAAC,UAAU,MAAM,MAAM,KAAK,CAAC;AACxG,MAAM,kBAAkB,CAAC,WAAqB,OAAO,QAAQ,CAAC,UAAU,MAAM,MAAM,qBAAqB,CAAC;AAC1G,MAAM,cAAc,CAAC,WAAqB;AACxC,SAAO,CAAC,WAAW,YAAY,GAAG,UAAU,GAAG,GAAG,UAAU,GAAG,GAAG,eAAe,EAAE;AAAA,IACjF,CAAC,KAAK,SAAS,KAAK,GAAG;AAAA,IACvB;AAAA,EACF;AACF;AAEA,MAAM,iBAAiB,CAAC,WAAqB,OAAO,OAAO,CAAC,UAAU,MAAM,SAAS,CAAC;AACtF,MAAM,iBAAiB,CAAC,UAAkB,CAAC,WAAqB,OAAO,OAAO,CAAC,UAAU,CAAC,MAAM,KAAK,KAAK,CAAC;AAC3G,MAAM,eAAe,CAAC,WAAqB;AACzC,SAAO,CAAC,gBAAgB,eAAe,YAAY,CAAC,EAAE,OAAO,CAAC,KAAK,SAAS,KAAK,GAAG,GAAG,MAAM;AAC/F;AAIA,MAAM,aAAa;AAAA,EACjB,YAAY,CAAC,WAAqB;AAChC,WAAO,OAAO,IAAI,qBAAqB,EAAE,KAAK,EAAE;AAAA,EAClD;AAAA,EACA,WAAW,CAAC,WAAqB;AAC/B,WAAO,OAAO,IAAI,CAAC,UAAU,MAAM,YAAY,CAAC,EAAE,KAAK,GAAG;AAAA,EAC5D;AAAA,EACA,WAAW,CAAC,WAAqB;AAC/B,WAAO,OAAO,IAAI,CAAC,UAAU,MAAM,YAAY,CAAC,EAAE,KAAK,GAAG;AAAA,EAC5D;AAAA,EACA,oBAAoB,CAAC,WAAqB;AACxC,WAAO,OAAO,IAAI,CAAC,UAAU,MAAM,YAAY,CAAC,EAAE,KAAK,GAAG;AAAA,EAC5D;AAAA,EACA,WAAW,CAAC,WAAqB;AAC/B,UAAM,CAAC,OAAO,GAAG,MAAM,IAAI;AAC3B,WAAO,CAAC,MAAO,YAAY,GAAG,GAAG,OAAO,IAAI,qBAAqB,CAAC,EAAE,KAAK,EAAE;AAAA,EAC7E;AACF;AAEO,MAAM,KAAK,cAAAA,QAAE,UAAU,YAAY,CAAC,OAAO,CAAC,SAAiB;AAClE,MAAI,SAAS,YAAY,CAAC,IAAI,CAAC;AAC/B,WAAS,aAAa,MAAM;AAC5B,SAAO,GAAG,MAAM;AAClB,CAAC;AAEM,MAAM,KAAK,cAAAA,QAAE,UAAU,IAAI,CAAC,OAAO,CAAC,SAAiB;AAC1D,QAAM,SAAS,GAAG,IAAI;AACtB,SAAO,WAAW;AACpB,CAAC;",
+  "names": ["_"]
+}

package/dist/bp-cli/dist/utils/case-utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/bp-cli/dist/utils/case-utils.test.js

@@ -0,0 +1,75 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_vitest = require("vitest");
+var caseUtils = __toESM(require("./case-utils"));
+const pascalCase = "HelloLittleWorld";
+const kebabCase = "hello-little-world";
+const snakeCase = "hello_little_world";
+const screamingSnakeCase = "HELLO_LITTLE_WORLD";
+const camelCase = "helloLittleWorld";
+(0, import_vitest.test)("case utils should convert from pascal case to all other cases", () => {
+  (0, import_vitest.expect)(caseUtils.to.kebabCase(pascalCase)).toBe(kebabCase);
+  (0, import_vitest.expect)(caseUtils.to.snakeCase(pascalCase)).toBe(snakeCase);
+  (0, import_vitest.expect)(caseUtils.to.screamingSnakeCase(pascalCase)).toBe(screamingSnakeCase);
+  (0, import_vitest.expect)(caseUtils.to.camelCase(pascalCase)).toBe(camelCase);
+});
+(0, import_vitest.test)("case utils should convert from kebab case to all other cases", () => {
+  (0, import_vitest.expect)(caseUtils.to.pascalCase(kebabCase)).toBe(pascalCase);
+  (0, import_vitest.expect)(caseUtils.to.snakeCase(kebabCase)).toBe(snakeCase);
+  (0, import_vitest.expect)(caseUtils.to.screamingSnakeCase(kebabCase)).toBe(screamingSnakeCase);
+  (0, import_vitest.expect)(caseUtils.to.camelCase(kebabCase)).toBe(camelCase);
+});
+(0, import_vitest.test)("case utils should convert from snake case to all other cases", () => {
+  (0, import_vitest.expect)(caseUtils.to.pascalCase(snakeCase)).toBe(pascalCase);
+  (0, import_vitest.expect)(caseUtils.to.kebabCase(snakeCase)).toBe(kebabCase);
+  (0, import_vitest.expect)(caseUtils.to.screamingSnakeCase(snakeCase)).toBe(screamingSnakeCase);
+  (0, import_vitest.expect)(caseUtils.to.camelCase(snakeCase)).toBe(camelCase);
+});
+(0, import_vitest.test)("case utils should convert from screaming snake case to all other cases", () => {
+  (0, import_vitest.expect)(caseUtils.to.pascalCase(screamingSnakeCase)).toBe(pascalCase);
+  (0, import_vitest.expect)(caseUtils.to.kebabCase(screamingSnakeCase)).toBe(kebabCase);
+  (0, import_vitest.expect)(caseUtils.to.snakeCase(screamingSnakeCase)).toBe(snakeCase);
+  (0, import_vitest.expect)(caseUtils.to.camelCase(screamingSnakeCase)).toBe(camelCase);
+});
+(0, import_vitest.test)("case utils should convert from camel case to all other cases", () => {
+  (0, import_vitest.expect)(caseUtils.to.pascalCase(camelCase)).toBe(pascalCase);
+  (0, import_vitest.expect)(caseUtils.to.kebabCase(camelCase)).toBe(kebabCase);
+  (0, import_vitest.expect)(caseUtils.to.snakeCase(camelCase)).toBe(snakeCase);
+  (0, import_vitest.expect)(caseUtils.to.screamingSnakeCase(camelCase)).toBe(screamingSnakeCase);
+});
+(0, import_vitest.test)("case utils should split special characters when converting", () => {
+  (0, import_vitest.expect)(caseUtils.to.pascalCase(`${pascalCase}.2`)).toBe(`${pascalCase}2`);
+  (0, import_vitest.expect)(caseUtils.to.kebabCase(`${kebabCase}.2`)).toBe(`${kebabCase}-2`);
+  (0, import_vitest.expect)(caseUtils.to.snakeCase(`${snakeCase}.2`)).toBe(`${snakeCase}_2`);
+  (0, import_vitest.expect)(caseUtils.to.screamingSnakeCase(`${screamingSnakeCase}.2`)).toBe(`${screamingSnakeCase}_2`);
+  (0, import_vitest.expect)(caseUtils.to.camelCase(`${camelCase}.2`)).toBe(`${camelCase}2`);
+});
+(0, import_vitest.test)("case utils should prevent special characters when checking", () => {
+  (0, import_vitest.expect)(caseUtils.is.pascalCase(`${pascalCase}.2`)).toBe(false);
+  (0, import_vitest.expect)(caseUtils.is.kebabCase(`${kebabCase}.2`)).toBe(false);
+  (0, import_vitest.expect)(caseUtils.is.snakeCase(`${snakeCase}.2`)).toBe(false);
+  (0, import_vitest.expect)(caseUtils.is.screamingSnakeCase(`${screamingSnakeCase}.2`)).toBe(false);
+  (0, import_vitest.expect)(caseUtils.is.camelCase(`${camelCase}.2`)).toBe(false);
+});
+//# sourceMappingURL=case-utils.test.js.map

package/dist/bp-cli/dist/utils/case-utils.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/case-utils.test.ts"],
+  "sourcesContent": ["import { test, expect } from 'vitest'\nimport * as caseUtils from './case-utils'\n\nconst pascalCase = 'HelloLittleWorld'\nconst kebabCase = 'hello-little-world'\nconst snakeCase = 'hello_little_world'\nconst screamingSnakeCase = 'HELLO_LITTLE_WORLD'\nconst camelCase = 'helloLittleWorld'\n\ntest('case utils should convert from pascal case to all other cases', () => {\n  expect(caseUtils.to.kebabCase(pascalCase)).toBe(kebabCase)\n  expect(caseUtils.to.snakeCase(pascalCase)).toBe(snakeCase)\n  expect(caseUtils.to.screamingSnakeCase(pascalCase)).toBe(screamingSnakeCase)\n  expect(caseUtils.to.camelCase(pascalCase)).toBe(camelCase)\n})\n\ntest('case utils should convert from kebab case to all other cases', () => {\n  expect(caseUtils.to.pascalCase(kebabCase)).toBe(pascalCase)\n  expect(caseUtils.to.snakeCase(kebabCase)).toBe(snakeCase)\n  expect(caseUtils.to.screamingSnakeCase(kebabCase)).toBe(screamingSnakeCase)\n  expect(caseUtils.to.camelCase(kebabCase)).toBe(camelCase)\n})\n\ntest('case utils should convert from snake case to all other cases', () => {\n  expect(caseUtils.to.pascalCase(snakeCase)).toBe(pascalCase)\n  expect(caseUtils.to.kebabCase(snakeCase)).toBe(kebabCase)\n  expect(caseUtils.to.screamingSnakeCase(snakeCase)).toBe(screamingSnakeCase)\n  expect(caseUtils.to.camelCase(snakeCase)).toBe(camelCase)\n})\n\ntest('case utils should convert from screaming snake case to all other cases', () => {\n  expect(caseUtils.to.pascalCase(screamingSnakeCase)).toBe(pascalCase)\n  expect(caseUtils.to.kebabCase(screamingSnakeCase)).toBe(kebabCase)\n  expect(caseUtils.to.snakeCase(screamingSnakeCase)).toBe(snakeCase)\n  expect(caseUtils.to.camelCase(screamingSnakeCase)).toBe(camelCase)\n})\n\ntest('case utils should convert from camel case to all other cases', () => {\n  expect(caseUtils.to.pascalCase(camelCase)).toBe(pascalCase)\n  expect(caseUtils.to.kebabCase(camelCase)).toBe(kebabCase)\n  expect(caseUtils.to.snakeCase(camelCase)).toBe(snakeCase)\n  expect(caseUtils.to.screamingSnakeCase(camelCase)).toBe(screamingSnakeCase)\n})\n\ntest('case utils should split special characters when converting', () => {\n  expect(caseUtils.to.pascalCase(`${pascalCase}.2`)).toBe(`${pascalCase}2`)\n  expect(caseUtils.to.kebabCase(`${kebabCase}.2`)).toBe(`${kebabCase}-2`)\n  expect(caseUtils.to.snakeCase(`${snakeCase}.2`)).toBe(`${snakeCase}_2`)\n  expect(caseUtils.to.screamingSnakeCase(`${screamingSnakeCase}.2`)).toBe(`${screamingSnakeCase}_2`)\n  expect(caseUtils.to.camelCase(`${camelCase}.2`)).toBe(`${camelCase}2`)\n})\n\ntest('case utils should prevent special characters when checking', () => {\n  expect(caseUtils.is.pascalCase(`${pascalCase}.2`)).toBe(false)\n  expect(caseUtils.is.kebabCase(`${kebabCase}.2`)).toBe(false)\n  expect(caseUtils.is.snakeCase(`${snakeCase}.2`)).toBe(false)\n  expect(caseUtils.is.screamingSnakeCase(`${screamingSnakeCase}.2`)).toBe(false)\n  expect(caseUtils.is.camelCase(`${camelCase}.2`)).toBe(false)\n})\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/bp-cli/dist/utils/concurrency-utils.d.ts

@@ -0,0 +1 @@
+export declare const debounceAsync: <TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => Promise<TReturn>, ms: number) => ((...args: TArgs) => Promise<TReturn>);

package/dist/bp-cli/dist/utils/concurrency-utils.js

@@ -0,0 +1,41 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var concurrency_utils_exports = {};
+__export(concurrency_utils_exports, {
+  debounceAsync: () => debounceAsync
+});
+module.exports = __toCommonJS(concurrency_utils_exports);
+const debounceAsync = (fn, ms) => {
+  let timeout = null;
+  return async function(...args) {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+    return new Promise((resolve, reject) => {
+      timeout = setTimeout(() => {
+        fn.apply(this, args).then(resolve, reject);
+      }, ms);
+    });
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  debounceAsync
+});
+//# sourceMappingURL=concurrency-utils.js.map

package/dist/bp-cli/dist/utils/concurrency-utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/concurrency-utils.ts"],
+  "sourcesContent": ["export const debounceAsync = <TArgs extends unknown[], TReturn>(\n  fn: (...args: TArgs) => Promise<TReturn>,\n  ms: number\n): ((...args: TArgs) => Promise<TReturn>) => {\n  let timeout: NodeJS.Timeout | null = null\n\n  return async function (this: unknown, ...args: TArgs): Promise<TReturn> {\n    if (timeout) {\n      clearTimeout(timeout)\n    }\n    return new Promise<TReturn>((resolve, reject) => {\n      timeout = setTimeout(() => {\n        fn.apply(this, args).then(resolve, reject)\n      }, ms)\n    })\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,MAAM,gBAAgB,CAC3B,IACA,OAC2C;AAC3C,MAAI,UAAiC;AAErC,SAAO,kBAAkC,MAA+B;AACtE,QAAI,SAAS;AACX,mBAAa,OAAO;AAAA,IACtB;AACA,WAAO,IAAI,QAAiB,CAAC,SAAS,WAAW;AAC/C,gBAAU,WAAW,MAAM;AACzB,WAAG,MAAM,MAAM,IAAI,EAAE,KAAK,SAAS,MAAM;AAAA,MAC3C,GAAG,EAAE;AAAA,IACP,CAAC;AAAA,EACH;AACF;",
+  "names": []
+}

package/dist/bp-cli/dist/utils/concurrency-utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/bp-cli/dist/utils/concurrency-utils.test.js

@@ -0,0 +1,49 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_concurrency_utils = require("./concurrency-utils");
+const TIMEOUT_MS = 100;
+(0, import_vitest.describe)("debounceAsync", () => {
+  (0, import_vitest.beforeEach)(() => {
+    import_vitest.vi.useFakeTimers();
+  });
+  (0, import_vitest.afterEach)(async () => {
+    import_vitest.vi.useRealTimers();
+    import_vitest.vi.restoreAllMocks();
+  });
+  (0, import_vitest.it)("should not execute function before delay", async () => {
+    const fn = import_vitest.vi.fn().mockResolvedValue("result");
+    const debouncedFn = (0, import_concurrency_utils.debounceAsync)(fn, TIMEOUT_MS);
+    debouncedFn("a");
+    await import_vitest.vi.advanceTimersByTimeAsync(TIMEOUT_MS - 1);
+    (0, import_vitest.expect)(fn).not.toHaveBeenCalled();
+  });
+  (0, import_vitest.it)("should execute function only once after delay", async () => {
+    const fn = import_vitest.vi.fn().mockResolvedValue("result");
+    const debouncedFn = (0, import_concurrency_utils.debounceAsync)(fn, TIMEOUT_MS);
+    debouncedFn("a");
+    debouncedFn("b");
+    await import_vitest.vi.advanceTimersByTimeAsync(TIMEOUT_MS - 1);
+    debouncedFn("c");
+    await import_vitest.vi.advanceTimersByTimeAsync(TIMEOUT_MS);
+    (0, import_vitest.expect)(fn).toHaveBeenCalledTimes(1);
+    (0, import_vitest.expect)(fn).toHaveBeenCalledWith("c");
+  });
+  (0, import_vitest.it)("should preserve `this` context", async () => {
+    const context = { value: 42 };
+    const fn = import_vitest.vi.fn(function() {
+      return Promise.resolve(this.value);
+    });
+    const debouncedFn = (0, import_concurrency_utils.debounceAsync)(fn, TIMEOUT_MS);
+    const promise = debouncedFn.call(context);
+    await import_vitest.vi.advanceTimersByTimeAsync(TIMEOUT_MS);
+    await (0, import_vitest.expect)(promise).resolves.toBe(42);
+  });
+  (0, import_vitest.it)("should handle rejections", async () => {
+    const error = new Error("test rejection");
+    const fn = import_vitest.vi.fn().mockRejectedValue(error);
+    const debouncedFn = (0, import_concurrency_utils.debounceAsync)(fn, 1);
+    import_vitest.vi.useRealTimers();
+    await (0, import_vitest.expect)(debouncedFn).rejects.toThrow(error);
+  });
+});
+//# sourceMappingURL=concurrency-utils.test.js.map

package/dist/bp-cli/dist/utils/concurrency-utils.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/concurrency-utils.test.ts"],
+  "sourcesContent": ["import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'\nimport { debounceAsync } from './concurrency-utils'\n\nconst TIMEOUT_MS = 100\n\ndescribe('debounceAsync', () => {\n  beforeEach(() => {\n    vi.useFakeTimers()\n  })\n\n  afterEach(async () => {\n    vi.useRealTimers()\n    vi.restoreAllMocks()\n  })\n\n  it('should not execute function before delay', async () => {\n    // Arrange\n    const fn = vi.fn().mockResolvedValue('result')\n    const debouncedFn = debounceAsync(fn, TIMEOUT_MS)\n\n    // Act\n    debouncedFn('a')\n    await vi.advanceTimersByTimeAsync(TIMEOUT_MS - 1)\n\n    // Assert\n    expect(fn).not.toHaveBeenCalled()\n  })\n\n  it('should execute function only once after delay', async () => {\n    // Arrange\n    const fn = vi.fn().mockResolvedValue('result')\n    const debouncedFn = debounceAsync(fn, TIMEOUT_MS)\n\n    // Act\n    debouncedFn('a')\n    debouncedFn('b')\n    await vi.advanceTimersByTimeAsync(TIMEOUT_MS - 1)\n    debouncedFn('c')\n    await vi.advanceTimersByTimeAsync(TIMEOUT_MS)\n\n    // Assert\n    expect(fn).toHaveBeenCalledTimes(1)\n    expect(fn).toHaveBeenCalledWith('c')\n  })\n\n  it('should preserve `this` context', async () => {\n    // Arrange\n    const context = { value: 42 }\n    const fn = vi.fn(function (this: typeof context) {\n      return Promise.resolve(this.value)\n    })\n    const debouncedFn = debounceAsync(fn, TIMEOUT_MS)\n\n    // Act\n    const promise = debouncedFn.call(context)\n\n    await vi.advanceTimersByTimeAsync(TIMEOUT_MS)\n\n    // Assert\n    await expect(promise).resolves.toBe(42)\n  })\n\n  it('should handle rejections', async () => {\n    // Arrange\n    const error = new Error('test rejection')\n    const fn = vi.fn().mockRejectedValue(error)\n    const debouncedFn = debounceAsync(fn, 1)\n    vi.useRealTimers()\n\n    // Act & Assert\n    await expect(debouncedFn).rejects.toThrow(error)\n  })\n})\n"],
+  "mappings": ";AAAA,oBAAgE;AAChE,+BAA8B;AAE9B,MAAM,aAAa;AAAA,IAEnB,wBAAS,iBAAiB,MAAM;AAC9B,gCAAW,MAAM;AACf,qBAAG,cAAc;AAAA,EACnB,CAAC;AAED,+BAAU,YAAY;AACpB,qBAAG,cAAc;AACjB,qBAAG,gBAAgB;AAAA,EACrB,CAAC;AAED,wBAAG,4CAA4C,YAAY;AAEzD,UAAM,KAAK,iBAAG,GAAG,EAAE,kBAAkB,QAAQ;AAC7C,UAAM,kBAAc,wCAAc,IAAI,UAAU;AAGhD,gBAAY,GAAG;AACf,UAAM,iBAAG,yBAAyB,aAAa,CAAC;AAGhD,8BAAO,EAAE,EAAE,IAAI,iBAAiB;AAAA,EAClC,CAAC;AAED,wBAAG,iDAAiD,YAAY;AAE9D,UAAM,KAAK,iBAAG,GAAG,EAAE,kBAAkB,QAAQ;AAC7C,UAAM,kBAAc,wCAAc,IAAI,UAAU;AAGhD,gBAAY,GAAG;AACf,gBAAY,GAAG;AACf,UAAM,iBAAG,yBAAyB,aAAa,CAAC;AAChD,gBAAY,GAAG;AACf,UAAM,iBAAG,yBAAyB,UAAU;AAG5C,8BAAO,EAAE,EAAE,sBAAsB,CAAC;AAClC,8BAAO,EAAE,EAAE,qBAAqB,GAAG;AAAA,EACrC,CAAC;AAED,wBAAG,kCAAkC,YAAY;AAE/C,UAAM,UAAU,EAAE,OAAO,GAAG;AAC5B,UAAM,KAAK,iBAAG,GAAG,WAAgC;AAC/C,aAAO,QAAQ,QAAQ,KAAK,KAAK;AAAA,IACnC,CAAC;AACD,UAAM,kBAAc,wCAAc,IAAI,UAAU;AAGhD,UAAM,UAAU,YAAY,KAAK,OAAO;AAExC,UAAM,iBAAG,yBAAyB,UAAU;AAG5C,cAAM,sBAAO,OAAO,EAAE,SAAS,KAAK,EAAE;AAAA,EACxC,CAAC;AAED,wBAAG,4BAA4B,YAAY;AAEzC,UAAM,QAAQ,IAAI,MAAM,gBAAgB;AACxC,UAAM,KAAK,iBAAG,GAAG,EAAE,kBAAkB,KAAK;AAC1C,UAAM,kBAAc,wCAAc,IAAI,CAAC;AACvC,qBAAG,cAAc;AAGjB,cAAM,sBAAO,WAAW,EAAE,QAAQ,QAAQ,KAAK;AAAA,EACjD,CAAC;AACH,CAAC;",
+  "names": []
+}

package/dist/bp-cli/dist/utils/esbuild-utils.d.ts

@@ -0,0 +1,35 @@
+import * as esb from 'esbuild';
+export * from 'esbuild';
+type BaseProps = {
+    absWorkingDir: string;
+};
+export type BuildCodeProps = BaseProps & {
+    code: string;
+    outfile: string;
+};
+export type BuildEntrypointProps = BaseProps & {
+    entrypoint: string;
+};
+export declare abstract class BuildContext<T> {
+    private _context;
+    private _previousProps;
+    private _previousOpts;
+    protected abstract _createContext(props: T, opts: esb.BuildOptions): Promise<esb.BuildContext>;
+    rebuild(props: T, opts?: esb.BuildOptions): Promise<esb.BuildResult<esb.BuildOptions>>;
+}
+export declare class BuildCodeContext extends BuildContext<BuildCodeProps> {
+    protected _createContext(props: BuildCodeProps, opts?: esb.BuildOptions): Promise<esb.BuildContext>;
+}
+export declare class BuildEntrypointContext extends BuildContext<BuildEntrypointProps> {
+    protected _createContext(props: BuildEntrypointProps, opts?: esb.BuildOptions): Promise<esb.BuildContext>;
+}
+/**
+ * Bundles a string of typescript code and writes the output to a file
+ */
+export declare function buildCode(props: BuildCodeProps, opts?: esb.BuildOptions): Promise<esb.BuildResult>;
+/**
+ * Bundles a typescript file and returns the output as a string
+ */
+export declare function buildEntrypoint(props: BuildEntrypointProps, opts?: esb.BuildOptions): Promise<esb.BuildResult & {
+    outputFiles: esb.OutputFile[];
+}>;

package/dist/bp-cli/dist/utils/esbuild-utils.js

@@ -0,0 +1,127 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var esbuild_utils_exports = {};
+__export(esbuild_utils_exports, {
+  BuildCodeContext: () => BuildCodeContext,
+  BuildContext: () => BuildContext,
+  BuildEntrypointContext: () => BuildEntrypointContext,
+  buildCode: () => buildCode,
+  buildEntrypoint: () => buildEntrypoint
+});
+module.exports = __toCommonJS(esbuild_utils_exports);
+var esb = __toESM(require("esbuild"));
+var import_lodash = __toESM(require("lodash"));
+__reExport(esbuild_utils_exports, require("esbuild"), module.exports);
+const DEFAULT_OPTIONS = {
+  bundle: true,
+  sourcemap: false,
+  logLevel: "silent",
+  platform: "node",
+  target: "es2020",
+  legalComments: "none",
+  logOverride: { "equals-negative-zero": "silent" },
+  keepNames: true,
+  // important : https://github.com/node-fetch/node-fetch/issues/784#issuecomment-1014768204
+  minify: false
+};
+class BuildContext {
+  _context;
+  _previousProps;
+  _previousOpts = {};
+  async rebuild(props, opts = {}) {
+    if (!this._context || !import_lodash.default.isEqual(props, this._previousProps) || !import_lodash.default.isEqual(opts, this._previousOpts)) {
+      if (this._context) {
+        await this._context.dispose();
+      }
+      this._context = await this._createContext(props, opts);
+      this._previousOpts = opts;
+      this._previousProps = props;
+    }
+    return await this._context?.rebuild();
+  }
+}
+class BuildCodeContext extends BuildContext {
+  _createContext(props, opts = {}) {
+    const { absWorkingDir, code, outfile } = props;
+    return esb.context({
+      ...DEFAULT_OPTIONS,
+      ...opts,
+      absWorkingDir,
+      outfile,
+      stdin: { contents: code, resolveDir: absWorkingDir, loader: "ts" },
+      write: true
+    });
+  }
+}
+class BuildEntrypointContext extends BuildContext {
+  _createContext(props, opts = {}) {
+    const { absWorkingDir, entrypoint } = props;
+    return esb.context({
+      ...DEFAULT_OPTIONS,
+      ...opts,
+      absWorkingDir,
+      entryPoints: [entrypoint],
+      outfile: void 0,
+      write: false
+    });
+  }
+}
+function buildCode(props, opts = {}) {
+  const { absWorkingDir, code, outfile } = props;
+  return esb.build({
+    ...DEFAULT_OPTIONS,
+    ...opts,
+    absWorkingDir,
+    outfile,
+    stdin: { contents: code, resolveDir: absWorkingDir, loader: "ts" },
+    write: true
+  });
+}
+function buildEntrypoint(props, opts = {}) {
+  const { absWorkingDir, entrypoint } = props;
+  return esb.build({
+    ...DEFAULT_OPTIONS,
+    ...opts,
+    absWorkingDir,
+    entryPoints: [entrypoint],
+    outfile: void 0,
+    write: false
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BuildCodeContext,
+  BuildContext,
+  BuildEntrypointContext,
+  buildCode,
+  buildEntrypoint,
+  ...require("esbuild")
+});
+//# sourceMappingURL=esbuild-utils.js.map

package/dist/bp-cli/dist/utils/esbuild-utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/esbuild-utils.ts"],
+  "sourcesContent": ["import * as esb from 'esbuild'\nimport _ from 'lodash'\n\nexport * from 'esbuild'\n\ntype BaseProps = {\n  absWorkingDir: string\n}\n\nexport type BuildCodeProps = BaseProps & {\n  code: string\n  outfile: string\n}\n\nexport type BuildEntrypointProps = BaseProps & {\n  entrypoint: string\n}\n\nconst DEFAULT_OPTIONS: esb.BuildOptions = {\n  bundle: true,\n  sourcemap: false,\n  logLevel: 'silent',\n  platform: 'node',\n  target: 'es2020',\n  legalComments: 'none',\n  logOverride: { 'equals-negative-zero': 'silent' },\n  keepNames: true, // important : https://github.com/node-fetch/node-fetch/issues/784#issuecomment-1014768204\n  minify: false,\n}\n\nexport abstract class BuildContext<T> {\n  private _context: esb.BuildContext | undefined\n  private _previousProps: T | undefined\n  private _previousOpts: esb.BuildOptions = {}\n\n  protected abstract _createContext(props: T, opts: esb.BuildOptions): Promise<esb.BuildContext>\n\n  public async rebuild(props: T, opts: esb.BuildOptions = {}) {\n    if (!this._context || !_.isEqual(props, this._previousProps) || !_.isEqual(opts, this._previousOpts)) {\n      if (this._context) {\n        await this._context.dispose()\n      }\n      this._context = await this._createContext(props, opts)\n      this._previousOpts = opts\n      this._previousProps = props\n    }\n    return await this._context?.rebuild()\n  }\n}\n\nexport class BuildCodeContext extends BuildContext<BuildCodeProps> {\n  protected _createContext(props: BuildCodeProps, opts: esb.BuildOptions = {}): Promise<esb.BuildContext> {\n    const { absWorkingDir, code, outfile } = props\n    return esb.context({\n      ...DEFAULT_OPTIONS,\n      ...opts,\n      absWorkingDir,\n      outfile,\n      stdin: { contents: code, resolveDir: absWorkingDir, loader: 'ts' },\n      write: true,\n    })\n  }\n}\n\nexport class BuildEntrypointContext extends BuildContext<BuildEntrypointProps> {\n  protected _createContext(props: BuildEntrypointProps, opts: esb.BuildOptions = {}): Promise<esb.BuildContext> {\n    const { absWorkingDir, entrypoint } = props\n    return esb.context({\n      ...DEFAULT_OPTIONS,\n      ...opts,\n      absWorkingDir,\n      entryPoints: [entrypoint],\n      outfile: undefined,\n      write: false,\n    })\n  }\n}\n\n/**\n * Bundles a string of typescript code and writes the output to a file\n */\nexport function buildCode(props: BuildCodeProps, opts: esb.BuildOptions = {}): Promise<esb.BuildResult> {\n  const { absWorkingDir, code, outfile } = props\n  return esb.build({\n    ...DEFAULT_OPTIONS,\n    ...opts,\n    absWorkingDir,\n    outfile,\n    stdin: { contents: code, resolveDir: absWorkingDir, loader: 'ts' },\n    write: true,\n  })\n}\n\n/**\n * Bundles a typescript file and returns the output as a string\n */\nexport function buildEntrypoint(\n  props: BuildEntrypointProps,\n  opts: esb.BuildOptions = {}\n): Promise<esb.BuildResult & { outputFiles: esb.OutputFile[] }> {\n  const { absWorkingDir, entrypoint } = props\n  return esb.build({\n    ...DEFAULT_OPTIONS,\n    ...opts,\n    absWorkingDir,\n    entryPoints: [entrypoint],\n    outfile: undefined,\n    write: false,\n  })\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UAAqB;AACrB,oBAAc;AAEd,kCAAc,oBAHd;AAkBA,MAAM,kBAAoC;AAAA,EACxC,QAAQ;AAAA,EACR,WAAW;AAAA,EACX,UAAU;AAAA,EACV,UAAU;AAAA,EACV,QAAQ;AAAA,EACR,eAAe;AAAA,EACf,aAAa,EAAE,wBAAwB,SAAS;AAAA,EAChD,WAAW;AAAA;AAAA,EACX,QAAQ;AACV;AAEO,MAAe,aAAgB;AAAA,EAC5B;AAAA,EACA;AAAA,EACA,gBAAkC,CAAC;AAAA,EAI3C,MAAa,QAAQ,OAAU,OAAyB,CAAC,GAAG;AAC1D,QAAI,CAAC,KAAK,YAAY,CAAC,cAAAA,QAAE,QAAQ,OAAO,KAAK,cAAc,KAAK,CAAC,cAAAA,QAAE,QAAQ,MAAM,KAAK,aAAa,GAAG;AACpG,UAAI,KAAK,UAAU;AACjB,cAAM,KAAK,SAAS,QAAQ;AAAA,MAC9B;AACA,WAAK,WAAW,MAAM,KAAK,eAAe,OAAO,IAAI;AACrD,WAAK,gBAAgB;AACrB,WAAK,iBAAiB;AAAA,IACxB;AACA,WAAO,MAAM,KAAK,UAAU,QAAQ;AAAA,EACtC;AACF;AAEO,MAAM,yBAAyB,aAA6B;AAAA,EACvD,eAAe,OAAuB,OAAyB,CAAC,GAA8B;AACtG,UAAM,EAAE,eAAe,MAAM,QAAQ,IAAI;AACzC,WAAO,IAAI,QAAQ;AAAA,MACjB,GAAG;AAAA,MACH,GAAG;AAAA,MACH;AAAA,MACA;AAAA,MACA,OAAO,EAAE,UAAU,MAAM,YAAY,eAAe,QAAQ,KAAK;AAAA,MACjE,OAAO;AAAA,IACT,CAAC;AAAA,EACH;AACF;AAEO,MAAM,+BAA+B,aAAmC;AAAA,EACnE,eAAe,OAA6B,OAAyB,CAAC,GAA8B;AAC5G,UAAM,EAAE,eAAe,WAAW,IAAI;AACtC,WAAO,IAAI,QAAQ;AAAA,MACjB,GAAG;AAAA,MACH,GAAG;AAAA,MACH;AAAA,MACA,aAAa,CAAC,UAAU;AAAA,MACxB,SAAS;AAAA,MACT,OAAO;AAAA,IACT,CAAC;AAAA,EACH;AACF;AAKO,SAAS,UAAU,OAAuB,OAAyB,CAAC,GAA6B;AACtG,QAAM,EAAE,eAAe,MAAM,QAAQ,IAAI;AACzC,SAAO,IAAI,MAAM;AAAA,IACf,GAAG;AAAA,IACH,GAAG;AAAA,IACH;AAAA,IACA;AAAA,IACA,OAAO,EAAE,UAAU,MAAM,YAAY,eAAe,QAAQ,KAAK;AAAA,IACjE,OAAO;AAAA,EACT,CAAC;AACH;AAKO,SAAS,gBACd,OACA,OAAyB,CAAC,GACoC;AAC9D,QAAM,EAAE,eAAe,WAAW,IAAI;AACtC,SAAO,IAAI,MAAM;AAAA,IACf,GAAG;AAAA,IACH,GAAG;AAAA,IACH;AAAA,IACA,aAAa,CAAC,UAAU;AAAA,IACxB,SAAS;AAAA,IACT,OAAO;AAAA,EACT,CAAC;AACH;",
+  "names": ["_"]
+}

package/dist/bp-cli/dist/utils/event-emitter.d.ts

@@ -0,0 +1,7 @@
+export declare class EventEmitter<E extends object> {
+    private _listeners;
+    emit<K extends keyof E>(type: K, event: E[K]): void;
+    once<K extends keyof E>(type: K, listener: (event: E[K]) => void): void;
+    on<K extends keyof E>(type: K, listener: (event: E[K]) => void): void;
+    off<K extends keyof E>(type: K, listener: (event: E[K]) => void): void;
+}

package/dist/bp-cli/dist/utils/event-emitter.js

@@ -0,0 +1,63 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var event_emitter_exports = {};
+__export(event_emitter_exports, {
+  EventEmitter: () => EventEmitter
+});
+module.exports = __toCommonJS(event_emitter_exports);
+class EventEmitter {
+  _listeners = {};
+  emit(type, event) {
+    const listeners = this._listeners[type];
+    if (!listeners) {
+      return;
+    }
+    for (const listener of listeners) {
+      listener(event);
+    }
+  }
+  once(type, listener) {
+    const wrapped = (event) => {
+      this.off(type, wrapped);
+      listener(event);
+    };
+    this.on(type, wrapped);
+  }
+  on(type, listener) {
+    if (!this._listeners[type]) {
+      this._listeners[type] = [];
+    }
+    this._listeners[type].push(listener);
+  }
+  off(type, listener) {
+    const listeners = this._listeners[type];
+    if (!listeners) {
+      return;
+    }
+    const index = listeners.indexOf(listener);
+    if (index !== -1) {
+      listeners.splice(index, 1);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EventEmitter
+});
+//# sourceMappingURL=event-emitter.js.map

package/dist/bp-cli/dist/utils/event-emitter.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/event-emitter.ts"],
+  "sourcesContent": ["export class EventEmitter<E extends object> {\n  private _listeners: {\n    [K in keyof E]?: ((event: E[K]) => void)[]\n  } = {}\n\n  public emit<K extends keyof E>(type: K, event: E[K]) {\n    const listeners = this._listeners[type]\n    if (!listeners) {\n      return\n    }\n    for (const listener of listeners) {\n      listener(event)\n    }\n  }\n\n  public once<K extends keyof E>(type: K, listener: (event: E[K]) => void) {\n    const wrapped = (event: E[K]) => {\n      this.off(type, wrapped)\n      listener(event)\n    }\n    this.on(type, wrapped)\n  }\n\n  public on<K extends keyof E>(type: K, listener: (event: E[K]) => void) {\n    if (!this._listeners[type]) {\n      this._listeners[type] = []\n    }\n    this._listeners[type]!.push(listener)\n  }\n\n  public off<K extends keyof E>(type: K, listener: (event: E[K]) => void) {\n    const listeners = this._listeners[type]\n    if (!listeners) {\n      return\n    }\n    const index = listeners.indexOf(listener)\n    if (index !== -1) {\n      listeners.splice(index, 1)\n    }\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,MAAM,aAA+B;AAAA,EAClC,aAEJ,CAAC;AAAA,EAEE,KAAwB,MAAS,OAAa;AACnD,UAAM,YAAY,KAAK,WAAW,IAAI;AACtC,QAAI,CAAC,WAAW;AACd;AAAA,IACF;AACA,eAAW,YAAY,WAAW;AAChC,eAAS,KAAK;AAAA,IAChB;AAAA,EACF;AAAA,EAEO,KAAwB,MAAS,UAAiC;AACvE,UAAM,UAAU,CAAC,UAAgB;AAC/B,WAAK,IAAI,MAAM,OAAO;AACtB,eAAS,KAAK;AAAA,IAChB;AACA,SAAK,GAAG,MAAM,OAAO;AAAA,EACvB;AAAA,EAEO,GAAsB,MAAS,UAAiC;AACrE,QAAI,CAAC,KAAK,WAAW,IAAI,GAAG;AAC1B,WAAK,WAAW,IAAI,IAAI,CAAC;AAAA,IAC3B;AACA,SAAK,WAAW,IAAI,EAAG,KAAK,QAAQ;AAAA,EACtC;AAAA,EAEO,IAAuB,MAAS,UAAiC;AACtE,UAAM,YAAY,KAAK,WAAW,IAAI;AACtC,QAAI,CAAC,WAAW;AACd;AAAA,IACF;AACA,UAAM,QAAQ,UAAU,QAAQ,QAAQ;AACxC,QAAI,UAAU,IAAI;AAChB,gBAAU,OAAO,OAAO,CAAC;AAAA,IAC3B;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/bp-cli/dist/utils/file-watcher.d.ts

@@ -0,0 +1,17 @@
+import watcher from '@parcel/watcher';
+export type FileChangeHandler = (events: watcher.Event[]) => Promise<void>;
+type FileWatcherOptions = watcher.Options & {
+    debounceMs?: number;
+};
+/**
+ * Wraps the Parcel file watcher to ensure errors can be catched in an async/await fashion
+ */
+export declare class FileWatcher {
+    private _subscription;
+    private _errorEmitter;
+    static watch(dir: string, fn: FileChangeHandler, opt?: FileWatcherOptions): Promise<FileWatcher>;
+    private constructor();
+    close(): Promise<void>;
+    wait: () => Promise<unknown>;
+}
+export {};