@botpress/cli 2.1.1 → 2.1.2

package/dist/utils/prompt-utils.js

@@ -0,0 +1,105 @@
+"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 __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 prompt_utils_exports = {};
+__export(prompt_utils_exports, {
+  CLIPrompt: () => CLIPrompt
+});
+module.exports = __toCommonJS(prompt_utils_exports);
+var import_prompts = __toESM(require("prompts"));
+class CLIPrompt {
+  constructor(_props, _logger) {
+    this._props = _props;
+    this._logger = _logger;
+  }
+  async confirm(message) {
+    if (this._props.confirm) {
+      this._logger.debug(`Confirming automatically (non-interactive mode): ${message}`);
+      return true;
+    }
+    const { confirm } = await this._prompts({
+      type: "confirm",
+      name: "confirm",
+      message,
+      initial: false
+    });
+    if (!confirm) {
+      return false;
+    }
+    return true;
+  }
+  async password(message, opts = {}) {
+    if (this._props.confirm) {
+      this._logger.debug(`Return default (non-interactive mode): ${message}`);
+      return opts?.default;
+    }
+    const { prompted } = await this._prompts({
+      type: "password",
+      name: "prompted",
+      message,
+      initial: opts?.initial
+    });
+    return prompted ? prompted : void 0;
+  }
+  async select(message, opts = {}) {
+    if (this._props.confirm) {
+      this._logger.debug(`Return default (non-interactive mode): ${message}`);
+      return opts?.default;
+    }
+    const { prompted } = await this._prompts({
+      type: "autocomplete",
+      name: "prompted",
+      message,
+      initial: opts?.initial?.value,
+      choices: opts?.choices
+    });
+    return prompted ? prompted : void 0;
+  }
+  async text(message, opts = {}) {
+    if (this._props.confirm) {
+      this._logger.debug(`Return default (non-interactive mode): ${message}`);
+      return opts?.default;
+    }
+    const { prompted } = await this._prompts({
+      type: "text",
+      name: "prompted",
+      message,
+      initial: opts?.initial
+    });
+    return prompted ? prompted : void 0;
+  }
+  _prompts = (...args) => {
+    this._logger.cleanup();
+    return (0, import_prompts.default)(...args);
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CLIPrompt
+});
+//# sourceMappingURL=prompt-utils.js.map

package/dist/utils/prompt-utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/prompt-utils.ts"],
+  "sourcesContent": ["import prompts from 'prompts'\nimport type { Logger } from '../logger'\n\nexport type CLIPromptsProps = {\n  confirm: boolean\n}\n\nexport type CLIPromptsChoice<V extends string> = {\n  title: string\n  value: V\n}\n\ntype PasswordOptions = Partial<{\n  default: string | undefined\n  initial: string\n}>\ntype SelectOptions<V extends string> = Partial<{\n  default: V | undefined\n  initial: CLIPromptsChoice<V>\n  choices: CLIPromptsChoice<V>[]\n}>\ntype TextOptions = Partial<{\n  default: string | undefined\n  initial: string\n}>\n\nexport class CLIPrompt {\n  public constructor(private _props: CLIPromptsProps, private _logger: Logger) {}\n\n  public async confirm(message: string): Promise<boolean> {\n    if (this._props.confirm) {\n      this._logger.debug(`Confirming automatically (non-interactive mode): ${message}`)\n      return true\n    }\n\n    const { confirm } = await this._prompts({\n      type: 'confirm',\n      name: 'confirm',\n      message,\n      initial: false,\n    })\n\n    if (!confirm) {\n      return false\n    }\n    return true\n  }\n\n  public async password(message: string, opts: PasswordOptions = {}): Promise<string | undefined> {\n    if (this._props.confirm) {\n      this._logger.debug(`Return default (non-interactive mode): ${message}`)\n      return opts?.default\n    }\n\n    const { prompted } = await this._prompts({\n      type: 'password',\n      name: 'prompted',\n      message,\n      initial: opts?.initial,\n    })\n\n    return prompted ? prompted : undefined\n  }\n\n  public async select<V extends string>(message: string, opts: SelectOptions<V> = {}): Promise<V | undefined> {\n    if (this._props.confirm) {\n      this._logger.debug(`Return default (non-interactive mode): ${message}`)\n      return opts?.default\n    }\n\n    const { prompted } = await this._prompts({\n      type: 'autocomplete',\n      name: 'prompted',\n      message,\n      initial: opts?.initial?.value,\n      choices: opts?.choices,\n    })\n    return prompted ? prompted : undefined\n  }\n\n  public async text(message: string, opts: TextOptions = {}): Promise<string | undefined> {\n    if (this._props.confirm) {\n      this._logger.debug(`Return default (non-interactive mode): ${message}`)\n      return opts?.default\n    }\n\n    const { prompted } = await this._prompts({\n      type: 'text',\n      name: 'prompted',\n      message,\n      initial: opts?.initial,\n    })\n\n    return prompted ? prompted : undefined\n  }\n\n  private _prompts = (...args: Parameters<typeof prompts>): ReturnType<typeof prompts> => {\n    this._logger.cleanup()\n    return prompts(...args)\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qBAAoB;AA0Bb,MAAM,UAAU;AAAA,EACd,YAAoB,QAAiC,SAAiB;AAAlD;AAAiC;AAAA,EAAkB;AAAA,EAE9E,MAAa,QAAQ,SAAmC;AACtD,QAAI,KAAK,OAAO,SAAS;AACvB,WAAK,QAAQ,MAAM,oDAAoD,SAAS;AAChF,aAAO;AAAA,IACT;AAEA,UAAM,EAAE,QAAQ,IAAI,MAAM,KAAK,SAAS;AAAA,MACtC,MAAM;AAAA,MACN,MAAM;AAAA,MACN;AAAA,MACA,SAAS;AAAA,IACX,CAAC;AAED,QAAI,CAAC,SAAS;AACZ,aAAO;AAAA,IACT;AACA,WAAO;AAAA,EACT;AAAA,EAEA,MAAa,SAAS,SAAiB,OAAwB,CAAC,GAAgC;AAC9F,QAAI,KAAK,OAAO,SAAS;AACvB,WAAK,QAAQ,MAAM,0CAA0C,SAAS;AACtE,aAAO,MAAM;AAAA,IACf;AAEA,UAAM,EAAE,SAAS,IAAI,MAAM,KAAK,SAAS;AAAA,MACvC,MAAM;AAAA,MACN,MAAM;AAAA,MACN;AAAA,MACA,SAAS,MAAM;AAAA,IACjB,CAAC;AAED,WAAO,WAAW,WAAW;AAAA,EAC/B;AAAA,EAEA,MAAa,OAAyB,SAAiB,OAAyB,CAAC,GAA2B;AAC1G,QAAI,KAAK,OAAO,SAAS;AACvB,WAAK,QAAQ,MAAM,0CAA0C,SAAS;AACtE,aAAO,MAAM;AAAA,IACf;AAEA,UAAM,EAAE,SAAS,IAAI,MAAM,KAAK,SAAS;AAAA,MACvC,MAAM;AAAA,MACN,MAAM;AAAA,MACN;AAAA,MACA,SAAS,MAAM,SAAS;AAAA,MACxB,SAAS,MAAM;AAAA,IACjB,CAAC;AACD,WAAO,WAAW,WAAW;AAAA,EAC/B;AAAA,EAEA,MAAa,KAAK,SAAiB,OAAoB,CAAC,GAAgC;AACtF,QAAI,KAAK,OAAO,SAAS;AACvB,WAAK,QAAQ,MAAM,0CAA0C,SAAS;AACtE,aAAO,MAAM;AAAA,IACf;AAEA,UAAM,EAAE,SAAS,IAAI,MAAM,KAAK,SAAS;AAAA,MACvC,MAAM;AAAA,MACN,MAAM;AAAA,MACN;AAAA,MACA,SAAS,MAAM;AAAA,IACjB,CAAC;AAED,WAAO,WAAW,WAAW;AAAA,EAC/B;AAAA,EAEQ,WAAW,IAAI,SAAiE;AACtF,SAAK,QAAQ,QAAQ;AACrB,eAAO,eAAAA,SAAQ,GAAG,IAAI;AAAA,EACxB;AACF;",
+  "names": ["prompts"]
+}

