import { t as Json } from "./types-ejoFe34F.mjs";
import { _ as LoggerInterface, o as LogLevelAliasType, r as LogLevel } from "./log-base-BP-JwjKY.mjs";
import { n as Encoder } from "./encoder-BcdNE4uv.mjs";
import { n as DisposerFunction } from "./dispose-types-Duihe1hZ.mjs";
import { t as TimerExecFunction } from "./dispose-utils-CxMUhvzb.mjs";
//#region src/common/msg/emitter.d.ts
type EmitterHandler = (...objs: any[]) => void;
type EmitterAllHandler<T = string> = (key: T, ...objs: any[]) => void;
declare type ListenerSignature<L> = { [E in keyof L]: (...args: any[]) => any };
declare interface DefaultListener {
  [k: string]: (...args: any[]) => any;
}
interface EmitterSubscriberOptions {
  priority?: number;
}
declare class Emitter<RemoteListener extends ListenerSignature<RemoteListener> = DefaultListener, LocalListener extends ListenerSignature<LocalListener> = DefaultListener> {
  private subscribers;
  private subscribersOnAny;
  _logEmitter: LoggerInterface;
  /** RPC like emitting of events. */
  call: RemoteListener;
  /**
   * Emits an event to all subscribers and executes their corresponding event handlers.
   *
   * @param event - The event to emit.
   * @param args - The arguments to pass to the event handlers.
   * @returns A promise that resolves to an array of results from all subscribers, or undefined if no subscribers are present.
   */
  getAll<U extends keyof RemoteListener>(event: U, ...args: Parameters<RemoteListener[U]>): Promise<ReturnType<RemoteListener[U]>[] | undefined>;
  /**
   * Emits an event to all subscribers and executes their corresponding event handlers.
   *
   * @param event - The event to emit.
   * @param args - The arguments to pass to the event handlers.
   * @returns A promise that resolves to the result of the first subscriber's handler, or undefined if no subscribers are present.
   */
  get<U extends keyof RemoteListener>(event: U, ...args: Parameters<RemoteListener[U]>): Promise<ReturnType<RemoteListener[U]> | undefined>;
  /**
   * Emits an event to all subscribers and executes their corresponding event handlers.
   *
   * @param event - The event to emit.
   * @param args - The arguments to pass to the event handlers.
   * @returns A promise that resolves to a boolean indicating whether the event was successfully emitted.
   */
  emit<U extends keyof RemoteListener>(event: U, ...args: Parameters<RemoteListener[U]>): Promise<boolean>;
  onAny(fn: EmitterHandler): void;
  on<U extends keyof LocalListener>(event: U, fn: LocalListener[U], opt?: EmitterSubscriberOptions): DisposerFunction;
  onCall(handlers: Partial<LocalListener>): void;
  once<U extends keyof LocalListener>(event: U, listener: LocalListener[U]): DisposerFunction;
  off<U extends keyof LocalListener>(event: U, listener: LocalListener[U]): this;
  removeAllListeners(): this;
  hasListeners(event: keyof LocalListener): boolean;
  waitOn<U extends keyof LocalListener, R = Parameters<LocalListener[U]>[0]>(event: U, timeoutMS?: number): Promise<R>;
  addEventListener<U extends keyof LocalListener>(event: U, fn: LocalListener[U], opt?: EmitterSubscriberOptions): DisposerFunction;
  removeEventListener<U extends keyof LocalListener>(event: U, listener: LocalListener[U]): this;
}
declare global {
  interface ZeedGlobalContext {
    emitter?: Emitter;
  }
  /**
   * Global emitter interface for Zeed, used for cross-module event emission.
   * @category Global
   */
  interface ZeedGlobalEmitter {}
}
/** Global emitter that will listen even across modules */
declare function getGlobalEmitter<T extends ListenerSignature<T> = ZeedGlobalEmitter>(): Emitter<T>;
interface ZeedGlobalEmitter extends DefaultListener {}
//#endregion
//#region src/common/msg/channel.d.ts
/** See http://developer.mozilla.org/en-US/docs/Web/API/MessageEvent */
interface ChannelMessageEvent<T = any> {
  data: T;
  origin?: string;
  lastEventId?: string;
}
/**
 * Inspired by
 * http://developer.mozilla.org/en-US/docs/Web/API/BroadcastChannel
 * https://deno.com/deploy/docs/runtime-broadcast-channel
 */
