hazo_files 1.4.7 → 1.5.2

package/dist/background-upload/index.d.mts

@@ -0,0 +1,166 @@
+type JobStatus = 'queued' | 'uploading' | 'processing' | 'awaiting_confirmation' | 'completing' | 'done' | 'error';
+interface UploadFile {
+    file: File;
+    file_id?: string;
+    file_name: string;
+    mime_type: string;
+    download_url?: string;
+}
+interface PipelineContext {
+    files: UploadFile[];
+    group_id: string;
+    group_label?: string;
+    extracted_data: Record<string, unknown>;
+    metadata: Record<string, unknown>;
+}
+interface ConfirmationResult {
+    confirmed: boolean;
+    data?: unknown;
+}
+interface JobHandle {
+    job_id: string;
+    set_status: (status: JobStatus) => void;
+    set_progress: (current: number, total: number) => void;
+    request_confirmation: <T = unknown>(payload: T) => Promise<ConfirmationResult>;
+    is_cancelled: () => boolean;
+}
+interface PipelineStep {
+    name: string;
+    execute: (context: PipelineContext, handle: JobHandle) => Promise<void>;
+}
+interface CreateBatchOptions {
+    files: File[];
+    group_id: string;
+    group_label?: string;
+    metadata?: Record<string, unknown>;
+    pipeline_steps?: PipelineStep[];
+}
+interface JobSnapshot {
+    job_id: string;
+    batch_id: string;
+    status: JobStatus;
+    group_id: string;
+    group_label?: string;
+    files: UploadFile[];
+    progress: {
+        current: number;
+        total: number;
+    } | null;
+    extracted_data: Record<string, unknown>;
+    error: string | null;
+    metadata: Record<string, unknown>;
+    confirmation_payload: unknown | null;
+    created_at: number;
+    updated_at: number;
+}
+interface BatchInfo {
+    batch_id: string;
+    job_ids: string[];
+    total: number;
+    completed: number;
+    failed: number;
+}
+interface UploadManagerEvents {
+    'job:created': {
+        job: JobSnapshot;
+    };
+    'job:status_changed': {
+        job: JobSnapshot;
+        previous_status: JobStatus;
+    };
+    'job:progress': {
+        job: JobSnapshot;
+    };
+    'job:completed': {
+        job: JobSnapshot;
+    };
+    'job:error': {
+        job: JobSnapshot;
+        error: string;
+    };
+    'job:confirmation_needed': {
+        job: JobSnapshot;
+        payload: unknown;
+    };
+    'job:confirmation_resolved': {
+        job: JobSnapshot;
+        result: ConfirmationResult;
+    };
+    'batch:progress': {
+        batch: BatchInfo;
+    };
+    'batch:completed': {
+        batch: BatchInfo;
+    };
+}
+interface UploadManagerConfig {
+    max_concurrent?: number;
+    default_pipeline_steps?: PipelineStep[];
+}
+
+type Listener<T> = (data: T) => void;
+declare class TypedEventEmitter<TEvents extends Record<string, any>> {
+    private listeners;
+    on<K extends keyof TEvents>(event: K, listener: Listener<TEvents[K]>): () => void;
+    emit<K extends keyof TEvents>(event: K, data: TEvents[K]): void;
+    off<K extends keyof TEvents>(event: K, listener: Listener<TEvents[K]>): void;
+    removeAllListeners(): void;
+}
+
+interface JobInit {
+    batch_id: string;
+    files: File[];
+    group_id: string;
+    group_label?: string;
+    pipeline_steps: PipelineStep[];
+    metadata?: Record<string, unknown>;
+}
+declare class Job {
+    readonly job_id: string;
+    readonly batch_id: string;
+    readonly created_at: number;
+    private status;
+    private progress;
+    private error;
+    private confirmation_payload;
+    private confirmation_resolve;
+    private context;
+    private readonly pipeline_steps;
+    private updated_at;
+    constructor(init: JobInit);
+    get_snapshot(): JobSnapshot;
+    set_status(status: JobStatus): void;
+    set_progress(current: number, total: number): void;
+    set_error(message: string): void;
+    request_confirmation<T>(payload: T): Promise<ConfirmationResult>;
+    resolve_confirmation(result: ConfirmationResult): void;
+    get_context(): PipelineContext;
+    get_pipeline_steps(): PipelineStep[];
+}
+
+declare class PipelineExecutor {
+    execute(job: Job, emitter: TypedEventEmitter<UploadManagerEvents>): Promise<void>;
+}
+
+declare class UploadManager {
+    private jobs;
+    private batches;
+    private executor;
+    private emitter;
+    private queue;
+    private running;
+    private destroyed;
+    private readonly config;
+    constructor(config?: UploadManagerConfig);
+    on<K extends keyof UploadManagerEvents>(event: K, listener: (data: UploadManagerEvents[K]) => void): () => void;
+    submit_batch(options: CreateBatchOptions): string;
+    get_jobs_for_group(group_id: string): JobSnapshot[];
+    get_job(job_id: string): JobSnapshot | null;
+    get_active_jobs(): JobSnapshot[];
+    resolve_confirmation(job_id: string, result: ConfirmationResult): void;
+    destroy(): void;
+    private process_queue;
+    private on_job_settled;
+}
+
+export { type BatchInfo, type ConfirmationResult, type CreateBatchOptions, Job, type JobHandle, type JobSnapshot, type JobStatus, type PipelineContext, PipelineExecutor, type PipelineStep, TypedEventEmitter, type UploadFile, UploadManager, type UploadManagerConfig, type UploadManagerEvents };