package/dist/utils/record-utils.js

@@ -0,0 +1,118 @@
+"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 __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 record_utils_exports = {};
+__export(record_utils_exports, {
+  filterValues: () => filterValues,
+  mapKeys: () => mapKeys,
+  mapValues: () => mapValues,
+  mapValuesAsync: () => mapValuesAsync,
+  mergeRecords: () => mergeRecords,
+  setNullOnMissingValues: () => setNullOnMissingValues,
+  zipObjects: () => zipObjects
+});
+module.exports = __toCommonJS(record_utils_exports);
+var import_lodash = __toESM(require("lodash"));
+const setNullOnMissingValues = (record = {}, oldRecord = {}) => {
+  const newRecord = {};
+  for (const [key, value] of Object.entries(record)) {
+    newRecord[key] = value;
+  }
+  for (const value of Object.keys(oldRecord)) {
+    if (!record[value]) {
+      newRecord[value] = null;
+    }
+  }
+  return newRecord;
+};
+const zipObjects = (recordA, recordB) => {
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(recordA), ...Object.keys(recordB)]);
+  const newRecord = {};
+  for (const key of allKeys) {
+    newRecord[key] = [recordA[key] ?? null, recordB[key] ?? null];
+  }
+  return newRecord;
+};
+const mapValues = (record, fn) => {
+  const newRecord = {};
+  for (const [key, value] of Object.entries(record)) {
+    newRecord[key] = fn(value, key);
+  }
+  return newRecord;
+};
+const mapValuesAsync = async (record, fn) => {
+  const newRecord = {};
+  for (const [key, value] of Object.entries(record)) {
+    newRecord[key] = await fn(value, key);
+  }
+  return newRecord;
+};
+const mapKeys = (record, fn) => {
+  const newRecord = {};
+  for (const [key, value] of Object.entries(record)) {
+    const newKey = fn(value, key);
+    newRecord[newKey] = value;
+  }
+  return newRecord;
+};
+function filterValues(record, fn) {
+  const newRecord = {};
+  for (const [key, value] of Object.entries(record)) {
+    if (fn(value, key)) {
+      newRecord[key] = value;
+    }
+  }
+  return newRecord;
+}
+const mergeRecords = (a, b, merge) => {
+  const keys = import_lodash.default.uniq([...Object.keys(a), ...Object.keys(b)]);
+  const result = {};
+  for (const key of keys) {
+    const aValue = a[key];
+    const bValue = b[key];
+    if (aValue && bValue) {
+      result[key] = merge(aValue, bValue);
+    } else if (aValue) {
+      result[key] = aValue;
+    } else if (bValue) {
+      result[key] = bValue;
+    }
+  }
+  return result;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  filterValues,
+  mapKeys,
+  mapValues,
+  mapValuesAsync,
+  mergeRecords,
+  setNullOnMissingValues,
+  zipObjects
+});
+//# sourceMappingURL=record-utils.js.map

