@innspel/core 0.1.1 → 0.2.0

package/README.md

@@ -83,12 +83,13 @@ Bruk hva du vil — MMKV, AsyncStorage, SQLite, et objekt i minnet.
 ## API
 
 ```ts
-innspel.capture({ type, text, context?, correlation?, relatedKnownIssueId?, clientRef? })
+innspel.capture({ type, text, attachment?, context?, correlation?, relatedKnownIssueId?, clientRef? })
 innspel.knownIssues.for({ screen?, version?, platform? })   // kortene som vises FØR feltet
 innspel.knownIssues.confirm(id)                             // «Ja, jeg også» — Reach +1, ingen ny sak
 innspel.subjects.submissions()                              // «Mine innspill», inkl. det som venter på nett
 innspel.subjects.status(submissionId)                       // status for én egen innsending
 innspel.programs.list()                                     // invitasjoner, deltakelser, oppfølginger
+innspel.attachments.upload(submissionId, attachment)        // skjermbilde til en innsending som alt er lagret
 innspel.queue.pending()                                     // det som ligger i offline-køen
 innspel.queue.flush()                                       // sendes ellers automatisk
 innspel.scanText(text)                                      // mønstervarsel, se under
@@ -109,6 +110,36 @@ er utløpt for lengst.
 Vis køen for brukeren. `queue.pending()` gir deg radene, og «Venter på nett —
 sendes automatisk» er teksten widgeten bruker.
 
+### Vedlegg
+
+Ett skjermbilde per innsending, **maskert på klienten før det forlater enheten**
+(K4). Kjernen har ingen fangst og ingen maskering selv — `@innspel/react-native`
+har begge; her tar du imot bildet som Blob, ArrayBuffer eller Uint8Array:
+
+```ts
+const res = await innspel.capture({
+  type: 'feil',
+  text: 'Dørlista er tom etter kl. 22.',
+  attachment: { mime: 'image/jpeg', body: blob, width: 1170, height: 2532 },
+});
+
+if (res.status === 'sent' && res.attachment?.status === 'failed') {
+  // Teksten ER lagret. Si «Sendt — skjermbildet kunne ikke legges ved» (DD-42).
+}
+```
+
+Teksten sendes først, bildet etterpå i egen forespørsel direkte til lagringen, og
+bildet kan feile alene — innsendingen står uansett. Uten nett køes teksten og
+bildet forkastes (`attachment.status === 'dropped'`); et skjermbilde køes aldri.
+
+Grensene sjekkes før noe går på nettet og kaster med feltnavn: PNG, JPEG eller
+WebP (aldri SVG eller GIF), høyst 5 MB og 4096 × 4096 (K9). Plattformen sjekker
+dem igjen, re-enkoder bildet i en isolert prosess og fjerner EXIF.
+
+Geometrien bak maskeringen — fingerstrøk og trykk til rektangler i bildets
+piksler — ligger her (`strokTilRekter`, `trykkTilRekt`, `skaler`, `klipp`), så
+`@innspel/react-native` og `@innspel/web` maskerer likt.
+
 ### Mønstervarsel
 
 ```ts

package/dist/index.cjs

