@embedpdf/models 1.0.11 → 1.0.12

package/dist/task.d.ts

@@ -0,0 +1,188 @@
+/**
+ * Stage of task
+ *
+ * @public
+ */
+export declare enum TaskStage {
+    /**
+     * Task is pending, means it just start executing
+     */
+    Pending = 0,
+    /**
+     * Task is succeed
+     */
+    Resolved = 1,
+    /**
+     * Task is failed
+     */
+    Rejected = 2,
+    /**
+     * Task is aborted
+     */
+    Aborted = 3
+}
+export interface TaskError<D> {
+    /**
+     * task error type
+     */
+    type: 'reject' | 'abort';
+    /**
+     * task error
+     */
+    reason: D;
+}
+/**
+ * callback that will be called when task is resolved
+ *
+ * @public
+ */
+export type ResolvedCallback<R> = (r: R) => void;
+/**
+ * callback that will be called when task is rejected
+ *
+ * @public
+ */
+export type RejectedCallback<D> = (e: TaskError<D>) => void;
+/**
+ * Task state in different stage
+ *
+ * @public
+ */
+export type TaskState<R, D> = {
+    stage: TaskStage.Pending;
+} | {
+    stage: TaskStage.Resolved;
+    result: R;
+} | {
+    stage: TaskStage.Rejected;
+    reason: D;
+} | {
+    stage: TaskStage.Aborted;
+    reason: D;
+};
+/**
+ * Result type for allSettled
+ *
+ * @public
+ */
+export type TaskSettledResult<R, D> = {
+    status: 'resolved';
+    value: R;
+} | {
+    status: 'rejected';
+    reason: D;
+} | {
+    status: 'aborted';
+    reason: D;
+};
+export declare class TaskAbortedError<D> extends Error {
+    constructor(reason: D);
+}
+export declare class TaskRejectedError<D> extends Error {
+    constructor(reason: D);
+}
+/**
+ * Base class of task
+ *
+ * @public
+ */
+export declare class Task<R, D> {
+    state: TaskState<R, D>;
+    /**
+     * callbacks that will be executed when task is resolved
+     */
+    resolvedCallbacks: ResolvedCallback<R>[];
+    /**
+     * callbacks that will be executed when task is rejected
+     */
+    rejectedCallbacks: RejectedCallback<D>[];
+    /**
+     * Promise that will be resolved when task is settled
+     */
+    private _promise;
+    /**
+     * Convert task to promise
+     * @returns promise that will be resolved when task is settled
+     */
+    toPromise(): Promise<R>;
+    /**
+     * wait for task to be settled
+     * @param resolvedCallback - callback for resolved value
+     * @param rejectedCallback - callback for rejected value
+     */
+    wait(resolvedCallback: ResolvedCallback<R>, rejectedCallback: RejectedCallback<D>): void;
+    /**
+     * resolve task with specific result
+     * @param result - result value
+     */
+    resolve(result: R): void;
+    /**
+     * reject task with specific reason
+     * @param reason - abort reason
+     *
+     */
+    reject(reason: D): void;
+    /**
+     * abort task with specific reason
+     * @param reason - abort reason
+     */
+    abort(reason: D): void;
+    /**
+     * fail task with a TaskError from another task
+     * This is a convenience method for error propagation between tasks
+     * @param error - TaskError from another task
+     */
+    fail(error: TaskError<D>): void;
+    /**
+     * Static method to wait for all tasks to resolve
+     * Returns a new task that resolves with an array of all results
+     * Rejects immediately if any task fails
+     *
+     * @param tasks - array of tasks to wait for
+     * @returns new task that resolves when all input tasks resolve
+     * @public
+     */
+    static all<R extends readonly Task<any, any>[]>(tasks: R): Task<{
+        [K in keyof R]: R[K] extends Task<infer U, any> ? U : never;
+    }, any>;
+    /**
+     * Static method to wait for all tasks to settle (resolve, reject, or abort)
+     * Always resolves with an array of settlement results
+     *
+     * @param tasks - array of tasks to wait for
+     * @returns new task that resolves when all input tasks settle
+     * @public
+     */
+    static allSettled<R extends readonly Task<any, any>[]>(tasks: R): Task<{
+        [K in keyof R]: R[K] extends Task<infer U, infer E> ? TaskSettledResult<U, E> : never;
+    }, never>;
+    /**
+     * Static method that resolves/rejects with the first task that settles
+     *
+     * @param tasks - array of tasks to race
+     * @returns new task that settles with the first input task that settles
+     * @public
+     */
+    static race<R extends readonly Task<any, any>[]>(tasks: R): Task<R[number] extends Task<infer U, any> ? U : never, R[number] extends Task<any, infer E> ? E : never>;
+    /**
+     * Utility to track progress of multiple tasks
+     *
+     * @param tasks - array of tasks to track
+     * @param onProgress - callback called when any task completes
+     * @returns new task that resolves when all input tasks resolve
+     * @public
+     */
+    static withProgress<R extends readonly Task<any, any>[]>(tasks: R, onProgress?: (completed: number, total: number) => void): Task<{
+        [K in keyof R]: R[K] extends Task<infer U, any> ? U : never;
+    }, any>;
+}
+/**
+ * Type that represent the result of executing task
+ */
+export type TaskReturn<T extends Task<any, any>> = T extends Task<infer R, infer E> ? {
+    type: 'result';
+    value: R;
+} | {
+    type: 'error';
+    value: TaskError<E>;
+} : never;

package/dist/task.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@embedpdf/models",
-  "version": "1.0.11",
+  "version": "1.0.12",
   "private": false,
   "description": "Shared type definitions, data models, and utility helpers (geometry, tasks, logging, PDF primitives) that underpin every package in the EmbedPDF ecosystem.",
   "type": "module",
@@ -30,20 +30,18 @@
   "author": "Bob Singor, Ji Chang",
   "license": "MIT",
   "devDependencies": {
-    "tsup": "^8.0.0",
     "typescript": "^5.0.0",
     "@types/jest": "^29.5.14",
-    "jest": "^29.7.0"
+    "jest": "^29.7.0",
+    "@embedpdf/build": "1.0.0"
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "PROJECT_CWD=$(pwd) pnpm -w p:build",
-    "build:watch": "PROJECT_CWD=$(pwd) pnpm -w p:build:watch",
-    "clean": "PROJECT_CWD=$(pwd) pnpm -w p:clean",
-    "lint": "PROJECT_CWD=$(pwd) pnpm -w p:lint",
-    "lint:fix": "PROJECT_CWD=$(pwd) pnpm -w p:lint:fix",
-    "typecheck": "PROJECT_CWD=$(pwd) pnpm -w p:typecheck"
+    "build": "pnpm run clean && vite build",
+    "clean": "rimraf dist",
+    "lint": "eslint src --color",
+    "lint:fix": "eslint src --color --fix"
   }
 }