package/dist/utils/record-utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/record-utils.ts"],
+  "sourcesContent": ["import _ from 'lodash'\n\nexport const setNullOnMissingValues = <A, B>(\n  record: Record<string, A> = {},\n  oldRecord: Record<string, B> = {}\n): Record<string, A | null> => {\n  const newRecord: Record<string, A | null> = {}\n\n  for (const [key, value] of Object.entries(record)) {\n    newRecord[key] = value\n  }\n\n  for (const value of Object.keys(oldRecord)) {\n    if (!record[value]) {\n      newRecord[value] = null\n    }\n  }\n\n  return newRecord\n}\n\nexport const zipObjects = <A, B>(\n  recordA: Record<string, A>,\n  recordB: Record<string, B>\n): Record<string, [A | null, B | null]> => {\n  const allKeys = new Set([...Object.keys(recordA), ...Object.keys(recordB)])\n  const newRecord: Record<string, [A | null, B | null]> = {}\n\n  for (const key of allKeys) {\n    newRecord[key] = [recordA[key] ?? null, recordB[key] ?? null]\n  }\n\n  return newRecord\n}\n\nexport const mapValues = <A, B>(record: Record<string, A>, fn: (value: A, key: string) => B): Record<string, B> => {\n  const newRecord: Record<string, B> = {}\n\n  for (const [key, value] of Object.entries(record)) {\n    newRecord[key] = fn(value, key)\n  }\n\n  return newRecord\n}\n\nexport const mapValuesAsync = async <A, B>(\n  record: Record<string, A>,\n  fn: (value: A, key: string) => Promise<B>\n): Promise<Record<string, B>> => {\n  const newRecord: Record<string, B> = {}\n\n  for (const [key, value] of Object.entries(record)) {\n    newRecord[key] = await fn(value, key)\n  }\n\n  return newRecord\n}\n\nexport const mapKeys = <A>(record: Record<string, A>, fn: (value: A, key: string) => string): Record<string, A> => {\n  const newRecord: Record<string, A> = {}\n\n  for (const [key, value] of Object.entries(record)) {\n    const newKey = fn(value, key) as string\n    newRecord[newKey] = value\n  }\n\n  return newRecord\n}\n\nexport function filterValues<A, B extends A>(\n  record: Record<string, A>,\n  fn: (value: A, key: string) => value is B\n): Record<string, B>\nexport function filterValues<A, _B extends A>(\n  record: Record<string, A>,\n  fn: (value: A, key: string) => boolean\n): Record<string, A>\nexport function filterValues<A>(record: Record<string, A>, fn: (value: A, key: string) => boolean) {\n  const newRecord: Record<string, A> = {}\n\n  for (const [key, value] of Object.entries(record)) {\n    if (fn(value, key)) {\n      newRecord[key] = value\n    }\n  }\n\n  return newRecord\n}\n\nexport const mergeRecords = <K extends string, V>(\n  a: Record<K, V>,\n  b: Record<K, V>,\n  merge: (v1: V, v2: V) => V\n): Record<K, V> => {\n  const keys = _.uniq([...Object.keys(a), ...Object.keys(b)]) as K[]\n  const result: Record<K, V> = {} as Record<K, V>\n  for (const key of keys) {\n    const aValue = a[key]\n    const bValue = b[key]\n    if (aValue && bValue) {\n      result[key] = merge(aValue, bValue)\n    } else if (aValue) {\n      result[key] = aValue\n    } else if (bValue) {\n      result[key] = bValue\n    }\n  }\n  return result\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAc;AAEP,MAAM,yBAAyB,CACpC,SAA4B,CAAC,GAC7B,YAA+B,CAAC,MACH;AAC7B,QAAM,YAAsC,CAAC;AAE7C,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,MAAM,GAAG;AACjD,cAAU,GAAG,IAAI;AAAA,EACnB;AAEA,aAAW,SAAS,OAAO,KAAK,SAAS,GAAG;AAC1C,QAAI,CAAC,OAAO,KAAK,GAAG;AAClB,gBAAU,KAAK,IAAI;AAAA,IACrB;AAAA,EACF;AAEA,SAAO;AACT;AAEO,MAAM,aAAa,CACxB,SACA,YACyC;AACzC,QAAM,UAAU,oBAAI,IAAI,CAAC,GAAG,OAAO,KAAK,OAAO,GAAG,GAAG,OAAO,KAAK,OAAO,CAAC,CAAC;AAC1E,QAAM,YAAkD,CAAC;AAEzD,aAAW,OAAO,SAAS;AACzB,cAAU,GAAG,IAAI,CAAC,QAAQ,GAAG,KAAK,MAAM,QAAQ,GAAG,KAAK,IAAI;AAAA,EAC9D;AAEA,SAAO;AACT;AAEO,MAAM,YAAY,CAAO,QAA2B,OAAwD;AACjH,QAAM,YAA+B,CAAC;AAEtC,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,MAAM,GAAG;AACjD,cAAU,GAAG,IAAI,GAAG,OAAO,GAAG;AAAA,EAChC;AAEA,SAAO;AACT;AAEO,MAAM,iBAAiB,OAC5B,QACA,OAC+B;AAC/B,QAAM,YAA+B,CAAC;AAEtC,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,MAAM,GAAG;AACjD,cAAU,GAAG,IAAI,MAAM,GAAG,OAAO,GAAG;AAAA,EACtC;AAEA,SAAO;AACT;AAEO,MAAM,UAAU,CAAI,QAA2B,OAA6D;AACjH,QAAM,YAA+B,CAAC;AAEtC,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,MAAM,GAAG;AACjD,UAAM,SAAS,GAAG,OAAO,GAAG;AAC5B,cAAU,MAAM,IAAI;AAAA,EACtB;AAEA,SAAO;AACT;AAUO,SAAS,aAAgB,QAA2B,IAAwC;AACjG,QAAM,YAA+B,CAAC;AAEtC,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,MAAM,GAAG;AACjD,QAAI,GAAG,OAAO,GAAG,GAAG;AAClB,gBAAU,GAAG,IAAI;AAAA,IACnB;AAAA,EACF;AAEA,SAAO;AACT;AAEO,MAAM,eAAe,CAC1B,GACA,GACA,UACiB;AACjB,QAAM,OAAO,cAAAA,QAAE,KAAK,CAAC,GAAG,OAAO,KAAK,CAAC,GAAG,GAAG,OAAO,KAAK,CAAC,CAAC,CAAC;AAC1D,QAAM,SAAuB,CAAC;AAC9B,aAAW,OAAO,MAAM;AACtB,UAAM,SAAS,EAAE,GAAG;AACpB,UAAM,SAAS,EAAE,GAAG;AACpB,QAAI,UAAU,QAAQ;AACpB,aAAO,GAAG,IAAI,MAAM,QAAQ,MAAM;AAAA,IACpC,WAAW,QAAQ;AACjB,aAAO,GAAG,IAAI;AAAA,IAChB,WAAW,QAAQ;AACjB,aAAO,GAAG,IAAI;AAAA,IAChB;AAAA,EACF;AACA,SAAO;AACT;",
+  "names": ["_"]
+}

