@vrtmrz/livesync-commonlib 0.1.44 → 0.2.1

package/dist/services/lib/HandlerUtils.js

@@ -326,6 +326,30 @@ class FirstResultHandler extends MultiBinder {
     return false;
   }
 }
+class FirstHandledHandler extends MultiBinder {
+  /**
+   * Whether at least one callback is currently registered.
+   */
+  get hasHandlers() {
+    return this._callbackMap.size > 0;
+  }
+  /**
+   * Invokes handlers until one returns a completed or veto outcome.
+   * @param args The arguments to pass to the handlers.
+   * @returns The first handled outcome, or a not-applicable outcome when no handler applies.
+   * @throws Any synchronous callback error or rejected callback value, unchanged.
+   */
+  async invoke(...args) {
+    const callbacks = [...this._callbacks];
+    for (const callback of callbacks) {
+      const outcome = await Promise.resolve(callback(...args));
+      if (outcome.kind !== "not-applicable") {
+        return outcome;
+      }
+    }
+    return { kind: "not-applicable" };
+  }
+}
 function getMultipleBound(handler) {
   const _handler = "invoke" in handler ? handler.invoke : handler.dispatch;
   const __handler = _handler.bind(handler);
@@ -367,6 +391,17 @@ function firstResultFunction(name) {
   const handler = new FirstResultHandler(name ?? "firstResultFunction");
   return getMultipleBound(handler);
 }
+function firstHandledFunction(name) {
+  const handler = new FirstHandledHandler(
+    name ?? "firstHandledFunction"
+  );
+  const toHandlerCallback = (callback) => callback;
+  const bound = (...args) => handler.invoke(...args);
+  bound.addHandler = (callback, priority) => handler.addHandler(toHandlerCallback(callback), priority);
+  bound.removeHandler = (callback) => handler.removeHandler(toHandlerCallback(callback));
+  Object.defineProperty(bound, "hasHandlers", { get: () => handler.hasHandlers });
+  return bound;
+}
 function dispatchParallelFunction(name) {
   const handler = new DispatchParallel(
     name ?? "dispatchParallelFunction"
@@ -452,6 +487,15 @@ function handlers() {
     firstResult(name) {
       return firstResultFunction(String(name));
     },
+    /**
+     * Create a handler that invokes registered handlers until one completes or vetoes.
+     * Callback errors and rejections propagate unchanged.
+     * @param name The name of the callback on `T`.
+     * @returns A bound handler with a live `hasHandlers` property.
+     */
+    firstHandled(name) {
+      return firstHandledFunction(String(name));
+    },
     /**
      * Create a handler that invokes all added handler functions in parallel.
      * @param name
@@ -481,6 +525,7 @@ export {
   BooleanHandlerBase,
   Dispatch,
   DispatchParallel,
+  FirstHandledHandler,
   FirstResultHandler,
   LazyBinder,
   MultiBinder,
@@ -494,6 +539,7 @@ export {
   bailFirstFailureWithResultFunction,
   bindableFunction,
   dispatchParallelFunction,
+  firstHandledFunction,
   firstResultFunction,
   handlers,
   lazyBindableFunction

package/dist/string_and_binary/chunks.js

@@ -404,14 +404,16 @@ async function splitPiecesRabinKarp(dataSrc, absoluteMaxPieceSize, doPlainSplit,
     }
   }
   const chunkUnitBinary = 256 * 1024;
-  const fixedAvgChunkSize = plainSplit ? chunkUnitPlain * 4 : chunkUnitBinary * 4;
   const fixedMaxChunkSize = plainSplit ? chunkUnitPlain * 16 : chunkUnitBinary * 16;
-  const fixedMinChunkSize = plainSplit ? chunkUnitPlain * 2 : chunkUnitBinary;
   const rkAbsoluteMaxPieceSizeFloor = 30 * 1024;
   const effectiveAbsoluteMaxPieceSize = Math.max(absoluteMaxPieceSize, rkAbsoluteMaxPieceSizeFloor);
   const maxChunkSize = Math.min(fixedMaxChunkSize, effectiveAbsoluteMaxPieceSize);
-  const minChunkSize = Math.min(Math.max(fixedMinChunkSize, minimumChunkSize), maxChunkSize);
-  const avgChunkSize = Math.min(Math.max(fixedAvgChunkSize, minChunkSize), maxChunkSize);
+  const proportionalGap = Math.max(1, Math.floor(maxChunkSize / 4));
+  const minChunkSize = Math.min(
+    Math.max(plainSplit ? chunkUnitPlain * 2 : proportionalGap, minimumChunkSize),
+    maxChunkSize
+  );
+  const avgChunkSize = plainSplit ? Math.min(Math.max(chunkUnitPlain * 4, minChunkSize), maxChunkSize) : proportionalGap;
   const windowSize = 48;
   const hashModulus = avgChunkSize;
   const boundaryPattern = 1;
@@ -429,7 +431,7 @@ async function splitPiecesRabinKarp(dataSrc, absoluteMaxPieceSize, doPlainSplit,
   return async function* piecesBlob() {
     while (pos < length) {
       const byte = buffer[pos];
-      if (pos >= start + windowSize) {
+      if (pos >= windowSize) {
         const oldByte = buffer[pos - windowSize];
         const oldByteTerm = Math.imul(oldByte, P_pow_w);
         hash = hash - oldByteTerm | 0;

package/dist/uiCommands.d.ts

@@ -0,0 +1,26 @@
+declare const commandTypes: unique symbol;
+/** An immutable declaration which associates a stable name with request and result types. */
+export interface UICommand<Request, Result> {
+    readonly id: string;
+    readonly [commandTypes]?: {
+        readonly request: (value: Request) => Request;
+        readonly result: (value: Result) => Result;
+    };
+}
+/** Declare a command without registering it in any global state. */
+export declare function declareUICommand<Request, Result>(id: string): UICommand<Request, Result>;
+/** Instance-owned command handlers for one host or service composition. */
+export declare class UICommandRegistry {
+    private readonly definitions;
+    private readonly handlers;
+    private disposed;
+    register<Request, Result>(command: UICommand<Request, Result>, handler: (request: NoInfer<Request>) => NoInfer<Result> | Promise<NoInfer<Result>>): () => void;
+    invoke<Request, Result>(command: UICommand<Request, Result>, input: NoInfer<Request>): Promise<{
+        status: "handled";
+        value: Result;
+    } | {
+        status: "unavailable";
+    }>;
+    dispose(): void;
+}
+export {};

package/dist/uiCommands.js

@@ -0,0 +1,57 @@
+function declareUICommand(id) {
+  return Object.freeze({ id });
+}
+class UICommandRegistry {
+  definitions = /* @__PURE__ */ new Map();
+  handlers = /* @__PURE__ */ new Map();
+  disposed = false;
+  register(command, handler) {
+    if (this.disposed) {
+      throw new Error("Cannot register a UI command on a disposed registry");
+    }
+    const knownDefinition = this.definitions.get(command.id);
+    if (knownDefinition !== void 0 && knownDefinition !== command) {
+      throw new Error(`A conflicting command definition is already known for '${command.id}'`);
+    }
+    if (this.handlers.has(command.id)) {
+      throw new Error(`A handler is already registered for '${command.id}'`);
+    }
+    this.definitions.set(command.id, command);
+    const entry = {
+      command,
+      handler: (input) => handler(input)
+    };
+    this.handlers.set(command.id, entry);
+    let active = true;
+    return () => {
+      if (!active) return;
+      active = false;
+      if (this.handlers.get(command.id) === entry) {
+        this.handlers.delete(command.id);
+      }
+    };
+  }
+  async invoke(command, input) {
+    if (this.disposed) {
+      return { status: "unavailable" };
+    }
+    const entry = this.handlers.get(command.id);
+    if (entry === void 0 || entry.command !== command) {
+      return { status: "unavailable" };
+    }
+    return {
+      status: "handled",
+      value: await entry.handler(input)
+    };
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.handlers.clear();
+    this.definitions.clear();
+  }
+}
+export {
+  UICommandRegistry,
+  declareUICommand
+};