declare abstract class Channel<T = any, ContextType = Record<string, any>> extends Emitter<{
  message: (event: ChannelMessageEvent<T>) => void;
  messageerror: (event: ChannelMessageEvent<T>) => void;
  connect: () => void;
  disconnect: () => void;
  close: () => void;
}> {
  id: string;
  context: ContextType;
  abstract isConnected?: boolean;
  abstract postMessage(data: T): void;
  dispose: ((strictSync?: boolean) => Promise<any> | void) & {
    readonly disposed: number;
    add: (obj?: DisposerFunction | {
      dispose: DisposerFunction;
    }) => DisposerFunction | undefined;
    remove: (disposable: DisposerFunction | {
      dispose: DisposerFunction;
    }) => Promise<void> | void;
    track: (obj?: DisposerFunction | {
      dispose: DisposerFunction;
    }) => DisposerFunction | undefined;
    untrack: (disposable: DisposerFunction | {
      dispose: DisposerFunction;
    }) => Promise<void> | void;
    dispose: (strictSync?: boolean) => Promise<any> | void;
    disposeSync: () => void;
    sync: () => void;
    exec: (strictSync?: boolean) => Promise<any> | void;
    getSize(): number;
    isDisposed(): boolean;
    [Symbol.dispose](): void | Promise<any>;
    [Symbol.asyncDispose](): Promise<any>;
  };
  /** @deprecated use .dispose() */
  close(): void;
}
//#endregion
//#region src/common/msg/channel-debug.d.ts
/** Just track messages posted for debug purposes */
declare class DebugChannel extends Channel {
  messages: (Uint8Array | string)[];
  postMessage(data: Uint8Array | string): void;
  get isConnected(): boolean;
}
//#endregion
//#region src/common/msg/channel-local.d.ts
/** Very basic channel demonstrating local communication */
declare class LocalChannel extends Channel {
  isConnected: boolean;
  other?: LocalChannel;
  postMessage(data: any): void;
}
declare function createLocalChannelPair(): [LocalChannel, LocalChannel];
//#endregion
//#region src/common/msg/channel-resilient.d.ts
/**
 * Channel that buffers if not connected.
 * The actual channel can be removed and replaced.
 */
