@xylabs/forget 2.9.2 → 2.10.0

package/dist/forget.d.mts

@@ -0,0 +1,13 @@
+interface ForgetTimeoutConfig {
+    cancel: () => void;
+    delay: number;
+}
+declare class ForgetPromise {
+    static activeForgets: number;
+    static get active(): boolean;
+    static awaitInactive(interval?: number, timeout?: number): Promise<number>;
+    static forget(promise: Promise<unknown>, timeout?: ForgetTimeoutConfig): void;
+}
+declare const forget: (promise: Promise<unknown>, timeout?: ForgetTimeoutConfig) => void;
+
+export { ForgetPromise, ForgetTimeoutConfig, forget };

package/dist/{types/forget.d.ts → forget.d.ts}

@@ -1,12 +1,13 @@
-export interface ForgetTimeoutConfig {
+interface ForgetTimeoutConfig {
     cancel: () => void;
     delay: number;
 }
-export declare class ForgetPromise {
+declare class ForgetPromise {
     static activeForgets: number;
     static get active(): boolean;
     static awaitInactive(interval?: number, timeout?: number): Promise<number>;
     static forget(promise: Promise<unknown>, timeout?: ForgetTimeoutConfig): void;
 }
-export declare const forget: (promise: Promise<unknown>, timeout?: ForgetTimeoutConfig) => void;
-//# sourceMappingURL=forget.d.ts.map
+declare const forget: (promise: Promise<unknown>, timeout?: ForgetTimeoutConfig) => void;
+
+export { ForgetPromise, ForgetTimeoutConfig, forget };

package/dist/forget.js

@@ -0,0 +1,86 @@
+"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);
+
+// src/forget.ts
+var forget_exports = {};
+__export(forget_exports, {
+  ForgetPromise: () => ForgetPromise,
+  forget: () => forget
+});
+module.exports = __toCommonJS(forget_exports);
+var import_delay = require("@xylabs/delay");
+var ForgetPromise = class {
+  static activeForgets = 0;
+  static get active() {
+    return this.activeForgets > 0;
+  }
+  static async awaitInactive(interval = 100, timeout) {
+    let timeoutRemaining = timeout;
+    while (this.active) {
+      await (0, import_delay.delay)(interval);
+      if (timeoutRemaining !== void 0) {
+        timeoutRemaining -= interval;
+        if (timeoutRemaining <= 0) {
+          return this.activeForgets;
+        }
+      }
+    }
+    return 0;
+  }
+  //used to explicitly launch an async function (or Promise) with awaiting it
+  static forget(promise, timeout) {
+    let completed = false;
+    this.activeForgets++;
+    const promiseWrapper = async () => {
+      await promise.then(() => {
+        this.activeForgets--;
+        completed = true;
+      }).catch(() => {
+        this.activeForgets--;
+        completed = true;
+      });
+    };
+    const promises = [promiseWrapper()];
+    if (timeout) {
+      const timeoutFunc = async () => {
+        await (0, import_delay.delay)(timeout.delay);
+        if (!completed) {
+          console.log(`forget promise timeout out after ${timeout.delay}ms [Cancelling]`);
+          timeout.cancel?.();
+        }
+      };
+      promises.push(timeoutFunc());
+    }
+    const all = Promise.race(promises);
+    all.then(() => {
+      return;
+    }).catch(() => {
+      return;
+    });
+  }
+};
+var forget = (promise, timeout) => {
+  ForgetPromise.forget(promise, timeout);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ForgetPromise,
+  forget
+});
+//# sourceMappingURL=forget.js.map

package/dist/forget.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/forget.ts"],"sourcesContent":["import { delay } from '@xylabs/delay'\n\nexport interface ForgetTimeoutConfig {\n  cancel: () => void\n  delay: number\n}\n\nexport class ForgetPromise {\n  static activeForgets = 0\n\n  static get active() {\n    return this.activeForgets > 0\n  }\n\n  static async awaitInactive(interval = 100, timeout?: number) {\n    let timeoutRemaining = timeout\n    while (this.active) {\n      await delay(interval)\n      if (timeoutRemaining !== undefined) {\n        timeoutRemaining -= interval\n        if (timeoutRemaining <= 0) {\n          return this.activeForgets\n        }\n      }\n    }\n    return 0\n  }\n\n  //used to explicitly launch an async function (or Promise) with awaiting it\n  static forget(promise: Promise<unknown>, timeout?: ForgetTimeoutConfig) {\n    let completed = false\n    this.activeForgets++\n\n    const promiseWrapper = async () => {\n      await promise\n        .then(() => {\n          this.activeForgets--\n          completed = true\n        })\n        .catch(() => {\n          this.activeForgets--\n          completed = true\n        })\n    }\n\n    const promises = [promiseWrapper()]\n\n    //if there is a timeout, add it to the race\n    if (timeout) {\n      const timeoutFunc = async () => {\n        await delay(timeout.delay)\n        if (!completed) {\n          console.log(`forget promise timeout out after ${timeout.delay}ms [Cancelling]`)\n          timeout.cancel?.()\n        }\n      }\n      promises.push(timeoutFunc())\n    }\n\n    const all = Promise.race(promises)\n\n    all\n      .then(() => {\n        return\n      })\n      .catch(() => {\n        return\n      })\n  }\n}\n\n//used to explicitly launch an async function (or Promise) with awaiting it\nexport const forget = (promise: Promise<unknown>, timeout?: ForgetTimeoutConfig) => {\n  ForgetPromise.forget(promise, timeout)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAsB;AAOf,IAAM,gBAAN,MAAoB;AAAA,EACzB,OAAO,gBAAgB;AAAA,EAEvB,WAAW,SAAS;AAClB,WAAO,KAAK,gBAAgB;AAAA,EAC9B;AAAA,EAEA,aAAa,cAAc,WAAW,KAAK,SAAkB;AAC3D,QAAI,mBAAmB;AACvB,WAAO,KAAK,QAAQ;AAClB,gBAAM,oBAAM,QAAQ;AACpB,UAAI,qBAAqB,QAAW;AAClC,4BAAoB;AACpB,YAAI,oBAAoB,GAAG;AACzB,iBAAO,KAAK;AAAA,QACd;AAAA,MACF;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,OAAO,OAAO,SAA2B,SAA+B;AACtE,QAAI,YAAY;AAChB,SAAK;AAEL,UAAM,iBAAiB,YAAY;AACjC,YAAM,QACH,KAAK,MAAM;AACV,aAAK;AACL,oBAAY;AAAA,MACd,CAAC,EACA,MAAM,MAAM;AACX,aAAK;AACL,oBAAY;AAAA,MACd,CAAC;AAAA,IACL;AAEA,UAAM,WAAW,CAAC,eAAe,CAAC;AAGlC,QAAI,SAAS;AACX,YAAM,cAAc,YAAY;AAC9B,kBAAM,oBAAM,QAAQ,KAAK;AACzB,YAAI,CAAC,WAAW;AACd,kBAAQ,IAAI,oCAAoC,QAAQ,KAAK,iBAAiB;AAC9E,kBAAQ,SAAS;AAAA,QACnB;AAAA,MACF;AACA,eAAS,KAAK,YAAY,CAAC;AAAA,IAC7B;AAEA,UAAM,MAAM,QAAQ,KAAK,QAAQ;AAEjC,QACG,KAAK,MAAM;AACV;AAAA,IACF,CAAC,EACA,MAAM,MAAM;AACX;AAAA,IACF,CAAC;AAAA,EACL;AACF;AAGO,IAAM,SAAS,CAAC,SAA2B,YAAkC;AAClF,gBAAc,OAAO,SAAS,OAAO;AACvC;","names":[]}

package/dist/forget.mjs

@@ -0,0 +1,60 @@
+// src/forget.ts
+import { delay } from "@xylabs/delay";
+var ForgetPromise = class {
+  static activeForgets = 0;
+  static get active() {
+    return this.activeForgets > 0;
+  }
+  static async awaitInactive(interval = 100, timeout) {
+    let timeoutRemaining = timeout;
+    while (this.active) {
+      await delay(interval);
+      if (timeoutRemaining !== void 0) {
+        timeoutRemaining -= interval;
+        if (timeoutRemaining <= 0) {
+          return this.activeForgets;
+        }
+      }
+    }
+    return 0;
+  }
+  //used to explicitly launch an async function (or Promise) with awaiting it
+  static forget(promise, timeout) {
+    let completed = false;
+    this.activeForgets++;
+    const promiseWrapper = async () => {
+      await promise.then(() => {
+        this.activeForgets--;
+        completed = true;
+      }).catch(() => {
+        this.activeForgets--;
+        completed = true;
+      });
+    };
+    const promises = [promiseWrapper()];
+    if (timeout) {
+      const timeoutFunc = async () => {
+        await delay(timeout.delay);
+        if (!completed) {
+          console.log(`forget promise timeout out after ${timeout.delay}ms [Cancelling]`);
+          timeout.cancel?.();
+        }
+      };
+      promises.push(timeoutFunc());
+    }
+    const all = Promise.race(promises);
+    all.then(() => {
+      return;
+    }).catch(() => {
+      return;
+    });
+  }
+};
+var forget = (promise, timeout) => {
+  ForgetPromise.forget(promise, timeout);
+};
+export {
+  ForgetPromise,
+  forget
+};
+//# sourceMappingURL=forget.mjs.map

package/dist/forget.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/forget.ts"],"sourcesContent":["import { delay } from '@xylabs/delay'\n\nexport interface ForgetTimeoutConfig {\n  cancel: () => void\n  delay: number\n}\n\nexport class ForgetPromise {\n  static activeForgets = 0\n\n  static get active() {\n    return this.activeForgets > 0\n  }\n\n  static async awaitInactive(interval = 100, timeout?: number) {\n    let timeoutRemaining = timeout\n    while (this.active) {\n      await delay(interval)\n      if (timeoutRemaining !== undefined) {\n        timeoutRemaining -= interval\n        if (timeoutRemaining <= 0) {\n          return this.activeForgets\n        }\n      }\n    }\n    return 0\n  }\n\n  //used to explicitly launch an async function (or Promise) with awaiting it\n  static forget(promise: Promise<unknown>, timeout?: ForgetTimeoutConfig) {\n    let completed = false\n    this.activeForgets++\n\n    const promiseWrapper = async () => {\n      await promise\n        .then(() => {\n          this.activeForgets--\n          completed = true\n        })\n        .catch(() => {\n          this.activeForgets--\n          completed = true\n        })\n    }\n\n    const promises = [promiseWrapper()]\n\n    //if there is a timeout, add it to the race\n    if (timeout) {\n      const timeoutFunc = async () => {\n        await delay(timeout.delay)\n        if (!completed) {\n          console.log(`forget promise timeout out after ${timeout.delay}ms [Cancelling]`)\n          timeout.cancel?.()\n        }\n      }\n      promises.push(timeoutFunc())\n    }\n\n    const all = Promise.race(promises)\n\n    all\n      .then(() => {\n        return\n      })\n      .catch(() => {\n        return\n      })\n  }\n}\n\n//used to explicitly launch an async function (or Promise) with awaiting it\nexport const forget = (promise: Promise<unknown>, timeout?: ForgetTimeoutConfig) => {\n  ForgetPromise.forget(promise, timeout)\n}\n"],"mappings":";AAAA,SAAS,aAAa;AAOf,IAAM,gBAAN,MAAoB;AAAA,EACzB,OAAO,gBAAgB;AAAA,EAEvB,WAAW,SAAS;AAClB,WAAO,KAAK,gBAAgB;AAAA,EAC9B;AAAA,EAEA,aAAa,cAAc,WAAW,KAAK,SAAkB;AAC3D,QAAI,mBAAmB;AACvB,WAAO,KAAK,QAAQ;AAClB,YAAM,MAAM,QAAQ;AACpB,UAAI,qBAAqB,QAAW;AAClC,4BAAoB;AACpB,YAAI,oBAAoB,GAAG;AACzB,iBAAO,KAAK;AAAA,QACd;AAAA,MACF;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,OAAO,OAAO,SAA2B,SAA+B;AACtE,QAAI,YAAY;AAChB,SAAK;AAEL,UAAM,iBAAiB,YAAY;AACjC,YAAM,QACH,KAAK,MAAM;AACV,aAAK;AACL,oBAAY;AAAA,MACd,CAAC,EACA,MAAM,MAAM;AACX,aAAK;AACL,oBAAY;AAAA,MACd,CAAC;AAAA,IACL;AAEA,UAAM,WAAW,CAAC,eAAe,CAAC;AAGlC,QAAI,SAAS;AACX,YAAM,cAAc,YAAY;AAC9B,cAAM,MAAM,QAAQ,KAAK;AACzB,YAAI,CAAC,WAAW;AACd,kBAAQ,IAAI,oCAAoC,QAAQ,KAAK,iBAAiB;AAC9E,kBAAQ,SAAS;AAAA,QACnB;AAAA,MACF;AACA,eAAS,KAAK,YAAY,CAAC;AAAA,IAC7B;AAEA,UAAM,MAAM,QAAQ,KAAK,QAAQ;AAEjC,QACG,KAAK,MAAM;AACV;AAAA,IACF,CAAC,EACA,MAAM,MAAM;AACX;AAAA,IACF,CAAC;AAAA,EACL;AACF;AAGO,IAAM,SAAS,CAAC,SAA2B,YAAkC;AAClF,gBAAc,OAAO,SAAS,OAAO;AACvC;","names":[]}

package/dist/index.d.mts

@@ -0,0 +1,6 @@
+import { forget } from './forget.mjs';
+export { ForgetPromise } from './forget.mjs';
+
+
+
+export { forget as default, forget };

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { forget } from './forget.js';
+export { ForgetPromise } from './forget.js';
+
+
+
+export { forget as default, forget };

package/dist/index.js

@@ -0,0 +1,92 @@
+"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);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ForgetPromise: () => ForgetPromise,
+  default: () => src_default,
+  forget: () => forget
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/forget.ts
+var import_delay = require("@xylabs/delay");
+var ForgetPromise = class {
+  static activeForgets = 0;
+  static get active() {
+    return this.activeForgets > 0;
+  }
+  static async awaitInactive(interval = 100, timeout) {
+    let timeoutRemaining = timeout;
+    while (this.active) {
+      await (0, import_delay.delay)(interval);
+      if (timeoutRemaining !== void 0) {
+        timeoutRemaining -= interval;
+        if (timeoutRemaining <= 0) {
+          return this.activeForgets;
+        }
+      }
+    }
+    return 0;
+  }
+  //used to explicitly launch an async function (or Promise) with awaiting it
+  static forget(promise, timeout) {
+    let completed = false;
+    this.activeForgets++;
+    const promiseWrapper = async () => {
+      await promise.then(() => {
+        this.activeForgets--;
+        completed = true;
+      }).catch(() => {
+        this.activeForgets--;
+        completed = true;
+      });
+    };
+    const promises = [promiseWrapper()];
+    if (timeout) {
+      const timeoutFunc = async () => {
+        await (0, import_delay.delay)(timeout.delay);
+        if (!completed) {
+          console.log(`forget promise timeout out after ${timeout.delay}ms [Cancelling]`);
+          timeout.cancel?.();
+        }
+      };
+      promises.push(timeoutFunc());
+    }
+    const all = Promise.race(promises);
+    all.then(() => {
+      return;
+    }).catch(() => {
+      return;
+    });
+  }
+};
+var forget = (promise, timeout) => {
+  ForgetPromise.forget(promise, timeout);
+};
+
+// src/index.ts
+var src_default = forget;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ForgetPromise,
+  forget
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/forget.ts"],"sourcesContent":["import { forget, ForgetPromise } from './forget'\n\nexport { forget, ForgetPromise }\n\n// eslint-disable-next-line import/no-default-export\nexport default forget\n","import { delay } from '@xylabs/delay'\n\nexport interface ForgetTimeoutConfig {\n  cancel: () => void\n  delay: number\n}\n\nexport class ForgetPromise {\n  static activeForgets = 0\n\n  static get active() {\n    return this.activeForgets > 0\n  }\n\n  static async awaitInactive(interval = 100, timeout?: number) {\n    let timeoutRemaining = timeout\n    while (this.active) {\n      await delay(interval)\n      if (timeoutRemaining !== undefined) {\n        timeoutRemaining -= interval\n        if (timeoutRemaining <= 0) {\n          return this.activeForgets\n        }\n      }\n    }\n    return 0\n  }\n\n  //used to explicitly launch an async function (or Promise) with awaiting it\n  static forget(promise: Promise<unknown>, timeout?: ForgetTimeoutConfig) {\n    let completed = false\n    this.activeForgets++\n\n    const promiseWrapper = async () => {\n      await promise\n        .then(() => {\n          this.activeForgets--\n          completed = true\n        })\n        .catch(() => {\n          this.activeForgets--\n          completed = true\n        })\n    }\n\n    const promises = [promiseWrapper()]\n\n    //if there is a timeout, add it to the race\n    if (timeout) {\n      const timeoutFunc = async () => {\n        await delay(timeout.delay)\n        if (!completed) {\n          console.log(`forget promise timeout out after ${timeout.delay}ms [Cancelling]`)\n          timeout.cancel?.()\n        }\n      }\n      promises.push(timeoutFunc())\n    }\n\n    const all = Promise.race(promises)\n\n    all\n      .then(() => {\n        return\n      })\n      .catch(() => {\n        return\n      })\n  }\n}\n\n//used to explicitly launch an async function (or Promise) with awaiting it\nexport const forget = (promise: Promise<unknown>, timeout?: ForgetTimeoutConfig) => {\n  ForgetPromise.forget(promise, timeout)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA,mBAAsB;AAOf,IAAM,gBAAN,MAAoB;AAAA,EACzB,OAAO,gBAAgB;AAAA,EAEvB,WAAW,SAAS;AAClB,WAAO,KAAK,gBAAgB;AAAA,EAC9B;AAAA,EAEA,aAAa,cAAc,WAAW,KAAK,SAAkB;AAC3D,QAAI,mBAAmB;AACvB,WAAO,KAAK,QAAQ;AAClB,gBAAM,oBAAM,QAAQ;AACpB,UAAI,qBAAqB,QAAW;AAClC,4BAAoB;AACpB,YAAI,oBAAoB,GAAG;AACzB,iBAAO,KAAK;AAAA,QACd;AAAA,MACF;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,OAAO,OAAO,SAA2B,SAA+B;AACtE,QAAI,YAAY;AAChB,SAAK;AAEL,UAAM,iBAAiB,YAAY;AACjC,YAAM,QACH,KAAK,MAAM;AACV,aAAK;AACL,oBAAY;AAAA,MACd,CAAC,EACA,MAAM,MAAM;AACX,aAAK;AACL,oBAAY;AAAA,MACd,CAAC;AAAA,IACL;AAEA,UAAM,WAAW,CAAC,eAAe,CAAC;AAGlC,QAAI,SAAS;AACX,YAAM,cAAc,YAAY;AAC9B,kBAAM,oBAAM,QAAQ,KAAK;AACzB,YAAI,CAAC,WAAW;AACd,kBAAQ,IAAI,oCAAoC,QAAQ,KAAK,iBAAiB;AAC9E,kBAAQ,SAAS;AAAA,QACnB;AAAA,MACF;AACA,eAAS,KAAK,YAAY,CAAC;AAAA,IAC7B;AAEA,UAAM,MAAM,QAAQ,KAAK,QAAQ;AAEjC,QACG,KAAK,MAAM;AACV;AAAA,IACF,CAAC,EACA,MAAM,MAAM;AACX;AAAA,IACF,CAAC;AAAA,EACL;AACF;AAGO,IAAM,SAAS,CAAC,SAA2B,YAAkC;AAClF,gBAAc,OAAO,SAAS,OAAO;AACvC;;;ADrEA,IAAO,cAAQ;","names":[]}

package/dist/index.mjs

@@ -0,0 +1,64 @@
+// src/forget.ts
+import { delay } from "@xylabs/delay";
+var ForgetPromise = class {
+  static activeForgets = 0;
+  static get active() {
+    return this.activeForgets > 0;
+  }
+  static async awaitInactive(interval = 100, timeout) {
+    let timeoutRemaining = timeout;
+    while (this.active) {
+      await delay(interval);
+      if (timeoutRemaining !== void 0) {
+        timeoutRemaining -= interval;
+        if (timeoutRemaining <= 0) {
+          return this.activeForgets;
+        }
+      }
+    }
+    return 0;
+  }
+  //used to explicitly launch an async function (or Promise) with awaiting it
+  static forget(promise, timeout) {
+    let completed = false;
+    this.activeForgets++;
+    const promiseWrapper = async () => {
+      await promise.then(() => {
+        this.activeForgets--;
+        completed = true;
+      }).catch(() => {
+        this.activeForgets--;
+        completed = true;
+      });
+    };
+    const promises = [promiseWrapper()];
+    if (timeout) {
+      const timeoutFunc = async () => {
+        await delay(timeout.delay);
+        if (!completed) {
+          console.log(`forget promise timeout out after ${timeout.delay}ms [Cancelling]`);
+          timeout.cancel?.();
+        }
+      };
+      promises.push(timeoutFunc());
+    }
+    const all = Promise.race(promises);
+    all.then(() => {
+      return;
+    }).catch(() => {
+      return;
+    });
+  }
+};
+var forget = (promise, timeout) => {
+  ForgetPromise.forget(promise, timeout);
+};
+
+// src/index.ts
+var src_default = forget;
+export {
+  ForgetPromise,
+  src_default as default,
+  forget
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/forget.ts","../src/index.ts"],"sourcesContent":["import { delay } from '@xylabs/delay'\n\nexport interface ForgetTimeoutConfig {\n  cancel: () => void\n  delay: number\n}\n\nexport class ForgetPromise {\n  static activeForgets = 0\n\n  static get active() {\n    return this.activeForgets > 0\n  }\n\n  static async awaitInactive(interval = 100, timeout?: number) {\n    let timeoutRemaining = timeout\n    while (this.active) {\n      await delay(interval)\n      if (timeoutRemaining !== undefined) {\n        timeoutRemaining -= interval\n        if (timeoutRemaining <= 0) {\n          return this.activeForgets\n        }\n      }\n    }\n    return 0\n  }\n\n  //used to explicitly launch an async function (or Promise) with awaiting it\n  static forget(promise: Promise<unknown>, timeout?: ForgetTimeoutConfig) {\n    let completed = false\n    this.activeForgets++\n\n    const promiseWrapper = async () => {\n      await promise\n        .then(() => {\n          this.activeForgets--\n          completed = true\n        })\n        .catch(() => {\n          this.activeForgets--\n          completed = true\n        })\n    }\n\n    const promises = [promiseWrapper()]\n\n    //if there is a timeout, add it to the race\n    if (timeout) {\n      const timeoutFunc = async () => {\n        await delay(timeout.delay)\n        if (!completed) {\n          console.log(`forget promise timeout out after ${timeout.delay}ms [Cancelling]`)\n          timeout.cancel?.()\n        }\n      }\n      promises.push(timeoutFunc())\n    }\n\n    const all = Promise.race(promises)\n\n    all\n      .then(() => {\n        return\n      })\n      .catch(() => {\n        return\n      })\n  }\n}\n\n//used to explicitly launch an async function (or Promise) with awaiting it\nexport const forget = (promise: Promise<unknown>, timeout?: ForgetTimeoutConfig) => {\n  ForgetPromise.forget(promise, timeout)\n}\n","import { forget, ForgetPromise } from './forget'\n\nexport { forget, ForgetPromise }\n\n// eslint-disable-next-line import/no-default-export\nexport default forget\n"],"mappings":";AAAA,SAAS,aAAa;AAOf,IAAM,gBAAN,MAAoB;AAAA,EACzB,OAAO,gBAAgB;AAAA,EAEvB,WAAW,SAAS;AAClB,WAAO,KAAK,gBAAgB;AAAA,EAC9B;AAAA,EAEA,aAAa,cAAc,WAAW,KAAK,SAAkB;AAC3D,QAAI,mBAAmB;AACvB,WAAO,KAAK,QAAQ;AAClB,YAAM,MAAM,QAAQ;AACpB,UAAI,qBAAqB,QAAW;AAClC,4BAAoB;AACpB,YAAI,oBAAoB,GAAG;AACzB,iBAAO,KAAK;AAAA,QACd;AAAA,MACF;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,OAAO,OAAO,SAA2B,SAA+B;AACtE,QAAI,YAAY;AAChB,SAAK;AAEL,UAAM,iBAAiB,YAAY;AACjC,YAAM,QACH,KAAK,MAAM;AACV,aAAK;AACL,oBAAY;AAAA,MACd,CAAC,EACA,MAAM,MAAM;AACX,aAAK;AACL,oBAAY;AAAA,MACd,CAAC;AAAA,IACL;AAEA,UAAM,WAAW,CAAC,eAAe,CAAC;AAGlC,QAAI,SAAS;AACX,YAAM,cAAc,YAAY;AAC9B,cAAM,MAAM,QAAQ,KAAK;AACzB,YAAI,CAAC,WAAW;AACd,kBAAQ,IAAI,oCAAoC,QAAQ,KAAK,iBAAiB;AAC9E,kBAAQ,SAAS;AAAA,QACnB;AAAA,MACF;AACA,eAAS,KAAK,YAAY,CAAC;AAAA,IAC7B;AAEA,UAAM,MAAM,QAAQ,KAAK,QAAQ;AAEjC,QACG,KAAK,MAAM;AACV;AAAA,IACF,CAAC,EACA,MAAM,MAAM;AACX;AAAA,IACF,CAAC;AAAA,EACL;AACF;AAGO,IAAM,SAAS,CAAC,SAA2B,YAAkC;AAClF,gBAAc,OAAO,SAAS,OAAO;AACvC;;;ACrEA,IAAO,cAAQ;","names":[]}

package/package.json

@@ -11,28 +11,39 @@
     "url": "https://github.com/xylabs/sdk-js/issues"
   },
   "description": "Base functionality used throughout XY Labs TypeScript/JavaScript libraries",
-  "browser": "dist/esm/index.js",
-  "main": "dist/cjs/index.js",
-  "module": "dist/esm/index.js",
   "docs": "dist/docs.json",
-  "types": "dist/types/index.d.ts",
+  "types": "dist/index.d.ts",
   "exports": {
     ".": {
-      "node": {
-        "import": "./dist/esm/index.js",
-        "require": "./dist/cjs/index.js"
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
       },
-      "browser": {
-        "import": "./dist/esm/index.js",
-        "require": "./dist/cjs/index.js"
-      },
-      "default": "./dist/esm/index.js"
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      }
     },
     "./dist/docs.json": {
       "default": "./dist/docs.json"
     },
+    "./cjs": {
+      "default": "./dist/index.js"
+    },
+    "./docs": {
+      "default": "./dist/docs.json"
+    },
+    "./esm": {
+      "default": "./dist/index.mjs"
+    },
     "./package.json": "./package.json"
   },
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "scripts": {
+    "package-compile": "tsup && publint",
+    "package-recompile": "tsup && publint"
+  },
   "homepage": "https://xylabs.com",
   "keywords": [
     "xylabs",
@@ -41,11 +52,13 @@
     "esm"
   ],
   "dependencies": {
-    "@xylabs/delay": "^2.9.2"
+    "@xylabs/delay": "~2.10.0"
   },
   "devDependencies": {
-    "@xylabs/ts-scripts-yarn3": "^2.17.17",
-    "@xylabs/tsconfig": "^2.17.17"
+    "@xylabs/ts-scripts-yarn3": "^2.19.5",
+    "@xylabs/tsconfig": "^2.19.5",
+    "publint": "^0.2.2",
+    "tsup": "^7.2.0"
   },
   "publishConfig": {
     "access": "public"
@@ -55,5 +68,5 @@
     "url": "https://github.com/xylabs/sdk-js.git"
   },
   "sideEffects": false,
-  "version": "2.9.2"
+  "version": "2.10.0"
 }

package/tsup.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from 'tsup'
+
+// eslint-disable-next-line import/no-default-export
+export default defineConfig({
+  bundle: true,
+  cjsInterop: true,
+  clean: true,
+  dts: true,
+  entry: ['src'],
+  format: ['cjs', 'esm'],
+  sourcemap: true,
+  splitting: false,
+  tsconfig: 'tsconfig.json',
+})

package/dist/cjs/forget.js

@@ -1,70 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.forget = exports.ForgetPromise = void 0;
-const tslib_1 = require("tslib");
-const delay_1 = require("@xylabs/delay");
-class ForgetPromise {
-    static get active() {
-        return this.activeForgets > 0;
-    }
-    static awaitInactive(interval = 100, timeout) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            let timeoutRemaining = timeout;
-            while (this.active) {
-                yield (0, delay_1.delay)(interval);
-                if (timeoutRemaining !== undefined) {
-                    timeoutRemaining -= interval;
-                    if (timeoutRemaining <= 0) {
-                        return this.activeForgets;
-                    }
-                }
-            }
-            return 0;
-        });
-    }
-    //used to explicitly launch an async function (or Promise) with awaiting it
-    static forget(promise, timeout) {
-        let completed = false;
-        this.activeForgets++;
-        const promiseWrapper = () => tslib_1.__awaiter(this, void 0, void 0, function* () {
-            yield promise
-                .then(() => {
-                this.activeForgets--;
-                completed = true;
-            })
-                .catch(() => {
-                this.activeForgets--;
-                completed = true;
-            });
-        });
-        const promises = [promiseWrapper()];
-        //if there is a timeout, add it to the race
-        if (timeout) {
-            const timeoutFunc = () => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                var _a;
-                yield (0, delay_1.delay)(timeout.delay);
-                if (!completed) {
-                    console.log(`forget promise timeout out after ${timeout.delay}ms [Cancelling]`);
-                    (_a = timeout.cancel) === null || _a === void 0 ? void 0 : _a.call(timeout);
-                }
-            });
-            promises.push(timeoutFunc());
-        }
-        const all = Promise.race(promises);
-        all
-            .then(() => {
-            return;
-        })
-            .catch(() => {
-            return;
-        });
-    }
-}
-exports.ForgetPromise = ForgetPromise;
-ForgetPromise.activeForgets = 0;
-//used to explicitly launch an async function (or Promise) with awaiting it
-const forget = (promise, timeout) => {
-    ForgetPromise.forget(promise, timeout);
-};
-exports.forget = forget;
-//# sourceMappingURL=forget.js.map