package/dist/background-upload/index.d.ts

@@ -0,0 +1,166 @@
+type JobStatus = 'queued' | 'uploading' | 'processing' | 'awaiting_confirmation' | 'completing' | 'done' | 'error';
+interface UploadFile {
+    file: File;
+    file_id?: string;
+    file_name: string;
+    mime_type: string;
+    download_url?: string;
+}
+interface PipelineContext {
+    files: UploadFile[];
+    group_id: string;
+    group_label?: string;
+    extracted_data: Record<string, unknown>;
+    metadata: Record<string, unknown>;
+}
+interface ConfirmationResult {
+    confirmed: boolean;
+    data?: unknown;
+}
+interface JobHandle {
+    job_id: string;
+    set_status: (status: JobStatus) => void;
+    set_progress: (current: number, total: number) => void;
+    request_confirmation: <T = unknown>(payload: T) => Promise<ConfirmationResult>;
+    is_cancelled: () => boolean;
+}
+interface PipelineStep {
+    name: string;
+    execute: (context: PipelineContext, handle: JobHandle) => Promise<void>;
+}
+interface CreateBatchOptions {
+    files: File[];
+    group_id: string;
+    group_label?: string;
+    metadata?: Record<string, unknown>;
+    pipeline_steps?: PipelineStep[];
+}
+interface JobSnapshot {
+    job_id: string;
+    batch_id: string;
+    status: JobStatus;
+    group_id: string;
+    group_label?: string;
+    files: UploadFile[];
+    progress: {
+        current: number;
+        total: number;
+    } | null;
+    extracted_data: Record<string, unknown>;
+    error: string | null;
+    metadata: Record<string, unknown>;
+    confirmation_payload: unknown | null;
+    created_at: number;
+    updated_at: number;
+}
+interface BatchInfo {
+    batch_id: string;
+    job_ids: string[];
+    total: number;
+    completed: number;
+    failed: number;
+}
+interface UploadManagerEvents {
+    'job:created': {
+        job: JobSnapshot;
+    };
+    'job:status_changed': {
+        job: JobSnapshot;
+        previous_status: JobStatus;
+    };
+    'job:progress': {
+        job: JobSnapshot;
+    };
+    'job:completed': {
+        job: JobSnapshot;
+    };
+    'job:error': {
+        job: JobSnapshot;
+        error: string;
+    };
+    'job:confirmation_needed': {
+        job: JobSnapshot;
+        payload: unknown;
+    };
+    'job:confirmation_resolved': {
+        job: JobSnapshot;
+        result: ConfirmationResult;
+    };
+    'batch:progress': {
+        batch: BatchInfo;
+    };
+    'batch:completed': {
+        batch: BatchInfo;
+    };
+}
+interface UploadManagerConfig {
+    max_concurrent?: number;
+    default_pipeline_steps?: PipelineStep[];
+}
+
+type Listener<T> = (data: T) => void;
+declare class TypedEventEmitter<TEvents extends Record<string, any>> {
+    private listeners;
+    on<K extends keyof TEvents>(event: K, listener: Listener<TEvents[K]>): () => void;
+    emit<K extends keyof TEvents>(event: K, data: TEvents[K]): void;
+    off<K extends keyof TEvents>(event: K, listener: Listener<TEvents[K]>): void;
+    removeAllListeners(): void;
+}
+
+interface JobInit {
+    batch_id: string;
+    files: File[];
+    group_id: string;
+    group_label?: string;
+    pipeline_steps: PipelineStep[];
+    metadata?: Record<string, unknown>;
+}
+declare class Job {
+    readonly job_id: string;
+    readonly batch_id: string;
+    readonly created_at: number;
+    private status;
+    private progress;
+    private error;
+    private confirmation_payload;
+    private confirmation_resolve;
+    private context;
+    private readonly pipeline_steps;
+    private updated_at;
+    constructor(init: JobInit);
+    get_snapshot(): JobSnapshot;
+    set_status(status: JobStatus): void;
+    set_progress(current: number, total: number): void;
+    set_error(message: string): void;
+    request_confirmation<T>(payload: T): Promise<ConfirmationResult>;
+    resolve_confirmation(result: ConfirmationResult): void;
+    get_context(): PipelineContext;
+    get_pipeline_steps(): PipelineStep[];
+}
+
+declare class PipelineExecutor {
+    execute(job: Job, emitter: TypedEventEmitter<UploadManagerEvents>): Promise<void>;
+}
+
+declare class UploadManager {
+    private jobs;
+    private batches;
+    private executor;
+    private emitter;
+    private queue;
+    private running;
+    private destroyed;
+    private readonly config;
+    constructor(config?: UploadManagerConfig);
+    on<K extends keyof UploadManagerEvents>(event: K, listener: (data: UploadManagerEvents[K]) => void): () => void;
+    submit_batch(options: CreateBatchOptions): string;
+    get_jobs_for_group(group_id: string): JobSnapshot[];
+    get_job(job_id: string): JobSnapshot | null;
+    get_active_jobs(): JobSnapshot[];
+    resolve_confirmation(job_id: string, result: ConfirmationResult): void;
+    destroy(): void;
+    private process_queue;
+    private on_job_settled;
+}
+
+export { type BatchInfo, type ConfirmationResult, type CreateBatchOptions, Job, type JobHandle, type JobSnapshot, type JobStatus, type PipelineContext, PipelineExecutor, type PipelineStep, TypedEventEmitter, type UploadFile, UploadManager, type UploadManagerConfig, type UploadManagerEvents };