package/dist/utils/record-utils.test.js

@@ -0,0 +1,38 @@
+"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 recordUtils = __toESM(require("./record-utils"));
+(0, import_vitest.test)("zip objects should return both values only when key is defined in both objects", () => {
+  const objA = { a: 1, b: 2, c: 3 };
+  const objB = { c: 4, d: 5 };
+  const zipped = recordUtils.zipObjects(objA, objB);
+  const expected = {
+    a: [1, null],
+    b: [2, null],
+    c: [3, 4],
+    d: [null, 5]
+  };
+  (0, import_vitest.expect)(zipped).toEqual(expected);
+});
+//# sourceMappingURL=record-utils.test.js.map

package/dist/utils/record-utils.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/record-utils.test.ts"],
+  "sourcesContent": ["import { test, expect } from 'vitest'\nimport * as recordUtils from './record-utils'\n\ntest('zip objects should return both values only when key is defined in both objects', () => {\n  const objA = { a: 1, b: 2, c: 3 }\n  const objB = { c: 4, d: 5 }\n\n  const zipped = recordUtils.zipObjects(objA, objB)\n\n  const expected = {\n    a: [1, null],\n    b: [2, null],\n    c: [3, 4],\n    d: [null, 5],\n  }\n\n  expect(zipped).toEqual(expected)\n})\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA,oBAA6B;AAC7B,kBAA6B;AAAA,IAE7B,oBAAK,kFAAkF,MAAM;AAC3F,QAAM,OAAO,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,EAAE;AAChC,QAAM,OAAO,EAAE,GAAG,GAAG,GAAG,EAAE;AAE1B,QAAM,SAAS,YAAY,WAAW,MAAM,IAAI;AAEhD,QAAM,WAAW;AAAA,IACf,GAAG,CAAC,GAAG,IAAI;AAAA,IACX,GAAG,CAAC,GAAG,IAAI;AAAA,IACX,GAAG,CAAC,GAAG,CAAC;AAAA,IACR,GAAG,CAAC,MAAM,CAAC;AAAA,EACb;AAEA,4BAAO,MAAM,EAAE,QAAQ,QAAQ;AACjC,CAAC;",
+  "names": []
+}

package/dist/utils/require-utils.js

@@ -0,0 +1,90 @@
+"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 __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 require_utils_exports = {};
+__export(require_utils_exports, {
+  requireJsCode: () => requireJsCode,
+  requireJsFile: () => requireJsFile
+});
+module.exports = __toCommonJS(require_utils_exports);
+var import_module = __toESM(require("module"));
+var import_path = __toESM(require("path"));
+const requireJsFile = (path) => {
+  return require(path);
+};
+const requireJsCode = (code) => {
+  const filedir = "tmp";
+  const filename = `${Date.now()}.js`;
+  const fileid = import_path.default.join(filedir, filename);
+  const m = new import_module.default(fileid);
+  m.filename = filename;
+  try {
+    m._compile(code, filename);
+    return m.exports;
+  } catch (thrown) {
+    const error = thrown instanceof Error ? thrown : new Error(`${thrown}`);
+    throw _injectStackTrace(error, code, filename);
+  }
+};
+const STACK_TRACE_SURROUNDING_LINES = 3;
+const _injectStackTrace = (compileError, code, filename) => {
+  if (!compileError.stack || !compileError.stack.includes(`${filename}:`)) {
+    return compileError;
+  }
+  const [, locationInfo] = compileError.stack.split(`${filename}:`, 2);
+  if (!locationInfo) {
+    return compileError;
+  }
+  const [lineNoStr, _rest] = locationInfo.split(":", 2);
+  if (!lineNoStr || !_rest) {
+    return compileError;
+  }
+  const [columnStr] = _rest.split(")", 1);
+  if (!columnStr) {
+    return compileError;
+  }
+  const lineNo = parseInt(lineNoStr);
+  const column = parseInt(columnStr);
+  const allLines = code.split("\n");
+  const linesBefore = allLines.slice(Math.max(0, lineNo - 1 - STACK_TRACE_SURROUNDING_LINES), lineNo - 1);
+  const offendingLine = allLines[lineNo - 1];
+  const caretLine = " ".repeat(column - 1) + "^";
+  const linesAfter = allLines.slice(lineNo, Math.min(allLines.length, lineNo + STACK_TRACE_SURROUNDING_LINES));
+  const stackTrace = [...linesBefore, offendingLine, caretLine, ...linesAfter].join("\n");
+  return new Error(`${compileError.message}
+
+Offending code:
+
+${stackTrace}`, { cause: compileError });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  requireJsCode,
+  requireJsFile
+});
+//# sourceMappingURL=require-utils.js.map