@@ -780,6 +780,28 @@ var createClient = (config = {}) => {
 var client = createClient(createConfig());
 
 // src/generated/api/sdk.gen.ts
+var attachmentsPresign = (options) => (options.client ?? client).post({
+  security: [{ name: "X-Innspel-Tenant-Key", type: "apiKey" }, {
+    key: "FeedbackTokenAuth",
+    scheme: "bearer",
+    type: "http"
+  }],
+  url: "/v1/ingest/attachments/presign",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var attachmentsComplete = (options) => (options.client ?? client).post({
+  security: [{ name: "X-Innspel-Tenant-Key", type: "apiKey" }, {
+    key: "FeedbackTokenAuth",
+    scheme: "bearer",
+    type: "http"
+  }],
+  url: "/v1/ingest/attachments/{id}/complete",
+  ...options
+});
 var knownIssuesList2 = (options) => (options?.client ?? client).get({
   security: [{ name: "X-Innspel-Tenant-Key", type: "apiKey" }, {
     key: "FeedbackTokenAuth",
@@ -1129,8 +1151,66 @@ function nyClientRef() {
   return hex.join("");
 }
 
+// src/vedlegg.ts
+var VEDLEGG_GRENSER = {
+  maxBytes: 5242880,
+  maxDimension: 4096
+};
+var TILLATTE_MIME = ["image/png", "image/jpeg", "image/webp"];
+function byteLengde(body) {
+  if (typeof body === "object" && body !== null && "size" in body && typeof body.size === "number") {
+    return body.size;
+  }
+  return body.byteLength;
+}
+function validerVedlegg(input) {
+  if (input === null || typeof input !== "object") {
+    throw new InnspelConfigError("attachment", "m\xE5 v\xE6re et objekt med { submissionId?, mime, body, width, height }");
+  }
+  if (!TILLATTE_MIME.includes(input.mime)) {
+    throw new InnspelConfigError(
+      "attachment.mime",
+      `m\xE5 v\xE6re en av ${TILLATTE_MIME.join(", ")}. SVG og GIF er aldri tillatt (K9)`
+    );
+  }
+  if (input.body === null || input.body === void 0) {
+    throw new InnspelConfigError("attachment.body", "mangler \u2014 send bildet som Blob, ArrayBuffer eller Uint8Array");
+  }
+  const bytes = byteLengde(input.body);
+  if (!Number.isFinite(bytes) || bytes < 1) {
+    throw new InnspelConfigError("attachment.body", "er tom");
+  }
+  if (bytes > VEDLEGG_GRENSER.maxBytes) {
+    throw new InnspelConfigError(
+      "attachment.body",
+      `er ${bytes} byte, over taket p\xE5 ${VEDLEGG_GRENSER.maxBytes} (5 MB). Reduser kvaliteten eller oppl\xF8sningen ved fangst`
+    );
+  }
+  for (const felt of ["width", "height"]) {
+    const v = input[felt];
+    if (!Number.isInteger(v) || v < 1 || v > VEDLEGG_GRENSER.maxDimension) {
+      throw new InnspelConfigError(
+        `attachment.${felt}`,
+        `m\xE5 v\xE6re et heltall mellom 1 og ${VEDLEGG_GRENSER.maxDimension} (K9)`
+      );
+    }
+  }
+}
+async function lastOppTilLagring(fetchImpl, presign, body, signal) {
+  const headers = {};
+  for (const h of presign.headers) headers[h.name] = h.value;
+  const res = await fetchImpl(new Request(presign.uploadUrl, { method: "PUT", headers, body, signal }));
+  if (!res.ok) {
+    throw new InnspelApiError(
+      res.status,
+      "unknown",
+      `Lagringen avviste opplastingen med status ${res.status}. Bildet ble ikke lagt ved.`
+    );
+  }
+}
+
 // src/versjon.ts
-var VERSJON = "0.1.1";
+var VERSJON = "0.2.0";
 
 // src/klient.ts
 var STANDARD_TIMEOUT_MS = 1e4;
@@ -1272,6 +1352,31 @@ function init(options) {
       })
     );
   }
+  async function lastOppVedlegg(submissionId, vedlegg) {
+    const presign = await medToken(
+      (h) => attachmentsPresign({
+        client: klient,
+        headers: h,
+        signal: signal(),
+        body: {
+          submissionId,
+          mime: vedlegg.mime,
+          bytes: byteLengde(vedlegg.body),
+          width: vedlegg.width,
+          height: vedlegg.height
+        }
+      })
+    );
+    await lastOppTilLagring(options.fetch ?? fetch, presign, vedlegg.body, signal());
+    return medToken(
+      (h) => attachmentsComplete({
+        client: klient,
+        headers: h,
+        signal: signal(),
+        path: { id: presign.attachmentId }
+      })
+    );
+  }
   const flushK\u00F8 = () => flushKo(
     k\u00F8,
     (rad) => sendN\u00E5({ type: rad.type, text: rad.text }, rad.clientRef, kontekst),
@@ -1297,17 +1402,12 @@ function init(options) {
         );
       }
       if (input.context) validerKontekst(input.context, "capture.context", false);
+      if (input.attachment) validerVedlegg(input.attachment);
       const clientRef = input.clientRef ?? nyClientRef();
       const kontekstForKall = sl\u00E5SammenKontekst(options.context, input.context, VERSJON);
+      let submission;
       try {
-        const submission = await sendN\u00E5(input, clientRef, kontekstForKall);
-        telemetri.emit({
-          name: "submission_sent",
-          type: input.type,
-          hasAttachment: false,
-          offlineQueued: false
-        });
-        return { status: "sent", submission };
+        submission = await sendN\u00E5(input, clientRef, kontekstForKall);
       } catch (e) {
         if (e instanceof InnspelApiError) {
           telemetri.emit({ name: "submission_failed", reason: e.code });
@@ -1325,8 +1425,23 @@ function init(options) {
           hasAttachment: false,
           offlineQueued: true
         });
-        return { status: "queued", clientRef };
+        return input.attachment ? { status: "queued", clientRef, attachment: { status: "dropped" } } : { status: "queued", clientRef };
+      }
+      let attachment;
+      if (input.attachment) {
+        try {
+          attachment = { status: "uploaded", attachment: await lastOppVedlegg(submission.id, input.attachment) };
+        } catch (e) {
+          attachment = { status: "failed", error: e instanceof Error ? e : new Error(String(e)) };
+        }
       }
+      telemetri.emit({
+        name: "submission_sent",
+        type: input.type,
+        hasAttachment: attachment?.status === "uploaded",
+        offlineQueued: false
+      });
+      return attachment ? { status: "sent", submission, attachment } : { status: "sent", submission };
     },
     knownIssues: {
       async for(query = {}) {
@@ -1406,6 +1521,15 @@ function init(options) {
         );
       }
     },
+    attachments: {
+      async upload(submissionId, attachment) {
+        if (typeof submissionId !== "string" || submissionId.length === 0) {
+          throw new InnspelConfigError("submissionId", "mangler \u2014 bruk id fra innsendingen capture() ga");
+        }
+        validerVedlegg(attachment);
+        return lastOppVedlegg(submissionId, attachment);
+      }
+    },
     queue: {
       pending: () => k\u00F8.les(),
       flush: flushK\u00F8
@@ -1429,13 +1553,72 @@ function init(options) {
   return innspel;
 }
 
+// src/maskering.ts
+function strokTilRekter(punkter, penselBredde, bilde) {
+  if (penselBredde <= 0 || punkter.length === 0) return [];
+  const halv = penselBredde / 2;
+  const ut = [];
+  const legg = (p) => {
+    const r = klipp({ x: p.x - halv, y: p.y - halv, width: penselBredde, height: penselBredde }, bilde);
+    if (r) ut.push(r);
+  };
+  legg(punkter[0]);
+  for (let i = 1; i < punkter.length; i++) {
+    const a = punkter[i - 1];
+    const b = punkter[i];
+    const avstand = Math.hypot(b.x - a.x, b.y - a.y);
+    const steg = Math.max(1, Math.ceil(avstand / halv));
+    for (let s = 1; s <= steg; s++) {
+      legg({ x: a.x + (b.x - a.x) * s / steg, y: a.y + (b.y - a.y) * s / steg });
+    }
+  }
+  return ut;
+}
+function trykkTilRekt(punkt, boks, bilde) {
+  return klipp({ x: punkt.x - boks.width / 2, y: punkt.y - boks.height / 2, width: boks.width, height: boks.height }, bilde);
+}
+function klipp(r, bilde) {
+  const x1 = Math.max(0, r.x);
+  const y1 = Math.max(0, r.y);
+  const x2 = Math.min(bilde.width, r.x + r.width);
+  const y2 = Math.min(bilde.height, r.y + r.height);
+  if (x2 <= x1 || y2 <= y1) return null;
+  return { x: x1, y: y1, width: x2 - x1, height: y2 - y1 };
+}
+function skaler(r, fra, til) {
+  const sx = til.width / fra.width;
+  const sy = til.height / fra.height;
+  const x = Math.floor(r.x * sx);
+  const y = Math.floor(r.y * sy);
+  return {
+    x,
+    y,
+    width: Math.ceil((r.x + r.width) * sx) - x,
+    height: Math.ceil((r.y + r.height) * sy) - y
+  };
+}
+function treffer(punkt, r) {
+  return punkt.x >= r.x && punkt.x < r.x + r.width && punkt.y >= r.y && punkt.y < r.y + r.height;
+}
+function dekkerAlt(rekter, bilde) {
+  return rekter.some((r) => r.x <= 0 && r.y <= 0 && r.x + r.width >= bilde.width && r.y + r.height >= bilde.height);
+}
+
 exports.InnspelApiError = InnspelApiError;
 exports.InnspelConfigError = InnspelConfigError;
 exports.InnspelQueueFullError = InnspelQueueFullError;
 exports.KONTEKST_FELTER = KONTEKST_FELTER;
 exports.KO_TAK = KO_TAK;
+exports.TILLATTE_MIME = TILLATTE_MIME;
+exports.VEDLEGG_GRENSER = VEDLEGG_GRENSER;
 exports.VERSJON = VERSJON;
+exports.dekkerAlt = dekkerAlt;
 exports.init = init;
+exports.klipp = klipp;
 exports.scanText = scanText;
+exports.skaler = skaler;
+exports.strokTilRekter = strokTilRekter;
+exports.treffer = treffer;
+exports.trykkTilRekt = trykkTilRekt;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map