@oddkin/ai 0.0.0-stage → 1.0.0-beta.0

package/dist/prod/controllers/composer.js

@@ -0,0 +1,235 @@
+import { signal } from "@oddkin/core/reactive";
+import { createId } from "../internal/ids.js";
+const BUSY = /* @__PURE__ */ new Set(["uploading", "processing"]);
+function matchesAccept(file, accept) {
+  if (!accept.length)
+    return !0;
+  const name = file.name.toLowerCase(), type = file.type.toLowerCase();
+  return accept.some((raw) => {
+    const pattern = raw.trim().toLowerCase();
+    return pattern ? pattern.startsWith(".") ? name.endsWith(pattern) : pattern.endsWith("/*") ? type.startsWith(pattern.slice(0, -1)) : type === pattern : !1;
+  });
+}
+class ComposerController {
+  #state;
+  state;
+  #files = /* @__PURE__ */ new Map();
+  #ownedUrls = /* @__PURE__ */ new Set();
+  #options;
+  #disposed = !1;
+  constructor(options = {}) {
+    this.#options = options, this.#state = signal({ text: "", revision: 0, attachments: [], issues: [] }), this.state = this.#state;
+  }
+  getSnapshot() {
+    return this.#state.peek();
+  }
+  configure(options) {
+    this.#options = { ...this.#options, ...options };
+  }
+  /** Replace the draft text (user edit or host restore). Increments the draft revision. */
+  setText(text) {
+    const now = this.#state.peek();
+    now.text !== text && this.#set({ ...now, text, revision: now.revision + 1 });
+  }
+  /** Validate and add files. Rejected files are reported in `issues` and never added. */
+  addFiles(files) {
+    const now = this.#state.peek(), issues = [], added = [];
+    if (this.#options.attachments === !1) {
+      for (const file of files)
+        issues.push({ code: "ai.attachment.unavailable", name: file.name });
+      return this.#set({ ...now, issues }), added;
+    }
+    const max = this.#options.maxFiles ?? 1 / 0;
+    let count = now.attachments.length;
+    for (const file of files) {
+      if (!matchesAccept(file, this.#options.accept ?? [])) {
+        issues.push({
+          code: "ai.attachment.type",
+          name: file.name,
+          limit: (this.#options.accept ?? []).join(", ")
+        });
+        continue;
+      }
+      if (this.#options.maxFileSize !== void 0 && file.size > this.#options.maxFileSize) {
+        issues.push({
+          code: "ai.attachment.size",
+          name: file.name,
+          limit: this.#options.maxFileSize
+        });
+        continue;
+      }
+      if (count >= max) {
+        issues.push({ code: "ai.attachment.count", name: file.name, limit: max });
+        continue;
+      }
+      count++;
+      const id = (this.#options.createId ?? createId)("attachment");
+      this.#files.set(id, file);
+      const previewUrl = this.#preview(file);
+      added.push({
+        id,
+        name: file.name,
+        size: file.size,
+        mediaType: file.type || "application/octet-stream",
+        status: "selected",
+        ...previewUrl ? { previewUrl } : {}
+      });
+    }
+    return this.#set({
+      ...now,
+      attachments: [...now.attachments, ...added],
+      revision: added.length ? now.revision + 1 : now.revision,
+      issues
+    }), added;
+  }
+  /** The runtime File for an attachment (never part of serializable state). */
+  file(id) {
+    return this.#files.get(id);
+  }
+  /** Host-reported upload or processing progress. Ignored for removed attachments. */
+  updateAttachment(id, update) {
+    const now = this.#state.peek();
+    now.attachments.some((a) => a.id === id) && this.#set({
+      ...now,
+      attachments: now.attachments.map((a) => a.id === id ? { ...a, ...update } : a)
+    });
+  }
+  removeAttachment(id) {
+    const now = this.#state.peek(), attachment = now.attachments.find((a) => a.id === id);
+    attachment && (this.#release(attachment), this.#set({
+      ...now,
+      attachments: now.attachments.filter((a) => a.id !== id),
+      revision: now.revision + 1,
+      issues: []
+    }));
+  }
+  clearIssues() {
+    const now = this.#state.peek();
+    now.issues.length && this.#set({ ...now, issues: [] });
+  }
+  /** Why the draft cannot be submitted now, or undefined when it can. */
+  blocker() {
+    const now = this.#state.peek();
+    if (now.submission?.status === "submitting")
+      return "submitting";
+    if (now.attachments.some((a) => BUSY.has(a.status)))
+      return "attachments-busy";
+    if (now.attachments.some((a) => a.status === "failed"))
+      return "attachments-failed";
+    if (!now.text.trim() && !now.attachments.length)
+      return "empty";
+  }
+  /**
+   * Capture the draft as a submission. The draft stays in place (and editable) until the host
+   * acknowledges acceptance; a failure leaves it untouched.
+   */
+  beginSubmit() {
+    if (this.blocker())
+      return;
+    const now = this.#state.peek(), submission = {
+      submissionId: (this.#options.createId ?? createId)("submission"),
+      revision: now.revision,
+      text: now.text,
+      attachments: now.attachments
+    };
+    return this.#set({
+      ...now,
+      submission: {
+        submissionId: submission.submissionId,
+        revision: now.revision,
+        status: "submitting"
+      }
+    }), submission;
+  }
+  /**
+   * The host accepted `submissionId`. Clears the submitted text only if the draft was not
+   * edited since; attachments added after submission stay. Stale ids are ignored.
+   */
+  acknowledge(submissionId) {
+    const now = this.#state.peek();
+    if (now.submission?.submissionId !== submissionId)
+      return !1;
+    const submittedRevision = now.submission.revision, edited = now.revision !== submittedRevision, submittedIds = this.#submittedIds.get(submissionId), remaining = edited ? now.attachments.filter((a) => !submittedIds?.has(a.id)) : [];
+    for (const attachment of now.attachments)
+      remaining.includes(attachment) || this.#release(attachment);
+    return this.#submittedIds.delete(submissionId), this.#set({
+      text: edited ? now.text : "",
+      revision: now.revision + 1,
+      attachments: remaining,
+      submission: void 0,
+      issues: []
+    }), !0;
+  }
+  #submittedIds = /* @__PURE__ */ new Map();
+  /** The host rejected `submissionId`. The draft and attachments are preserved. */
+  fail(submissionId, error) {
+    const now = this.#state.peek();
+    return now.submission?.submissionId !== submissionId ? !1 : (this.#set({
+      ...now,
+      submission: { submissionId, revision: now.submission.revision, status: "failed", error }
+    }), !0);
+  }
+  /** Abandon the pending submission locally (e.g. the host cancelled it before acceptance). */
+  cancel(submissionId) {
+    const now = this.#state.peek();
+    return now.submission?.submissionId !== submissionId ? !1 : (this.#set({ ...now, submission: void 0 }), !0);
+  }
+  /** Revoke owned preview URLs and drop File references. */
+  dispose() {
+    if (!this.#disposed) {
+      this.#disposed = !0;
+      for (const url of this.#ownedUrls)
+        URL.revokeObjectURL(url);
+      this.#ownedUrls.clear(), this.#files.clear();
+    }
+  }
+  /** Number of object URLs this controller currently owns (for leak tests). */
+  get ownedUrlCount() {
+    return this.#ownedUrls.size;
+  }
+  /** Revoke owned preview URLs (e.g. while a view is disconnected); the files are kept. */
+  releasePreviews() {
+    const now = this.#state.peek();
+    now.attachments.some((a) => a.previewUrl && this.#ownedUrls.has(a.previewUrl)) && this.#set({
+      ...now,
+      attachments: now.attachments.map((a) => {
+        if (!a.previewUrl || !this.#ownedUrls.delete(a.previewUrl))
+          return a;
+        URL.revokeObjectURL(a.previewUrl);
+        const { previewUrl: _released, ...rest } = a;
+        return rest;
+      })
+    });
+  }
+  /** Recreate previews released by `releasePreviews`. */
+  restorePreviews() {
+    if (this.#disposed)
+      return;
+    const now = this.#state.peek();
+    let changed = !1;
+    const attachments = now.attachments.map((a) => {
+      const file = this.#files.get(a.id);
+      if (a.previewUrl || !file)
+        return a;
+      const previewUrl = this.#preview(file);
+      return previewUrl ? (changed = !0, { ...a, previewUrl }) : a;
+    });
+    changed && this.#set({ ...now, attachments });
+  }
+  #preview(file) {
+    if (this.#options.previews === !1 || !file.type.startsWith("image/") || typeof URL > "u" || typeof URL.createObjectURL != "function")
+      return;
+    const url = URL.createObjectURL(file);
+    return this.#ownedUrls.add(url), url;
+  }
+  #release(attachment) {
+    this.#files.delete(attachment.id), attachment.previewUrl && this.#ownedUrls.delete(attachment.previewUrl) && URL.revokeObjectURL(attachment.previewUrl);
+  }
+  #set(next) {
+    next.submission?.status === "submitting" && !this.#submittedIds.has(next.submission.submissionId) && this.#submittedIds.set(next.submission.submissionId, new Set(next.attachments.map((a) => a.id))), this.#state.value = next;
+  }
+}
+export {
+  ComposerController,
+  matchesAccept
+};