package/dist/utils/require-utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/require-utils.ts"],
+  "sourcesContent": ["import Module from 'module'\nimport pathlib from 'path'\n\nexport const requireJsFile = <T>(path: string): T => {\n  return require(path)\n}\n\nexport const requireJsCode = <T>(code: string): T => {\n  const filedir = 'tmp'\n  const filename = `${Date.now()}.js`\n\n  const fileid = pathlib.join(filedir, filename)\n\n  const m = new Module(fileid)\n  m.filename = filename\n\n  try {\n    // @ts-ignore\n    m._compile(code, filename)\n    return m.exports\n  } catch (thrown: unknown) {\n    const error = thrown instanceof Error ? thrown : new Error(`${thrown}`)\n    throw _injectStackTrace(error, code, filename)\n  }\n}\n\nconst STACK_TRACE_SURROUNDING_LINES = 3\n\nconst _injectStackTrace = (compileError: Error, code: string, filename: string): Error => {\n  if (!compileError.stack || !compileError.stack.includes(`${filename}:`)) {\n    return compileError\n  }\n\n  // Extract line and column from the stack trace:\n  const [, locationInfo] = compileError.stack.split(`${filename}:`, 2)\n  if (!locationInfo) {\n    return compileError\n  }\n\n  const [lineNoStr, _rest] = locationInfo.split(':', 2)\n  if (!lineNoStr || !_rest) {\n    return compileError\n  }\n\n  const [columnStr] = _rest.split(')', 1)\n  if (!columnStr) {\n    return compileError\n  }\n\n  const lineNo = parseInt(lineNoStr)\n  const column = parseInt(columnStr)\n\n  // Build the stack trace:\n  const allLines = code.split('\\n')\n  const linesBefore = allLines.slice(Math.max(0, lineNo - 1 - STACK_TRACE_SURROUNDING_LINES), lineNo - 1)\n  const offendingLine = allLines[lineNo - 1]\n  const caretLine = ' '.repeat(column - 1) + '^'\n  const linesAfter = allLines.slice(lineNo, Math.min(allLines.length, lineNo + STACK_TRACE_SURROUNDING_LINES))\n  const stackTrace = [...linesBefore, offendingLine, caretLine, ...linesAfter].join('\\n')\n\n  return new Error(`${compileError.message}\\n\\nOffending code:\\n\\n${stackTrace}`, { cause: compileError })\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAmB;AACnB,kBAAoB;AAEb,MAAM,gBAAgB,CAAI,SAAoB;AACnD,SAAO,QAAQ,IAAI;AACrB;AAEO,MAAM,gBAAgB,CAAI,SAAoB;AACnD,QAAM,UAAU;AAChB,QAAM,WAAW,GAAG,KAAK,IAAI;AAE7B,QAAM,SAAS,YAAAA,QAAQ,KAAK,SAAS,QAAQ;AAE7C,QAAM,IAAI,IAAI,cAAAC,QAAO,MAAM;AAC3B,IAAE,WAAW;AAEb,MAAI;AAEF,MAAE,SAAS,MAAM,QAAQ;AACzB,WAAO,EAAE;AAAA,EACX,SAAS,QAAP;AACA,UAAM,QAAQ,kBAAkB,QAAQ,SAAS,IAAI,MAAM,GAAG,QAAQ;AACtE,UAAM,kBAAkB,OAAO,MAAM,QAAQ;AAAA,EAC/C;AACF;AAEA,MAAM,gCAAgC;AAEtC,MAAM,oBAAoB,CAAC,cAAqB,MAAc,aAA4B;AACxF,MAAI,CAAC,aAAa,SAAS,CAAC,aAAa,MAAM,SAAS,GAAG,WAAW,GAAG;AACvE,WAAO;AAAA,EACT;AAGA,QAAM,CAAC,EAAE,YAAY,IAAI,aAAa,MAAM,MAAM,GAAG,aAAa,CAAC;AACnE,MAAI,CAAC,cAAc;AACjB,WAAO;AAAA,EACT;AAEA,QAAM,CAAC,WAAW,KAAK,IAAI,aAAa,MAAM,KAAK,CAAC;AACpD,MAAI,CAAC,aAAa,CAAC,OAAO;AACxB,WAAO;AAAA,EACT;AAEA,QAAM,CAAC,SAAS,IAAI,MAAM,MAAM,KAAK,CAAC;AACtC,MAAI,CAAC,WAAW;AACd,WAAO;AAAA,EACT;AAEA,QAAM,SAAS,SAAS,SAAS;AACjC,QAAM,SAAS,SAAS,SAAS;AAGjC,QAAM,WAAW,KAAK,MAAM,IAAI;AAChC,QAAM,cAAc,SAAS,MAAM,KAAK,IAAI,GAAG,SAAS,IAAI,6BAA6B,GAAG,SAAS,CAAC;AACtG,QAAM,gBAAgB,SAAS,SAAS,CAAC;AACzC,QAAM,YAAY,IAAI,OAAO,SAAS,CAAC,IAAI;AAC3C,QAAM,aAAa,SAAS,MAAM,QAAQ,KAAK,IAAI,SAAS,QAAQ,SAAS,6BAA6B,CAAC;AAC3G,QAAM,aAAa,CAAC,GAAG,aAAa,eAAe,WAAW,GAAG,UAAU,EAAE,KAAK,IAAI;AAEtF,SAAO,IAAI,MAAM,GAAG,aAAa;AAAA;AAAA;AAAA;AAAA,EAAiC,cAAc,EAAE,OAAO,aAAa,CAAC;AACzG;",
+  "names": ["pathlib", "Module"]
+}

