hazo_files 1.4.7 → 1.5.2

package/dist/background-upload/react/index.js

@@ -0,0 +1,474 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/background_upload/react/index.ts
+var index_exports = {};
+__export(index_exports, {
+  FileUploadContext: () => FileUploadContext,
+  HazoFileUploadProvider: () => HazoFileUploadProvider,
+  useFileUpload: () => useFileUpload,
+  useFileUploadToasts: () => useFileUploadToasts,
+  useJobStatus: () => useJobStatus
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/background_upload/react/provider.tsx
+var import_react3 = require("react");
+
+// 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/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/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 } });
+    }
+  }
+};
+
+// src/background_upload/react/context.ts
+var import_react = require("react");
+var FileUploadContext = (0, import_react.createContext)(null);
+
+// src/background_upload/react/use-file-upload-toasts.ts
+var import_react2 = require("react");
+var toast_promise = null;
+function get_toast() {
+  if (!toast_promise) {
+    toast_promise = import("sonner").then((mod) => mod.toast).catch(() => null);
+  }
+  return toast_promise;
+}
+function useFileUploadToasts(manager) {
+  (0, import_react2.useEffect)(() => {
+    const unsubs = [];
+    unsubs.push(manager.on("job:completed", ({ job }) => {
+      void get_toast().then((t) => {
+        if (!t) return;
+        const label = job.group_label || job.group_id;
+        const n = job.files.length;
+        t.success(`${n} file${n > 1 ? "s" : ""} processed for ${label}`);
+      });
+    }));
+    unsubs.push(manager.on("job:error", ({ job, error }) => {
+      void get_toast().then((t) => {
+        if (!t) return;
+        const label = job.group_label || job.group_id;
+        t.error(`Upload failed for ${label}: ${error}`);
+      });
+    }));
+    unsubs.push(manager.on("job:confirmation_needed", ({ job }) => {
+      void get_toast().then((t) => {
+        if (!t) return;
+        const label = job.group_label || job.group_id;
+        t.info(`Action required for ${label}`, {
+          description: "Review and confirm data conflicts",
+          duration: 1e4
+        });
+      });
+    }));
+    unsubs.push(manager.on("batch:completed", ({ batch }) => {
+      void get_toast().then((t) => {
+        if (!t) return;
+        if (batch.failed > 0) {
+          t.warning(`Batch complete: ${batch.completed}/${batch.total} succeeded`);
+        }
+      });
+    }));
+    return () => unsubs.forEach((u) => u());
+  }, [manager]);
+}
+
+// src/background_upload/react/toast-bridge.tsx
+function ToastBridge({ manager }) {
+  useFileUploadToasts(manager);
+  return null;
+}
+
+// src/background_upload/react/provider.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+function HazoFileUploadProvider({
+  children,
+  config,
+  enable_toasts = true
+}) {
+  const manager_ref = (0, import_react3.useRef)(null);
+  if (!manager_ref.current) {
+    manager_ref.current = new UploadManager(config);
+  }
+  (0, import_react3.useEffect)(() => {
+    const m = manager_ref.current;
+    return () => {
+      m.destroy();
+    };
+  }, []);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(FileUploadContext.Provider, { value: manager_ref.current, children: [
+    enable_toasts && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ToastBridge, { manager: manager_ref.current }),
+    children
+  ] });
+}
+
+// src/background_upload/react/use-file-upload.ts
+var import_react4 = require("react");
+var EMPTY_ACTIVE_JOBS = Object.freeze([]);
+function useFileUpload() {
+  const manager = (0, import_react4.useContext)(FileUploadContext);
+  if (!manager) {
+    throw new Error("useFileUpload must be used within HazoFileUploadProvider");
+  }
+  const snapshot_ref = (0, import_react4.useRef)([]);
+  const active_jobs = (0, import_react4.useSyncExternalStore)(
+    (callback) => {
+      const unsubs = [
+        manager.on("job:created", callback),
+        manager.on("job:status_changed", callback),
+        manager.on("job:progress", callback),
+        manager.on("job:completed", callback),
+        manager.on("job:error", callback)
+      ];
+      return () => unsubs.forEach((u) => u());
+    },
+    () => {
+      const next = manager.get_active_jobs();
+      const prev = snapshot_ref.current;
+      if (prev.length === next.length && next.every((j, i) => j.job_id === prev[i]?.job_id && j.updated_at === prev[i]?.updated_at)) {
+        return prev;
+      }
+      snapshot_ref.current = next;
+      return next;
+    },
+    () => EMPTY_ACTIVE_JOBS
+  );
+  const submit_batch = (0, import_react4.useCallback)(
+    (options) => manager.submit_batch(options),
+    [manager]
+  );
+  const get_job = (0, import_react4.useCallback)((id) => manager.get_job(id), [manager]);
+  const get_jobs_for_group = (0, import_react4.useCallback)(
+    (id) => manager.get_jobs_for_group(id),
+    [manager]
+  );
+  const resolve_confirmation = (0, import_react4.useCallback)(
+    (id, r) => manager.resolve_confirmation(id, r),
+    [manager]
+  );
+  return { manager, active_jobs, submit_batch, get_job, get_jobs_for_group, resolve_confirmation };
+}
+
+// src/background_upload/react/use-job-status.ts
+var import_react5 = require("react");
+function useJobStatus(job_id) {
+  const manager = (0, import_react5.useContext)(FileUploadContext);
+  return (0, import_react5.useSyncExternalStore)(
+    (callback) => {
+      if (!manager || !job_id) return () => {
+      };
+      const unsubs = [
+        manager.on("job:status_changed", ({ job }) => {
+          if (job.job_id === job_id) callback();
+        }),
+        manager.on("job:progress", ({ job }) => {
+          if (job.job_id === job_id) callback();
+        }),
+        manager.on("job:completed", ({ job }) => {
+          if (job.job_id === job_id) callback();
+        }),
+        manager.on("job:error", ({ job }) => {
+          if (job.job_id === job_id) callback();
+        })
+      ];
+      return () => unsubs.forEach((u) => u());
+    },
+    () => manager && job_id ? manager.get_job(job_id) : null,
+    () => null
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FileUploadContext,
+  HazoFileUploadProvider,
+  useFileUpload,
+  useFileUploadToasts,
+  useJobStatus
+});