package/dist/background-upload/index.js

@@ -0,0 +1,301 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/background_upload/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Job: () => Job,
+  PipelineExecutor: () => PipelineExecutor,
+  TypedEventEmitter: () => TypedEventEmitter,
+  UploadManager: () => UploadManager
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/background_upload/core/event-emitter.ts
+var TypedEventEmitter = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Map();
+  }
+  on(event, listener) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(event, set);
+    }
+    set.add(listener);
+    return () => this.off(event, listener);
+  }
+  emit(event, data) {
+    const set = this.listeners.get(event);
+    if (!set) return;
+    for (const listener of set) {
+      listener(data);
+    }
+  }
+  off(event, listener) {
+    this.listeners.get(event)?.delete(listener);
+  }
+  removeAllListeners() {
+    this.listeners.clear();
+  }
+};
+
+// src/background_upload/core/job.ts
+var Job = class {
+  constructor(init) {
+    this.status = "queued";
+    this.progress = null;
+    this.error = null;
+    this.confirmation_payload = null;
+    this.confirmation_resolve = null;
+    this.job_id = crypto.randomUUID();
+    this.batch_id = init.batch_id;
+    this.created_at = Date.now();
+    this.updated_at = this.created_at;
+    this.pipeline_steps = init.pipeline_steps;
+    this.context = {
+      files: init.files.map((f) => ({
+        file: f,
+        file_name: f.name,
+        mime_type: f.type
+      })),
+      group_id: init.group_id,
+      group_label: init.group_label,
+      extracted_data: {},
+      metadata: { ...init.metadata ?? {} }
+    };
+  }
+  get_snapshot() {
+    return {
+      job_id: this.job_id,
+      batch_id: this.batch_id,
+      status: this.status,
+      group_id: this.context.group_id,
+      group_label: this.context.group_label,
+      files: [...this.context.files],
+      progress: this.progress ? { ...this.progress } : null,
+      extracted_data: { ...this.context.extracted_data },
+      error: this.error,
+      metadata: { ...this.context.metadata },
+      confirmation_payload: this.confirmation_payload,
+      created_at: this.created_at,
+      updated_at: this.updated_at
+    };
+  }
+  set_status(status) {
+    this.status = status;
+    this.updated_at = Date.now();
+  }
+  set_progress(current, total) {
+    this.progress = { current, total };
+    this.updated_at = Date.now();
+  }
+  set_error(message) {
+    this.error = message;
+    this.updated_at = Date.now();
+  }
+  request_confirmation(payload) {
+    this.confirmation_payload = payload;
+    this.set_status("awaiting_confirmation");
+    return new Promise((resolve) => {
+      this.confirmation_resolve = resolve;
+    });
+  }
+  resolve_confirmation(result) {
+    if (this.confirmation_resolve) {
+      this.confirmation_resolve(result);
+      this.confirmation_resolve = null;
+      this.confirmation_payload = null;
+      this.updated_at = Date.now();
+    }
+  }
+  get_context() {
+    return this.context;
+  }
+  get_pipeline_steps() {
+    return this.pipeline_steps;
+  }
+};
+
+// src/background_upload/core/pipeline-executor.ts
+var PipelineExecutor = class {
+  async execute(job, emitter) {
+    const steps = job.get_pipeline_steps();
+    const context = job.get_context();
+    const handle = {
+      job_id: job.job_id,
+      set_status: (status) => {
+        const previous_status = job.get_snapshot().status;
+        job.set_status(status);
+        emitter.emit("job:status_changed", { job: job.get_snapshot(), previous_status });
+      },
+      set_progress: (current, total) => {
+        job.set_progress(current, total);
+        emitter.emit("job:progress", { job: job.get_snapshot() });
+      },
+      request_confirmation: async (payload) => {
+        const previous_status = job.get_snapshot().status;
+        const result_promise = job.request_confirmation(payload);
+        emitter.emit("job:confirmation_needed", { job: job.get_snapshot(), payload });
+        emitter.emit("job:status_changed", { job: job.get_snapshot(), previous_status });
+        const result = await result_promise;
+        emitter.emit("job:confirmation_resolved", { job: job.get_snapshot(), result });
+        return result;
+      },
+      is_cancelled: () => job.get_snapshot().status === "error"
+    };
+    try {
+      for (const step of steps) {
+        if (handle.is_cancelled()) break;
+        await step.execute(context, handle);
+      }
+      if (!handle.is_cancelled()) {
+        const previous_status = job.get_snapshot().status;
+        job.set_status("done");
+        emitter.emit("job:status_changed", { job: job.get_snapshot(), previous_status });
+        emitter.emit("job:completed", { job: job.get_snapshot() });
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const previous_status = job.get_snapshot().status;
+      job.set_error(message);
+      job.set_status("error");
+      emitter.emit("job:status_changed", { job: job.get_snapshot(), previous_status });
+      emitter.emit("job:error", { job: job.get_snapshot(), error: message });
+    }
+  }
+};
+
+// src/background_upload/core/upload-manager.ts
+var UploadManager = class {
+  constructor(config) {
+    this.jobs = /* @__PURE__ */ new Map();
+    this.batches = /* @__PURE__ */ new Map();
+    this.executor = new PipelineExecutor();
+    this.emitter = new TypedEventEmitter();
+    this.queue = [];
+    this.running = 0;
+    this.destroyed = false;
+    this.config = {
+      max_concurrent: config?.max_concurrent ?? 1,
+      default_pipeline_steps: config?.default_pipeline_steps ?? []
+    };
+    this.emitter.on("job:completed", ({ job }) => this.on_job_settled(job));
+    this.emitter.on("job:error", ({ job }) => this.on_job_settled(job));
+  }
+  on(event, listener) {
+    return this.emitter.on(event, listener);
+  }
+  submit_batch(options) {
+    if (this.destroyed) throw new Error("UploadManager is destroyed");
+    const batch_id = crypto.randomUUID();
+    const job_ids = [];
+    const pipeline_steps = options.pipeline_steps ?? this.config.default_pipeline_steps;
+    for (const file of options.files) {
+      const job = new Job({
+        batch_id,
+        files: [file],
+        group_id: options.group_id,
+        group_label: options.group_label,
+        pipeline_steps,
+        metadata: options.metadata
+      });
+      this.jobs.set(job.job_id, job);
+      job_ids.push(job.job_id);
+      this.emitter.emit("job:created", { job: job.get_snapshot() });
+      this.queue.push(job.job_id);
+    }
+    this.batches.set(batch_id, {
+      batch_id,
+      job_ids,
+      total: options.files.length,
+      completed: 0,
+      failed: 0,
+      emitted_complete: false
+    });
+    this.process_queue();
+    return batch_id;
+  }
+  get_jobs_for_group(group_id) {
+    const out = [];
+    for (const job of this.jobs.values()) {
+      const snap = job.get_snapshot();
+      if (snap.group_id === group_id) out.push(snap);
+    }
+    return out;
+  }
+  get_job(job_id) {
+    return this.jobs.get(job_id)?.get_snapshot() ?? null;
+  }
+  get_active_jobs() {
+    const out = [];
+    for (const job of this.jobs.values()) {
+      const snap = job.get_snapshot();
+      if (snap.status !== "done" && snap.status !== "error") out.push(snap);
+    }
+    return out;
+  }
+  resolve_confirmation(job_id, result) {
+    const job = this.jobs.get(job_id);
+    if (job) job.resolve_confirmation(result);
+  }
+  destroy() {
+    this.destroyed = true;
+    this.emitter.removeAllListeners();
+    this.jobs.clear();
+    this.batches.clear();
+    this.queue = [];
+  }
+  process_queue() {
+    while (!this.destroyed && this.queue.length > 0 && this.running < this.config.max_concurrent) {
+      const job_id = this.queue.shift();
+      const job = this.jobs.get(job_id);
+      if (!job) continue;
+      this.running++;
+      void this.executor.execute(job, this.emitter).finally(() => {
+        this.running--;
+        this.process_queue();
+      });
+    }
+  }
+  on_job_settled(job) {
+    const batch = this.batches.get(job.batch_id);
+    if (!batch) return;
+    let completed = 0, failed = 0;
+    for (const jid of batch.job_ids) {
+      const s = this.jobs.get(jid)?.get_snapshot().status;
+      if (s === "done") completed++;
+      else if (s === "error") failed++;
+    }
+    batch.completed = completed;
+    batch.failed = failed;
+    this.emitter.emit("batch:progress", { batch: { ...batch } });
+    if (!batch.emitted_complete && completed + failed === batch.total) {
+      batch.emitted_complete = true;
+      this.emitter.emit("batch:completed", { batch: { ...batch } });
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Job,
+  PipelineExecutor,
+  TypedEventEmitter,
+  UploadManager
+});