package/dist/utils/require-utils.test.js

@@ -0,0 +1,54 @@
+"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 requireUtils = __toESM(require("./require-utils"));
+(0, import_vitest.test)("require js code should do as its name suggests", () => {
+  const code = `
+    module.exports = {
+      foo: 'bar'
+    }
+  `;
+  const result = requireUtils.requireJsCode(code);
+  (0, import_vitest.expect)(result.foo).toBe("bar");
+});
+const getError = (fn) => {
+  try {
+    fn();
+    return;
+  } catch (thrown) {
+    return thrown instanceof Error ? thrown : new Error(`${thrown}`);
+  }
+};
+(0, import_vitest.test)("require js code should indicate issue in stack trace", () => {
+  const code = `
+    var foo = undefined
+    module.exports = {
+      bar: foo.bar
+    }
+  `;
+  const error = getError(() => requireUtils.requireJsCode(code));
+  (0, import_vitest.expect)(error).toBeDefined();
+  (0, import_vitest.expect)(error?.message).toContain("bar: foo.bar");
+});
+//# sourceMappingURL=require-utils.test.js.map

package/dist/utils/require-utils.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/require-utils.test.ts"],
+  "sourcesContent": ["import { test, expect } from 'vitest'\nimport * as requireUtils from './require-utils'\n\ntest('require js code should do as its name suggests', () => {\n  const code = `\n    module.exports = {\n      foo: 'bar'\n    }\n  `\n\n  const result = requireUtils.requireJsCode<{ foo: string }>(code)\n\n  expect(result.foo).toBe('bar')\n})\n\nconst getError = (fn: () => void): Error | undefined => {\n  try {\n    fn()\n    return\n  } catch (thrown: unknown) {\n    return thrown instanceof Error ? thrown : new Error(`${thrown}`)\n  }\n}\n\ntest('require js code should indicate issue in stack trace', () => {\n  const code = `\n    var foo = undefined\n    module.exports = {\n      bar: foo.bar\n    }\n  `\n\n  const error = getError(() => requireUtils.requireJsCode(code))\n\n  expect(error).toBeDefined()\n  expect(error?.message).toContain('bar: foo.bar')\n})\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA,oBAA6B;AAC7B,mBAA8B;AAAA,IAE9B,oBAAK,kDAAkD,MAAM;AAC3D,QAAM,OAAO;AAAA;AAAA;AAAA;AAAA;AAMb,QAAM,SAAS,aAAa,cAA+B,IAAI;AAE/D,4BAAO,OAAO,GAAG,EAAE,KAAK,KAAK;AAC/B,CAAC;AAED,MAAM,WAAW,CAAC,OAAsC;AACtD,MAAI;AACF,OAAG;AACH;AAAA,EACF,SAAS,QAAP;AACA,WAAO,kBAAkB,QAAQ,SAAS,IAAI,MAAM,GAAG,QAAQ;AAAA,EACjE;AACF;AAAA,IAEA,oBAAK,wDAAwD,MAAM;AACjE,QAAM,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAOb,QAAM,QAAQ,SAAS,MAAM,aAAa,cAAc,IAAI,CAAC;AAE7D,4BAAO,KAAK,EAAE,YAAY;AAC1B,4BAAO,OAAO,OAAO,EAAE,UAAU,cAAc;AACjD,CAAC;",
+  "names": []
+}

package/dist/utils/schema-utils.js

