@h-rig/cli 0.0.6-alpha.81 → 0.0.6-alpha.83

package/dist/src/app-opentui/runtime-resources.d.ts

@@ -0,0 +1,16 @@
+export type Disposer = () => void;
+export declare class RuntimeResources {
+    private readonly disposers;
+    private disposed;
+    add(disposer: Disposer): Disposer;
+    setTimeout(callback: () => void, delayMs: number): ReturnType<typeof setTimeout>;
+    setInterval(callback: () => void, delayMs: number): ReturnType<typeof setInterval>;
+    clearTimeout(timer: ReturnType<typeof setTimeout> | null | undefined): void;
+    on<TEmitter extends {
+        on(event: string, listener: (...args: never[]) => void): unknown;
+        off?(event: string, listener: (...args: never[]) => void): unknown;
+        removeListener?(event: string, listener: (...args: never[]) => void): unknown;
+    }>(emitter: TEmitter, event: string, listener: (...args: never[]) => void): void;
+    disposeAll(): void;
+    private remove;
+}

package/dist/src/app-opentui/runtime-resources.js

@@ -0,0 +1,62 @@
+// @bun
+// packages/cli/src/app-opentui/runtime-resources.ts
+class RuntimeResources {
+  disposers = [];
+  disposed = false;
+  add(disposer) {
+    if (this.disposed) {
+      disposer();
+      return () => {
+        return;
+      };
+    }
+    this.disposers.push(disposer);
+    return disposer;
+  }
+  setTimeout(callback, delayMs) {
+    const timer = setTimeout(() => {
+      this.remove(dispose);
+      callback();
+    }, delayMs);
+    const dispose = () => clearTimeout(timer);
+    this.add(dispose);
+    return timer;
+  }
+  setInterval(callback, delayMs) {
+    const timer = setInterval(callback, delayMs);
+    this.add(() => clearInterval(timer));
+    return timer;
+  }
+  clearTimeout(timer) {
+    if (timer)
+      clearTimeout(timer);
+  }
+  on(emitter, event, listener) {
+    emitter.on(event, listener);
+    this.add(() => {
+      if (typeof emitter.off === "function")
+        emitter.off(event, listener);
+      else
+        emitter.removeListener?.(event, listener);
+    });
+  }
+  disposeAll() {
+    if (this.disposed)
+      return;
+    this.disposed = true;
+    for (let index = this.disposers.length - 1;index >= 0; index -= 1) {
+      try {
+        this.disposers[index]?.();
+      } catch {}
+    }
+    this.disposers.length = 0;
+  }
+  remove(disposer) {
+    const index = this.disposers.indexOf(disposer);
+    if (index >= 0)
+      this.disposers.splice(index, 1);
+  }
+}
+export {
+  RuntimeResources
+};