@gadgetinc/ggt 1.0.4 → 1.0.6

package/lib/services/util/promise.js

@@ -1,74 +0,0 @@
-import { _ as _define_property } from "@swc/helpers/_/_define_property";
-import ms from "ms";
-import { setTimeout } from "node:timers/promises";
-export const delay = (duration, options)=>setTimeout(ms(duration), undefined, options);
-/**
- * Long lived references to Promises stress the garbage collector in JS.
- *
- * Instead of caching resolved Promises, we cache these little data
- * objects instead which reference the resolution or rejection of the
- * Promise, allowing the Promise object to be free'd.
- */ export class PromiseWrapper {
-    async unwrap() {
-        if (this.pendingPromise) {
-            return await this.pendingPromise;
-        } else if (this.rejection) {
-            // eslint-disable-next-line @typescript-eslint/no-throw-literal
-            throw this.rejection;
-        } else {
-            return this.resolution;
-        }
-    }
-    constructor(promise){
-        _define_property(this, "resolution", void 0);
-        _define_property(this, "rejection", void 0);
-        _define_property(this, "pendingPromise", void 0);
-        this.pendingPromise = promise;
-        promise.then((res)=>{
-            this.resolution = res;
-            return res;
-        }).catch((err)=>{
-            this.rejection = err;
-        }).finally(()=>{
-            delete this.pendingPromise;
-        });
-    }
-}
-let _Symbol_toStringTag = Symbol.toStringTag;
-/**
- * A promise that can be resolved or rejected from outside its callback.
- *
- * This is typically used when you want to await a promise that is
- * resolved or rejected from outside the current scope, such as from an
- * event handler.
- *
- * @example
- * const signal = new PromiseSignal();
- * process.on("SIGINT", () => {
- *  signal.resolve();
- * });
- * await signal;
- */ export class PromiseSignal {
-    then(onfulfilled, onrejected) {
-        return this._promise.unwrap().then(onfulfilled, onrejected);
-    }
-    catch(onrejected) {
-        return this._promise.unwrap().catch(onrejected);
-    }
-    finally(onfinally) {
-        return this._promise.unwrap().finally(onfinally);
-    }
-    constructor(){
-        _define_property(this, _Symbol_toStringTag, void 0);
-        _define_property(this, "resolve", void 0);
-        _define_property(this, "reject", void 0);
-        _define_property(this, "_promise", void 0);
-        this._promise = new PromiseWrapper(new Promise((resolve, reject)=>{
-            this.resolve = resolve;
-            this.reject = reject;
-        }));
-        this[Symbol.toStringTag] = String(this._promise.pendingPromise);
-    }
-}
-
-//# sourceMappingURL=promise.js.map