@@ -0,0 +1,64 @@
+"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 schema_utils_exports = {};
+__export(schema_utils_exports, {
+  dereferenceSchema: () => dereferenceSchema,
+  mapZodToJsonSchema: () => mapZodToJsonSchema
+});
+module.exports = __toCommonJS(schema_utils_exports);
+var import_json_schema_ref_parser = require("@apidevtools/json-schema-ref-parser");
+var import_sdk = require("@botpress/sdk");
+const isObjectSchema = (schema) => schema.type === "object";
+async function mapZodToJsonSchema(definition) {
+  let schema = import_sdk.transforms.zuiToJsonSchema(definition.schema, { target: "jsonSchema7" });
+  schema = await dereferenceSchema(schema);
+  if (!isObjectSchema(schema) || !definition.ui) {
+    return schema;
+  }
+  for (const [key, value] of Object.entries(definition.ui ?? {})) {
+    const property = schema.properties?.[key];
+    if (!property) {
+      continue;
+    }
+    if (!!value?.title) {
+      ;
+      property.title = value.title;
+    }
+    if (!!value?.examples) {
+      ;
+      property.examples = value.examples;
+    }
+  }
+  return schema;
+}
+const dereferenceSchema = async (schema) => {
+  return (0, import_json_schema_ref_parser.dereference)(schema, {
+    resolve: {
+      external: false,
+      file: false,
+      http: false
+    }
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dereferenceSchema,
+  mapZodToJsonSchema
+});
+//# sourceMappingURL=schema-utils.js.map

package/dist/utils/schema-utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/schema-utils.ts"],
+  "sourcesContent": ["import { dereference } from '@apidevtools/json-schema-ref-parser'\nimport { z, transforms } from '@botpress/sdk'\nimport { JSONSchema7 } from 'json-schema'\n\ntype ZuiToJsonSchema = typeof transforms.zuiToJsonSchema\ntype JsonSchema = ReturnType<ZuiToJsonSchema>\ntype ObjectJsonSchema = Extract<JsonSchema, { type: 'object' }>\n\ntype SchemaOptions = {\n  title?: string\n  examples?: any[]\n}\n\ntype ZodObjectSchema = z.ZodObject | z.ZodRecord\ntype SchemaDefinition = {\n  schema: ZodObjectSchema\n  ui?: Record<string, SchemaOptions | undefined>\n}\n\nconst isObjectSchema = (schema: JsonSchema): schema is ObjectJsonSchema => schema.type === 'object'\n\nexport async function mapZodToJsonSchema(\n  definition: SchemaDefinition\n): Promise<ReturnType<typeof transforms.zuiToJsonSchema>> {\n  let schema = transforms.zuiToJsonSchema(definition.schema, { target: 'jsonSchema7' })\n  schema = (await dereferenceSchema(schema)) as typeof schema\n\n  if (!isObjectSchema(schema) || !definition.ui) {\n    return schema\n  }\n\n  for (const [key, value] of Object.entries(definition.ui ?? {})) {\n    const property = schema.properties?.[key]\n\n    if (!property) {\n      continue\n    }\n\n    if (!!value?.title) {\n      ;(property as any).title = value.title\n    }\n\n    if (!!value?.examples) {\n      ;(property as any).examples = value.examples\n    }\n  }\n\n  return schema\n}\n\nexport const dereferenceSchema = async (schema: JSONSchema7): Promise<JSONSchema7> => {\n  return dereference(schema, {\n    resolve: {\n      external: false,\n      file: false,\n      http: false,\n    },\n  })\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oCAA4B;AAC5B,iBAA8B;AAkB9B,MAAM,iBAAiB,CAAC,WAAmD,OAAO,SAAS;AAE3F,eAAsB,mBACpB,YACwD;AACxD,MAAI,SAAS,sBAAW,gBAAgB,WAAW,QAAQ,EAAE,QAAQ,cAAc,CAAC;AACpF,WAAU,MAAM,kBAAkB,MAAM;AAExC,MAAI,CAAC,eAAe,MAAM,KAAK,CAAC,WAAW,IAAI;AAC7C,WAAO;AAAA,EACT;AAEA,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,WAAW,MAAM,CAAC,CAAC,GAAG;AAC9D,UAAM,WAAW,OAAO,aAAa,GAAG;AAExC,QAAI,CAAC,UAAU;AACb;AAAA,IACF;AAEA,QAAI,CAAC,CAAC,OAAO,OAAO;AAClB;AAAC,MAAC,SAAiB,QAAQ,MAAM;AAAA,IACnC;AAEA,QAAI,CAAC,CAAC,OAAO,UAAU;AACrB;AAAC,MAAC,SAAiB,WAAW,MAAM;AAAA,IACtC;AAAA,EACF;AAEA,SAAO;AACT;AAEO,MAAM,oBAAoB,OAAO,WAA8C;AACpF,aAAO,2CAAY,QAAQ;AAAA,IACzB,SAAS;AAAA,MACP,UAAU;AAAA,MACV,MAAM;AAAA,MACN,MAAM;AAAA,IACR;AAAA,EACF,CAAC;AACH;",
+  "names": []
+}

package/dist/utils/schema-utils.test.js

@@ -0,0 +1,50 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_schema_utils = require("./schema-utils");
+(0, import_vitest.describe)("dereferenceSchema", () => {
+  (0, import_vitest.it)("should do nothing if no $ref", async () => {
+    const schema = { type: "object" };
+    const result = await (0, import_schema_utils.dereferenceSchema)(schema);
+    (0, import_vitest.expect)(result).toEqual(schema);
+  });
+  (0, import_vitest.it)("should dereference local $ref", async () => {
+    const schema = {
+      type: "object",
+      properties: {
+        foo: { $ref: "#/$defs/foo" },
+        bar: { $ref: "#/definitions/bar" }
+      },
+      $defs: {
+        foo: { type: "string" }
+      },
+      definitions: {
+        bar: { type: "number" }
+      }
+    };
+    const result = await (0, import_schema_utils.dereferenceSchema)(schema);
+    (0, import_vitest.expect)(result).toEqual({
+      type: "object",
+      properties: {
+        foo: { type: "string" },
+        bar: { type: "number" }
+      },
+      $defs: {
+        foo: { type: "string" }
+      },
+      definitions: {
+        bar: { type: "number" }
+      }
+    });
+  });
+  (0, import_vitest.it)("should ignore non-local $ref", async () => {
+    const schema = {
+      type: "object",
+      properties: {
+        foo: { $ref: "TItem" }
+      }
+    };
+    const result = await (0, import_schema_utils.dereferenceSchema)(schema);
+    (0, import_vitest.expect)(result).toEqual(schema);
+  });
+});
+//# sourceMappingURL=schema-utils.test.js.map

package/dist/utils/schema-utils.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/schema-utils.test.ts"],
+  "sourcesContent": ["import { it, expect, describe } from 'vitest'\nimport { dereferenceSchema } from './schema-utils'\nimport { JSONSchema7 } from 'json-schema'\n\ndescribe('dereferenceSchema', () => {\n  it('should do nothing if no $ref', async () => {\n    const schema: JSONSchema7 = { type: 'object' }\n    const result = await dereferenceSchema(schema)\n    expect(result).toEqual(schema)\n  })\n\n  it('should dereference local $ref', async () => {\n    const schema: JSONSchema7 = {\n      type: 'object',\n      properties: {\n        foo: { $ref: '#/$defs/foo' },\n        bar: { $ref: '#/definitions/bar' },\n      },\n      $defs: {\n        foo: { type: 'string' },\n      },\n      definitions: {\n        bar: { type: 'number' },\n      },\n    }\n    const result = await dereferenceSchema(schema)\n    expect(result).toEqual({\n      type: 'object',\n      properties: {\n        foo: { type: 'string' },\n        bar: { type: 'number' },\n      },\n      $defs: {\n        foo: { type: 'string' },\n      },\n      definitions: {\n        bar: { type: 'number' },\n      },\n    })\n  })\n\n  it('should ignore non-local $ref', async () => {\n    const schema: JSONSchema7 = {\n      type: 'object',\n      properties: {\n        foo: { $ref: 'TItem' },\n      },\n    }\n    const result = await dereferenceSchema(schema)\n    expect(result).toEqual(schema)\n  })\n})\n"],
+  "mappings": ";AAAA,oBAAqC;AACrC,0BAAkC;AAAA,IAGlC,wBAAS,qBAAqB,MAAM;AAClC,wBAAG,gCAAgC,YAAY;AAC7C,UAAM,SAAsB,EAAE,MAAM,SAAS;AAC7C,UAAM,SAAS,UAAM,uCAAkB,MAAM;AAC7C,8BAAO,MAAM,EAAE,QAAQ,MAAM;AAAA,EAC/B,CAAC;AAED,wBAAG,iCAAiC,YAAY;AAC9C,UAAM,SAAsB;AAAA,MAC1B,MAAM;AAAA,MACN,YAAY;AAAA,QACV,KAAK,EAAE,MAAM,cAAc;AAAA,QAC3B,KAAK,EAAE,MAAM,oBAAoB;AAAA,MACnC;AAAA,MACA,OAAO;AAAA,QACL,KAAK,EAAE,MAAM,SAAS;AAAA,MACxB;AAAA,MACA,aAAa;AAAA,QACX,KAAK,EAAE,MAAM,SAAS;AAAA,MACxB;AAAA,IACF;AACA,UAAM,SAAS,UAAM,uCAAkB,MAAM;AAC7C,8BAAO,MAAM,EAAE,QAAQ;AAAA,MACrB,MAAM;AAAA,MACN,YAAY;AAAA,QACV,KAAK,EAAE,MAAM,SAAS;AAAA,QACtB,KAAK,EAAE,MAAM,SAAS;AAAA,MACxB;AAAA,MACA,OAAO;AAAA,QACL,KAAK,EAAE,MAAM,SAAS;AAAA,MACxB;AAAA,MACA,aAAa;AAAA,QACX,KAAK,EAAE,MAAM,SAAS;AAAA,MACxB;AAAA,IACF,CAAC;AAAA,EACH,CAAC;AAED,wBAAG,gCAAgC,YAAY;AAC7C,UAAM,SAAsB;AAAA,MAC1B,MAAM;AAAA,MACN,YAAY;AAAA,QACV,KAAK,EAAE,MAAM,QAAQ;AAAA,MACvB;AAAA,IACF;AACA,UAAM,SAAS,UAAM,uCAAkB,MAAM;AAC7C,8BAAO,MAAM,EAAE,QAAQ,MAAM;AAAA,EAC/B,CAAC;AACH,CAAC;",
+  "names": []
+}

package/dist/utils/semver-utils.js

@@ -0,0 +1,45 @@
+"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 semver_utils_exports = {};
+__export(semver_utils_exports, {
+  releases: () => releases
+});
+module.exports = __toCommonJS(semver_utils_exports);
+const semverReleases = {
+  prerelease: 0,
+  prepatch: 1,
+  patch: 2,
+  preminor: 3,
+  minor: 4,
+  premajor: 5,
+  major: 6
+};
+var releases;
+((releases2) => {
+  releases2.eq = (a, b) => semverReleases[a] === semverReleases[b];
+  releases2.gt = (a, b) => semverReleases[a] > semverReleases[b];
+  releases2.gte = (a, b) => semverReleases[a] >= semverReleases[b];
+  releases2.lt = (a, b) => semverReleases[a] < semverReleases[b];
+  releases2.lte = (a, b) => semverReleases[a] <= semverReleases[b];
+})(releases || (releases = {}));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  releases
+});
+//# sourceMappingURL=semver-utils.js.map