declare class ResillientChannel extends Channel {
  private channel?;
  private buffer;
  dispose: ((strictSync?: boolean) => Promise<any> | void) & {
    readonly disposed: number;
    add: (obj?: DisposerFunction | {
      dispose: DisposerFunction;
    }) => DisposerFunction | undefined;
    remove: (disposable: DisposerFunction | {
      dispose: DisposerFunction;
    }) => Promise<void> | void;
    track: (obj?: DisposerFunction | {
      dispose: DisposerFunction;
    }) => DisposerFunction | undefined;
    untrack: (disposable: DisposerFunction | {
      dispose: DisposerFunction;
    }) => Promise<void> | void;
    dispose: (strictSync?: boolean) => Promise<any> | void;
    disposeSync: () => void;
    sync: () => void;
    exec: (strictSync?: boolean) => Promise<any> | void;
    getSize(): number;
    isDisposed(): boolean;
    [Symbol.dispose](): void | Promise<any>;
    [Symbol.asyncDispose](): Promise<any>;
  } & {
    timeout: (fn: TimerExecFunction, timeout?: number) => DisposerFunction;
    interval: (fn: TimerExecFunction, interval?: number) => DisposerFunction;
    intervalPause: (fn: TimerExecFunction, interval?: number) => DisposerFunction;
    on: (emitter: any, eventName: string, fn: (ev?: any) => void, ...args: any[]) => DisposerFunction;
    once: (emitter: any, eventName: string, fn: (ev?: any) => void, ...args: any[]) => DisposerFunction;
  };
  private postMessageRaw;
  /** Post all buffered messages */
  flushBuffer(): void;
  /** Reset buffer without force sending */
  emptyBuffer(): void;
  /**
   * Set a new channel and flush buffer
   */
  setChannel(channel?: Channel): void;
  /** @deprecated use `setChannel(undefined)` */
  deleteChannel(): void;
  postMessage(data: Uint8Array | string): void;
  get isConnected(): boolean;
}
//#endregion
//#region src/common/msg/messages.d.ts
interface MessageAction {
  name: string;
  id: string;
  args?: Json[];
}
interface MessageResult {
  id: string;
  result?: Json;
  error?: {
    stack?: string;
    name: string;
    message: string;
  };
}
type Message = MessageAction | MessageResult;
interface MessagesOptions {
  timeout?: number;
}
interface MessagesDefaultMethods<L> {
  dispose: () => void;
  connect?: (channel: Channel) => void;
  options: (opt: MessagesOptions) => L;
}
type MessagesMethods<L> = L & MessagesDefaultMethods<L>;
type MessageDefinitions = Record<any, (...args: any) => Promise<any>>;
interface MessageHub {
  dispose: () => void;
  connect: (newChannel: Channel) => void;
  listen: <L extends MessageDefinitions>(newHandlers: L) => void;
  send: <L extends MessageDefinitions>() => MessagesMethods<L>;
}
declare function createPromiseProxy<P extends object>(fn: (name: string, args: any[], opt: any) => Promise<unknown>, opt: MessagesOptions, predefinedMethods?: any): P;
/**
 * RPC
 *
 * Features:
 * - Waits for connection
 * - Retries after fail
 * - Timeouts
 */
declare function useMessageHub(opt?: {
  name?: string;
  channel?: Channel;
  encoder?: Encoder;
  retryAfter?: number;
  ignoreUnhandled?: boolean;
  debug?: boolean;
  logLevel?: LogLevelAliasType;
}): MessageHub;
//#endregion
//#region src/common/msg/pubsub.d.ts
interface PubSubConfig {
  channel: Channel;
  encoder?: Encoder;
  name?: string;
  debug?: boolean;
}
declare class PubSub<L extends ListenerSignature<L> = DefaultListener> extends Emitter<L> {
  name: string;
  channel: Channel;
  encoder: Encoder;
  log: any;
  debug: boolean;
  get shortId(): string;
  constructor(opt: PubSubConfig);
  private emitSuper;
  emit<U extends keyof L>(event: U, ...args: Parameters<L[U]>): Promise<boolean>;
  publish<U extends keyof L>(event: U, ...args: Parameters<L[U]>): Promise<boolean>;
  subscribe<U extends keyof L>(event: U, fn: L[U], opt?: EmitterSubscriberOptions): DisposerFunction;
}
declare function usePubSub<L extends ListenerSignature<L> = DefaultListener>(opt: PubSubConfig): PubSub<L>;
//#endregion
//#region src/common/exec/progress.d.ts
interface ProgressOptions {
  totalUnits?: number;
  completeUnits?: number;
  resetWhenFinished?: boolean;
  name?: string;
}
/**
 * Progress helper with these properties:
 *
 * - `totalUnits` and `completedUnits` for progress
 * - Can be cancelled
 * - Sends events on cancel, changed and dispose
 * - Supports children and propagates values.
 *   Total progress is sum of all units in the tree.
 * - On `dispose` child removes itself from parent.
 */
