@wix/himalaya-cli 0.1029.0 → 0.1031.0

package/templates/gym-fitness-owner/tier5-src/_shared/aria-attachments.ts

@@ -0,0 +1,179 @@
+// Photo attachments for the Aria composer — the pure half.
+//
+// Everything here is a decision that can be made without touching the device
+// or the network: which files may be attached, how many, how large, what a chip
+// in the composer says in each of its three states, and how a picked image is
+// turned into the bytes an upload sends. The half that DOES touch the world —
+// minting the upload, sending the bytes, picking — lives in `aria-chat.ts`
+// (the mint, through `@himalaya/wix-genie-chat`) and in each app's adapter (the
+// picker and the byte transfer, which are device capabilities the adapter's
+// screen has to declare).
+//
+// This file is copied verbatim into every generated starter app, so it explains
+// itself without pointing at anything only this repo has.
+
+/** Image types the composer accepts. The first-party clients' own allowlist
+ *  for images: png, jpeg (and the non-standard `image/jpg` some pickers still
+ *  report), webp, gif and heic. Anything else is REFUSED with a line saying so,
+ *  never silently dropped — the native Aria app drops unsupported files without a
+ *  word, and an owner who picked something and sees nothing happen assumes the
+ *  button is broken. */
+export const ARIA_IMAGE_TYPES: readonly string[] = [
+  "image/png",
+  "image/jpeg",
+  "image/jpg",
+  "image/webp",
+  "image/gif",
+  "image/heic",
+];
+
+/** At most this many attachments ride one message. The native Aria app caps at
+ *  10; nothing on the wire says otherwise. */
+export const ARIA_MAX_ATTACHMENTS = 10;
+
+/** The largest image the composer will try to send, in bytes.
+ *
+ *  Not a product choice: it is the ceiling of the transfer this slice uses. A
+ *  picked photo crosses the worker bridge as a base64 string and is sent inline,
+ *  and the inline upload refuses anything over 8 MiB (the `MAX_INLINE_BASE64_BYTES`
+ *  bound of the pre-signed upload capability, which it enforces on every arm).
+ *  Checking it HERE is what turns that refusal into a sentence the owner can act
+ *  on, instead of a chip that fails for no stated reason. */
+export const ARIA_MAX_IMAGE_BYTES = 8 * 1024 * 1024;
+
+/** A chip in the composer. Every field is always present — a `$item.` path that
+ *  is missing on some rows does not substitute — and each `…Hidden` flag
+ *  collapses the part it names. */
+export interface AriaAttachmentChip {
+  /** Minted by the worker, never derived from the file. The native Aria app keyed
+   *  concurrent uploads by file NAME and collided on the second `IMG_0001.jpg`. */
+  id: string;
+  name: string;
+  mimeType: string;
+  state: "uploading" | "ready" | "failed";
+  /** The chip's thumbnail as a `data:` URI, set only when the picked image is
+   *  small; "" otherwise, which collapses the preview. The full bytes an upload
+   *  and a retry send are held by the worker, never in the chip, because the chip
+   *  rides the service state and a large photo there would exceed the web
+   *  runtime's frame limit. */
+  thumbUrl: string;
+  thumbHidden: boolean;
+  /** "Uploading…" / "Couldn't upload" / "" — collapses when empty. */
+  statusText: string;
+  statusHidden: boolean;
+  /** The retry control shows ONLY on a failed chip. */
+  retryHidden: boolean;
+  /** `genie-upload://<id>` once the bytes have landed; "" until then. The send
+   *  carries a chip only when this is set. */
+  ref: string;
+}
+
+/** What an upload reports back, delivered as a fresh action so it lands on the
+ *  CURRENT state rather than on the snapshot the upload started from. */
+export interface AriaAttachmentOutcome {
+  id: string;
+  ok: boolean;
+  /** Set when `ok`. */
+  ref?: string;
+}
+
+export interface ParsedDataUri { mimeType: string; base64: string; bytes: number }
+
+/** `data:<mime>;base64,<payload>` → its parts, or null for anything else.
+ *
+ *  Only the base64 form: every picker this composer is wired to returns it, and
+ *  a percent-encoded `data:` URI would need decoding the bridge cannot do. The
+ *  byte count is computed from the payload length, so a multi-megabyte photo is
+ *  sized without being decoded. */
+export function parseDataUri(uri: string): ParsedDataUri | null {
+  const m = /^data:([^;,]*)((?:;[^;,]*)*?);base64,/i.exec(uri ?? "");
+  if (!m) return null;
+  const base64 = uri.slice(m[0].length).replace(/\s+/g, "");
+  const pad = base64.endsWith("==") ? 2 : base64.endsWith("=") ? 1 : 0;
+  const bytes = Math.max(0, Math.floor((base64.length * 3) / 4) - pad);
+  return { mimeType: (m[1] || "").trim().toLowerCase(), base64, bytes };
+}
+
+/** Normalize a MIME type a picker reported.
+ *
+ *  Some pickers hand back a platform type identifier where a MIME type belongs
+ *  (`public.jpeg`, `public.heic`), and the service validates the field as a MIME
+ *  type. Mapped for the image identifiers this composer accepts; anything else
+ *  is returned lowercased and left for the allowlist to judge. */
+export function normalizeMime(mime: string): string {
+  const v = (mime ?? "").trim().toLowerCase();
+  switch (v) {
+    case "public.jpeg": return "image/jpeg";
+    case "public.png": return "image/png";
+    case "public.heic": return "image/heic";
+    case "com.compuserve.gif": return "image/gif";
+    case "org.webmproject.webp": return "image/webp";
+    case "image/jpg": return "image/jpeg";
+    default: return v;
+  }
+}
+
+/** A file name for an image the picker did not name, by type. The service
+ *  requires one (1–255 characters), and it is what the transcript shows. */
+export function imageFileName(mimeType: string, n: number, given?: string): string {
+  const name = (given ?? "").trim();
+  if (name) return name.slice(0, 255);
+  const ext = mimeType === "image/png" ? "png"
+    : mimeType === "image/webp" ? "webp"
+    : mimeType === "image/gif" ? "gif"
+    : mimeType === "image/heic" ? "heic"
+    : "jpg";
+  return `photo-${n}.${ext}`;
+}
+
+/** Why a picked file cannot be attached, or "" when it can. */
+export type AttachRefusal = "" | "type" | "size" | "count";
+
+export function refusalFor(parsed: ParsedDataUri | null, mimeType: string, attached: number): AttachRefusal {
+  if (attached >= ARIA_MAX_ATTACHMENTS) return "count";
+  if (!parsed || !ARIA_IMAGE_TYPES.includes(mimeType)) return "type";
+  if (parsed.bytes > ARIA_MAX_IMAGE_BYTES) return "size";
+  return "";
+}
+
+/** A chip in a given state. One constructor so the flags can never disagree
+ *  with the state they describe — a failed chip without its retry control is
+ *  the shape of bug this rules out. */
+export function chipIn(
+  base: Pick<AriaAttachmentChip, "id" | "name" | "mimeType" | "thumbUrl">,
+  state: AriaAttachmentChip["state"],
+  labels: { uploading: string; failed: string },
+  ref = "",
+): AriaAttachmentChip {
+  const statusText = state === "uploading" ? labels.uploading : state === "failed" ? labels.failed : "";
+  return {
+    ...base,
+    state,
+    thumbHidden: !base.thumbUrl,
+    statusText,
+    statusHidden: !statusText,
+    retryHidden: state !== "failed",
+    ref: state === "ready" ? ref : "",
+  };
+}
+
+/** Why Send is refused while attachments are pending, or "" when it is not.
+ *
+ *  An upload still running would be dropped from the message, and a failed one
+ *  would be sent as if the owner had never picked it — in both cases the
+ *  assistant answers about a photo it never received. So the send waits, and
+ *  says what it is waiting for. */
+export function sendBlocker(chips: readonly AriaAttachmentChip[]): "" | "uploading" | "failed" {
+  if (chips.some((c) => c.state === "uploading")) return "uploading";
+  if (chips.some((c) => c.state === "failed")) return "failed";
+  return "";
+}
+
+/** The one line a bubble shows for its attachments: a paperclip and the file
+ *  names. Text, not thumbnails, and not by choice: a `genie-upload://`
+ *  reference has no published download url, so a sent photo cannot be shown
+ *  again from the server's copy — and a resumed conversation has nothing else. */
+export function attachmentLine(names: readonly string[]): string {
+  const shown = names.map((n) => n.trim()).filter(Boolean);
+  return shown.length ? `📎 ${shown.join(", ")}` : "";
+}