@embedpdf/models 2.0.0-next.2 → 2.0.0

package/dist/index.d.ts

@@ -15,6 +15,7 @@ export * from './color';
 export * from './date';
 export * from './helpers';
 export * from './uuid';
+export * from './compound-task';
 /**
  * ignore will do nothing when called.
  *

package/dist/index.js

@@ -367,6 +367,7 @@ class PerfLogger {
    * create new PerfLogger
    */
   constructor() {
+    this.marks = /* @__PURE__ */ new Map();
   }
   /** {@inheritDoc Logger.isEnabled} */
   isEnabled() {
@@ -386,21 +387,23 @@ class PerfLogger {
   }
   /** {@inheritDoc Logger.perf} */
   perf(source, category, event, phase, identifier, ...args) {
+    const markName = `${source}.${category}.${event}.${phase}.${identifier}`;
     switch (phase) {
       case "Begin":
-        globalThis.performance.mark(`${source}.${category}.${event}.${phase}.${identifier}`, {
-          detail: args
-        });
+        globalThis.performance.mark(markName, { detail: args });
+        this.marks.set(`${source}.${category}.${event}.${identifier}`, Date.now());
         break;
       case "End":
-        globalThis.performance.mark(`${source}.${category}.${event}.${phase}.${identifier}`, {
-          detail: args
-        });
-        globalThis.performance.measure(
-          `${source}.${category}.${event}.Measure.${identifier}`,
-          `${source}.${category}.${event}.Begin.${identifier}`,
-          `${source}.${category}.${event}.End.${identifier}`
-        );
+        globalThis.performance.mark(markName, { detail: args });
+        const measureName = `${source}.${category}.${event}.Measure.${identifier}`;
+        const beginMark = `${source}.${category}.${event}.Begin.${identifier}`;
+        globalThis.performance.measure(measureName, beginMark, markName);
+        const startTime = this.marks.get(`${source}.${category}.${event}.${identifier}`);
+        if (startTime) {
+          const duration = Date.now() - startTime;
+          console.info(`⏱️ ${source}.${category}.${event}.${identifier}: ${duration}ms`);
+          this.marks.delete(`${source}.${category}.${event}.${identifier}`);
+        }
         break;
     }
   }
@@ -1783,11 +1786,196 @@ function uuidV4() {
   const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
   return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
 }
+class CompoundTask extends Task {
+  constructor(config = {}) {
+    super();
+    this.children = /* @__PURE__ */ new Map();
+    this.childResults = [];
+    this.completedCount = 0;
+    this.expectedCount = 0;
+    this.isFinalized = false;
+    this.config = {
+      aggregate: config.aggregate ?? ((results) => results),
+      onChildComplete: config.onChildComplete ?? (() => {
+      }),
+      failFast: config.failFast ?? true
+    };
+  }
+  /**
+   * Add a child task - automatically wires up completion handling
+   */
+  addChild(child, index) {
+    if (this.state.stage !== TaskStage.Pending) {
+      if (this.state.stage === TaskStage.Aborted) {
+        child.abort(this.state.reason);
+      }
+      return this;
+    }
+    const childIndex = index ?? this.expectedCount;
+    this.expectedCount = Math.max(this.expectedCount, childIndex + 1);
+    this.children.set(child, childIndex);
+    child.wait(
+      (result) => this.handleChildSuccess(child, result, childIndex),
+      (error) => this.handleChildError(child, error, childIndex)
+    );
+    return this;
+  }
+  /**
+   * Finalize - signals that no more children will be added
+   * If no children were added, resolves immediately
+   */
+  finalize() {
+    if (this.isFinalized) return this;
+    this.isFinalized = true;
+    if (this.expectedCount === 0) {
+      this.resolve(this.config.aggregate([]));
+    }
+    return this;
+  }
+  handleChildSuccess(child, result, index) {
+    if (this.state.stage !== TaskStage.Pending) return;
+    this.childResults[index] = result;
+    this.completedCount++;
+    this.children.delete(child);
+    const progressValue = this.config.onChildComplete(
+      this.completedCount,
+      this.expectedCount,
+      result,
+      index
+    );
+    if (progressValue !== void 0) {
+      this.progress(progressValue);
+    }
+    if (this.completedCount === this.expectedCount) {
+      const finalResult = this.config.aggregate(this.childResults);
+      this.resolve(finalResult);
+    }
+  }
+  handleChildError(child, error, index) {
+    if (this.state.stage !== TaskStage.Pending) return;
+    this.children.delete(child);
+    if (this.config.failFast) {
+      for (const [otherChild] of this.children) {
+        otherChild.abort("Sibling task failed");
+      }
+      this.children.clear();
+      this.fail(error);
+    } else {
+      this.childResults[index] = void 0;
+      this.completedCount++;
+      if (this.completedCount === this.expectedCount) {
+        const finalResult = this.config.aggregate(this.childResults);
+        this.resolve(finalResult);
+      }
+    }
+  }
+  /**
+   * Override abort to propagate to all children
+   */
+  abort(reason) {
+    for (const [child] of this.children) {
+      child.abort(reason);
+    }
+    this.children.clear();
+    super.abort(reason);
+  }
+  /**
+   * Override reject to abort all children
+   */
+  reject(reason) {
+    for (const [child] of this.children) {
+      child.abort(reason);
+    }
+    this.children.clear();
+    super.reject(reason);
+  }
+  /**
+   * Get count of pending children
+   */
+  getPendingCount() {
+    return this.children.size;
+  }
+  /**
+   * Get count of completed children
+   */
+  getCompletedCount() {
+    return this.completedCount;
+  }
+  // ============================================================================
+  // Static Factory Methods
+  // ============================================================================
+  /**
+   * Gather results from an array of tasks (progress-friendly).
+   * (Formerly: all)
+   */
+  static gather(tasks) {
+    const compound = new CompoundTask({
+      aggregate: (results) => results,
+      onChildComplete: (completed, total) => ({ completed, total })
+    });
+    tasks.forEach((task, index) => compound.addChild(task, index));
+    compound.finalize();
+    return compound;
+  }
+  /**
+   * Gather into a Record indexed by number.
+   * (Formerly: allIndexed)
+   */
+  static gatherIndexed(tasks) {
+    const compound = new CompoundTask({
+      aggregate: (results) => {
+        const record = {};
+        results.forEach((result, index) => {
+          record[index] = result;
+        });
+        return record;
+      },
+      onChildComplete: (_completed, _total, result, index) => ({ page: index, result })
+    });
+    tasks.forEach((task, index) => compound.addChild(task, index));
+    compound.finalize();
+    return compound;
+  }
+  /**
+   * Gather with custom aggregation config.
+   * (Formerly: from)
+   */
+  static gatherFrom(tasks, config) {
+    const compound = new CompoundTask(config);
+    tasks.forEach((task, index) => compound.addChild(task, index));
+    compound.finalize();
+    return compound;
+  }
+  /**
+   * Resolve with the first successful child; abort the rest.
+   * (Formerly: race)
+   */
+  static first(tasks) {
+    let resolved = false;
+    const compound = new CompoundTask({
+      aggregate: (results) => results[0],
+      failFast: false
+    });
+    compound["handleChildSuccess"] = (child, result) => {
+      if (!resolved) {
+        resolved = true;
+        for (const [otherChild] of compound["children"]) {
+          if (otherChild !== child) otherChild.abort("Race won by sibling");
+        }
+        compound.resolve(result);
+      }
+    };
+    tasks.forEach((task, index) => compound.addChild(task, index));
+    compound.finalize();
+    return compound;
+  }
+}
 function ignore() {
 }
 export {
   AllLogger,
   AppearanceMode,
+  CompoundTask,
   ConsoleLogger,
   LevelLogger,
   LogLevel,