declare class Progress extends Emitter<{
  progressCancelled: (progress: Progress) => void;
  progressChanged: (progress: Progress) => void;
  progressDispose: (progress: Progress) => void;
}> {
  private _totalUnits;
  private _completedUnits;
  private _isCancelled;
  private _resetWhenFinished;
  private _children;
  dispose: ((strictSync?: boolean) => Promise<any> | void) & {
    readonly disposed: number;
    add: (obj?: DisposerFunction | {
      dispose: DisposerFunction;
    }) => DisposerFunction | undefined;
    remove: (disposable: DisposerFunction | {
      dispose: DisposerFunction;
    }) => Promise<void> | void;
    track: (obj?: DisposerFunction | {
      dispose: DisposerFunction;
    }) => DisposerFunction | undefined;
    untrack: (disposable: DisposerFunction | {
      dispose: DisposerFunction;
    }) => Promise<void> | void;
    dispose: (strictSync?: boolean) => Promise<any> | void;
    disposeSync: () => void;
    sync: () => void;
    exec: (strictSync?: boolean) => Promise<any> | void;
    getSize(): number;
    isDisposed(): boolean;
    [Symbol.dispose](): void | Promise<any>;
    [Symbol.asyncDispose](): Promise<any>;
  };
  name: string;
  constructor(opt?: ProgressOptions);
  /** Notify others about changes and reset on completion, if flag is set. */
  private update;
  /** Fresh start */
  reset(): void;
  /** Notify and mark as cancelled. May take some time before having an effect. */
  cancel(): Promise<void>;
  /** Add child progress, which count into its parents units. On `dispose` it will auto remove itself from parent. */
  addChild(child: Progress): void;
  /** Create child progress.  */
  createChildProgress(opt?: ProgressOptions): Progress;
  removeChild(child: Progress): void;
  /** Total units including children */
  getTotalUnits(): number;
  /** Completed units including children */
  getCompletedUnits(): number;
  /** Cannot calculate progress, because totalUnits are missing. Special representation in UI. */
  isIndeterminate(): boolean;
  isCancelled(): boolean;
  /** Either disposed or all units completed. */
  isFinished(): boolean;
  /** Value from 0 to 1, where 1 is 100% completeness. */
  getFraction(): number;
  getChildrenCount(): number;
  /** Change total units. */
  setTotalUnits(units: number, completedUnits?: number): void;
  /** Relatively change total units. */
  incTotalUnits(step?: number): void;
  /** Set fixed number of completed units. */
  setCompletetedUnits(units: number): void;
  /** Set to 100% without disposing. */
  setCompleted(): void;
  /** Dynamically change completed units. */
  incCompletedUnits(step?: number): void;
  /** Progress tree to string for debuggin purposes. Consider using `name` attribute of Progress. */
  toString(indent?: number): string;
}
//#endregion
//#region src/common/exec/pool.d.ts
type PoolTaskIdConflictResolution = 'replace' | 'memoize' | 'prioritize' | 'error';
interface PoolConfig {
  name?: string;
  maxParallel?: number;
  idConflictResolution?: PoolTaskIdConflictResolution;
}
type PoolTaskFn<T = any> = (taskInfo: PoolTask<T>) => Promise<T>;
type PoolTaskState = 'waiting' | 'running' | 'finished';
/** Task */
interface PoolTask<T> {
  readonly id: string;
  readonly task: PoolTaskFn<T>;
  readonly done: (result?: any) => void;
  readonly setMax: (max: number) => void;
  readonly setResolved: (resolved: number) => void;
  readonly incResolved: (inc?: number) => void;
  state: PoolTaskState;
  priority: number;
  /** Same groups are executed only one at a time */
  group?: string;
  progress: Progress;
  max: number;
  resolved: number;
  result?: T;
  payload?: unknown;
}
interface PoolTaskEvents {
  didUpdate: (max: number, resolved: number, presentMax: number, presentResolved: number) => void;
  didStart: (id: string) => void;
  didCancel: (id: string) => void;
  didFinish: () => void;
  didResolve: (id: string, value: any) => void;
  didReject: (id: string, error: any) => void;
}
declare function usePool<T = any>(config?: PoolConfig): {
  events: Emitter<PoolTaskEvents, DefaultListener>;
  cancel: (id: string) => void;
  cancelAll: () => void;
  hasById: (id: string) => boolean;
  progress: Progress;
  enqueue: <P>(task: PoolTaskFn<T>, config?: {
    id?: string;
    max?: number;
    resolved?: number;
    group?: string;
    idConflictResolution?: PoolTaskIdConflictResolution;
    payload?: P;
  }) => {
    id: string;
    promise: Promise<any>;
    dispose: () => void;
    cancel: () => void;
  };
  dispose: ((strictSync?: boolean) => Promise<any> | void) & {
    readonly disposed: number;
    add: (obj?: DisposerFunction | {
      dispose: DisposerFunction;
    }) => DisposerFunction | undefined;
    remove: (disposable: DisposerFunction | {
      dispose: DisposerFunction;
    }) => Promise<void> | void;
    track: (obj?: DisposerFunction | {
      dispose: DisposerFunction;
    }) => DisposerFunction | undefined;
    untrack: (disposable: DisposerFunction | {
      dispose: DisposerFunction;
    }) => Promise<void> | void;
    dispose: (strictSync?: boolean) => Promise<any> | void;
    disposeSync: () => void;
    sync: () => void;
    exec: (strictSync?: boolean) => Promise<any> | void;
    getSize(): number;
    isDisposed(): boolean;
    [Symbol.dispose](): void | Promise<any>;
    [Symbol.asyncDispose](): Promise<any>;
  };
  waitFinishAll: () => Promise<unknown>;
};
//#endregion
//#region src/common/exec/queue.d.ts
type TaskFn<T = any> = () => Promise<T>;
interface TaskEvents {
  didUpdate: (max: number, resolved: number) => void;
  didStart: (max: number) => void;
  didCancel: () => void;
  didFinish: () => void;
}
/** Guarentee serial execution of tasks. Able to wait, pause, resume and cancel all. */
declare class SerialQueue extends Emitter<TaskEvents> {
  private queue;
  private waitToFinish;
  private currentTask?;
  private log;
  private countMax;
  private countResolved;
  private paused;
  name: string;
  constructor(opt?: {
    name?: string;
    logLevel?: LogLevel;
  });
  private performNext;
  /** Enqueue task to be executed when all other tasks are done. Except `immediate = true`. */
  enqueue<T>(task: TaskFn<T>, opt?: {
    immediate?: boolean;
    name?: string;
  }): Promise<T>;
  /** If a task is already performing, execute immediately. Otherwise enqueue as usual. */
  enqueueReentrant<T>(task: TaskFn<T>, opt?: {
    name?: string;
  }): Promise<T>;
  /** Remove all tasks from queue that are not yet executing. */
  cancelAll(_unblock?: boolean): Promise<void>;
  /** Pause execution after current task is finished. */
  pause(): Promise<void>;
  /** Resume paused queue. */
  resume(): void;
  /** Wait for all tasks to finish */
  wait(): Promise<unknown>;
  get isPaused(): boolean;
  get hasTasks(): boolean;
}
//#endregion
export { Channel as A, MessagesOptions as C, LocalChannel as D, ResillientChannel as E, EmitterHandler as F, EmitterSubscriberOptions as I, ListenerSignature as L, DefaultListener as M, Emitter as N, createLocalChannelPair as O, EmitterAllHandler as P, ZeedGlobalEmitter as R, MessagesMethods as S, useMessageHub as T, MessageAction as _, PoolTask as a, MessageResult as b, PoolTaskIdConflictResolution as c, Progress as d, ProgressOptions as f, Message as g, usePubSub as h, PoolConfig as i, ChannelMessageEvent as j, DebugChannel as k, PoolTaskState as l, PubSubConfig as m, TaskEvents as n, PoolTaskEvents as o, PubSub as p, TaskFn as r, PoolTaskFn as s, SerialQueue as t, usePool as u, MessageDefinitions as v, createPromiseProxy as w, MessagesDefaultMethods as x, MessageHub as y, getGlobalEmitter as z };
//# sourceMappingURL=index-C_3Y_s6f.d.mts.map