package/dist/cjs/forget.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"forget.js","sourceRoot":"","sources":["../../src/forget.ts"],"names":[],"mappings":";;;;AAAA,yCAAqC;AAOrC,MAAa,aAAa;IAGxB,MAAM,KAAK,MAAM;QACf,OAAO,IAAI,CAAC,aAAa,GAAG,CAAC,CAAA;IAC/B,CAAC;IAED,MAAM,CAAO,aAAa,CAAC,QAAQ,GAAG,GAAG,EAAE,OAAgB;;YACzD,IAAI,gBAAgB,GAAG,OAAO,CAAA;YAC9B,OAAO,IAAI,CAAC,MAAM,EAAE;gBAClB,MAAM,IAAA,aAAK,EAAC,QAAQ,CAAC,CAAA;gBACrB,IAAI,gBAAgB,KAAK,SAAS,EAAE;oBAClC,gBAAgB,IAAI,QAAQ,CAAA;oBAC5B,IAAI,gBAAgB,IAAI,CAAC,EAAE;wBACzB,OAAO,IAAI,CAAC,aAAa,CAAA;qBAC1B;iBACF;aACF;YACD,OAAO,CAAC,CAAA;QACV,CAAC;KAAA;IAED,2EAA2E;IAC3E,MAAM,CAAC,MAAM,CAAC,OAAyB,EAAE,OAA6B;QACpE,IAAI,SAAS,GAAG,KAAK,CAAA;QACrB,IAAI,CAAC,aAAa,EAAE,CAAA;QAEpB,MAAM,cAAc,GAAG,GAAS,EAAE;YAChC,MAAM,OAAO;iBACV,IAAI,CAAC,GAAG,EAAE;gBACT,IAAI,CAAC,aAAa,EAAE,CAAA;gBACpB,SAAS,GAAG,IAAI,CAAA;YAClB,CAAC,CAAC;iBACD,KAAK,CAAC,GAAG,EAAE;gBACV,IAAI,CAAC,aAAa,EAAE,CAAA;gBACpB,SAAS,GAAG,IAAI,CAAA;YAClB,CAAC,CAAC,CAAA;QACN,CAAC,CAAA,CAAA;QAED,MAAM,QAAQ,GAAG,CAAC,cAAc,EAAE,CAAC,CAAA;QAEnC,2CAA2C;QAC3C,IAAI,OAAO,EAAE;YACX,MAAM,WAAW,GAAG,GAAS,EAAE;;gBAC7B,MAAM,IAAA,aAAK,EAAC,OAAO,CAAC,KAAK,CAAC,CAAA;gBAC1B,IAAI,CAAC,SAAS,EAAE;oBACd,OAAO,CAAC,GAAG,CAAC,oCAAoC,OAAO,CAAC,KAAK,iBAAiB,CAAC,CAAA;oBAC/E,MAAA,OAAO,CAAC,MAAM,uDAAI,CAAA;iBACnB;YACH,CAAC,CAAA,CAAA;YACD,QAAQ,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,CAAA;SAC7B;QAED,MAAM,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;QAElC,GAAG;aACA,IAAI,CAAC,GAAG,EAAE;YACT,OAAM;QACR,CAAC,CAAC;aACD,KAAK,CAAC,GAAG,EAAE;YACV,OAAM;QACR,CAAC,CAAC,CAAA;IACN,CAAC;;AA7DH,sCA8DC;AA7DQ,2BAAa,GAAG,CAAC,CAAA;AA+D1B,2EAA2E;AACpE,MAAM,MAAM,GAAG,CAAC,OAAyB,EAAE,OAA6B,EAAE,EAAE;IACjF,aAAa,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;AACxC,CAAC,CAAA;AAFY,QAAA,MAAM,UAElB"}

package/dist/cjs/index.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ForgetPromise = exports.forget = void 0;
-const forget_1 = require("./forget");
-Object.defineProperty(exports, "forget", { enumerable: true, get: function () { return forget_1.forget; } });
-Object.defineProperty(exports, "ForgetPromise", { enumerable: true, get: function () { return forget_1.ForgetPromise; } });
-// eslint-disable-next-line import/no-default-export
-exports.default = forget_1.forget;
-//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;AAAA,qCAAgD;AAEvC,uFAFA,eAAM,OAEA;AAAE,8FAFA,sBAAa,OAEA;AAE9B,oDAAoD;AACpD,kBAAe,eAAM,CAAA"}