package/lib/services/util/promise.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/services/util/promise.ts"],"sourcesContent":["import ms from \"ms\";\nimport type { TimerOptions } from \"node:timers\";\nimport { setTimeout } from \"node:timers/promises\";\n\nexport const delay = (duration: string, options?: TimerOptions): Promise<void> => setTimeout(ms(duration), undefined, options);\n\n/**\n * Long lived references to Promises stress the garbage collector in JS.\n *\n * Instead of caching resolved Promises, we cache these little data\n * objects instead which reference the resolution or rejection of the\n * Promise, allowing the Promise object to be free'd.\n */\nexport class PromiseWrapper<T> {\n  resolution?: T;\n  rejection?: unknown;\n  pendingPromise?: Promise<T>;\n\n  constructor(promise: Promise<T>) {\n    this.pendingPromise = promise;\n\n    promise\n      .then((res) => {\n        this.resolution = res;\n        return res;\n      })\n      .catch((err) => {\n        this.rejection = err;\n      })\n      .finally(() => {\n        delete this.pendingPromise;\n      });\n  }\n\n  async unwrap(): Promise<T> {\n    if (this.pendingPromise) {\n      return await this.pendingPromise;\n    } else if (this.rejection) {\n      // eslint-disable-next-line @typescript-eslint/no-throw-literal\n      throw this.rejection;\n    } else {\n      return this.resolution as T;\n    }\n  }\n}\n\n/**\n * A promise that can be resolved or rejected from outside its callback.\n *\n * This is typically used when you want to await a promise that is\n * resolved or rejected from outside the current scope, such as from an\n * event handler.\n *\n * @example\n * const signal = new PromiseSignal();\n * process.on(\"SIGINT\", () => {\n *  signal.resolve();\n * });\n * await signal;\n */\nexport class PromiseSignal<T = void> implements Promise<T> {\n  readonly [Symbol.toStringTag]!: string;\n\n  resolve!: (value: T | PromiseLike<T>) => void;\n  reject!: (reason?: unknown) => void;\n\n  private _promise: PromiseWrapper<T>;\n\n  constructor() {\n    this._promise = new PromiseWrapper<T>(\n      new Promise((resolve, reject) => {\n        this.resolve = resolve;\n        this.reject = reject;\n      }),\n    );\n\n    this[Symbol.toStringTag] = String(this._promise.pendingPromise);\n  }\n\n  then<R = T, E = never>(\n    onfulfilled?: (value: T) => R | PromiseLike<R>,\n    onrejected?: (reason: unknown) => E | PromiseLike<E>,\n  ): Promise<R | E> {\n    return this._promise.unwrap().then(onfulfilled, onrejected);\n  }\n\n  catch<E = never>(onrejected?: (reason: unknown) => E | PromiseLike<E>): Promise<T | E> {\n    return this._promise.unwrap().catch(onrejected);\n  }\n\n  finally(onfinally?: () => void): Promise<T> {\n    return this._promise.unwrap().finally(onfinally);\n  }\n}\n"],"names":["ms","setTimeout","delay","duration","options","undefined","PromiseWrapper","unwrap","pendingPromise","rejection","resolution","constructor","promise","then","res","catch","err","finally","Symbol","toStringTag","PromiseSignal","onfulfilled","onrejected","_promise","onfinally","resolve","reject","Promise","String"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";AAAA,OAAOA,QAAQ,KAAK;AAEpB,SAASC,UAAU,QAAQ,uBAAuB;AAElD,OAAO,MAAMC,QAAQ,CAACC,UAAkBC,UAA0CH,WAAWD,GAAGG,WAAWE,WAAWD,SAAS;AAE/H;;;;;;CAMC,GACD,OAAO,MAAME;IAqBX,MAAMC,SAAqB;QACzB,IAAI,IAAI,CAACC,cAAc,EAAE;YACvB,OAAO,MAAM,IAAI,CAACA,cAAc;QAClC,OAAO,IAAI,IAAI,CAACC,SAAS,EAAE;YACzB,+DAA+D;YAC/D,MAAM,IAAI,CAACA,SAAS;QACtB,OAAO;YACL,OAAO,IAAI,CAACC,UAAU;QACxB;IACF;IAzBAC,YAAYC,OAAmB,CAAE;QAJjCF,uBAAAA,cAAAA,KAAAA;QACAD,uBAAAA,aAAAA,KAAAA;QACAD,uBAAAA,kBAAAA,KAAAA;QAGE,IAAI,CAACA,cAAc,GAAGI;QAEtBA,QACGC,IAAI,CAAC,CAACC;YACL,IAAI,CAACJ,UAAU,GAAGI;YAClB,OAAOA;QACT,GACCC,KAAK,CAAC,CAACC;YACN,IAAI,CAACP,SAAS,GAAGO;QACnB,GACCC,OAAO,CAAC;YACP,OAAO,IAAI,CAACT,cAAc;QAC5B;IACJ;AAYF;IAiBYU,sBAAAA,OAAOC,WAAW;AAf9B;;;;;;;;;;;;;CAaC,GACD,OAAO,MAAMC;IAmBXP,KACEQ,WAA8C,EAC9CC,UAAoD,EACpC;QAChB,OAAO,IAAI,CAACC,QAAQ,CAAChB,MAAM,GAAGM,IAAI,CAACQ,aAAaC;IAClD;IAEAP,MAAiBO,UAAoD,EAAkB;QACrF,OAAO,IAAI,CAACC,QAAQ,CAAChB,MAAM,GAAGQ,KAAK,CAACO;IACtC;IAEAL,QAAQO,SAAsB,EAAc;QAC1C,OAAO,IAAI,CAACD,QAAQ,CAAChB,MAAM,GAAGU,OAAO,CAACO;IACxC;IAxBAb,aAAc;QAPd,uBAAUO,qBAAV,KAAA;QAEAO,uBAAAA,WAAAA,KAAAA;QACAC,uBAAAA,UAAAA,KAAAA;QAEA,uBAAQH,YAAR,KAAA;QAGE,IAAI,CAACA,QAAQ,GAAG,IAAIjB,eAClB,IAAIqB,QAAQ,CAACF,SAASC;YACpB,IAAI,CAACD,OAAO,GAAGA;YACf,IAAI,CAACC,MAAM,GAAGA;QAChB;QAGF,IAAI,CAACR,OAAOC,WAAW,CAAC,GAAGS,OAAO,IAAI,CAACL,QAAQ,CAACf,cAAc;IAChE;AAgBF"}

package/lib/services/util/types.js

@@ -1,5 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */ /**
- * Returns the arguments of a function.
- */ export { };
-
-//# sourceMappingURL=types.js.map

package/lib/services/util/types.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/services/util/types.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type { Promisable, Simplify } from \"type-fest\";\n\n/**\n * Makes all properties of an object optional, except for the specified\n * properties.\n */\nexport type PartialExcept<T, K extends keyof T> = Simplify<Partial<T> & Pick<T, K>>;\n\n/**\n * Represents a function that can accept any number of arguments\n * and returns any value.\n */\nexport type AnyFunction = (...args: any[]) => unknown;\n\n/**\n * Represents void or Promise<void>.\n */\nexport type AnyVoid = Promisable<void>;\n\n/**\n * Returns all property names of an object whose values are functions.\n */\nexport type FunctionPropertyNames<T> = {\n  [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;\n}[keyof T];\n\n/**\n * Returns the arguments of a function.\n */\nexport type ArgsType<T> = T extends (...args: infer A) => any ? A : never;\n"],"names":[],"rangeMappings":";;","mappings":"AAAA,qDAAqD,GA2BrD;;CAEC,GACD,WAA0E"}