@medialane/ui 0.105.0 → 0.106.0

package/dist/utils/proxy-body.cjs

@@ -0,0 +1,60 @@
+"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);
+var proxy_body_exports = {};
+__export(proxy_body_exports, {
+  readBodyWithCap: () => readBodyWithCap
+});
+module.exports = __toCommonJS(proxy_body_exports);
+async function readBodyWithCap(upstream, maxBytes) {
+  const declaredLength = upstream.headers.get("content-length");
+  if (declaredLength) {
+    const n = Number.parseInt(declaredLength, 10);
+    if (Number.isFinite(n) && n > maxBytes) {
+      return { ok: false, status: 413, error: `Response exceeds size cap (${maxBytes} bytes)` };
+    }
+  }
+  if (!upstream.body) {
+    return { ok: false, status: 502, error: "Upstream returned no body" };
+  }
+  const reader = upstream.body.getReader();
+  const chunks = [];
+  let total = 0;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    total += value.byteLength;
+    if (total > maxBytes) {
+      await reader.cancel();
+      return { ok: false, status: 413, error: `Response exceeds size cap (${maxBytes} bytes)` };
+    }
+    chunks.push(value);
+  }
+  const body = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return { ok: true, body };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  readBodyWithCap
+});
+//# sourceMappingURL=proxy-body.cjs.map

package/dist/utils/proxy-body.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/proxy-body.ts"],"sourcesContent":["/**\n * Read an upstream `fetch` Response body into memory with a hard byte cap.\n *\n * `arrayBuffer()` buffers the whole body before any limit applies, so a public\n * proxy route (image, IPFS) can be made to pin server memory by pointing it at\n * a large file. This streams the body and aborts once `maxBytes` is crossed.\n * A `Content-Length` larger than the cap short-circuits before a byte is read\n * (advisory — some origins omit or lie, so the streaming guard is the real\n * limit). Shared by both apps' `/api/img` and `/api/ipfs` routes so the cap\n * can't drift between them.\n */\nexport type CappedBody =\n  | { ok: true; body: Uint8Array<ArrayBuffer> }\n  | { ok: false; status: 413 | 502; error: string };\n\nexport async function readBodyWithCap(upstream: Response, maxBytes: number): Promise<CappedBody> {\n  const declaredLength = upstream.headers.get(\"content-length\");\n  if (declaredLength) {\n    const n = Number.parseInt(declaredLength, 10);\n    if (Number.isFinite(n) && n > maxBytes) {\n      return { ok: false, status: 413, error: `Response exceeds size cap (${maxBytes} bytes)` };\n    }\n  }\n\n  if (!upstream.body) {\n    return { ok: false, status: 502, error: \"Upstream returned no body\" };\n  }\n\n  const reader = upstream.body.getReader();\n  const chunks: Uint8Array[] = [];\n  let total = 0;\n  while (true) {\n    const { done, value } = await reader.read();\n    if (done) break;\n    total += value.byteLength;\n    if (total > maxBytes) {\n      await reader.cancel();\n      return { ok: false, status: 413, error: `Response exceeds size cap (${maxBytes} bytes)` };\n    }\n    chunks.push(value);\n  }\n\n  const body = new Uint8Array(total) as Uint8Array<ArrayBuffer>;\n  let offset = 0;\n  for (const chunk of chunks) {\n    body.set(chunk, offset);\n    offset += chunk.byteLength;\n  }\n  return { ok: true, body };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAeA,eAAsB,gBAAgB,UAAoB,UAAuC;AAC/F,QAAM,iBAAiB,SAAS,QAAQ,IAAI,gBAAgB;AAC5D,MAAI,gBAAgB;AAClB,UAAM,IAAI,OAAO,SAAS,gBAAgB,EAAE;AAC5C,QAAI,OAAO,SAAS,CAAC,KAAK,IAAI,UAAU;AACtC,aAAO,EAAE,IAAI,OAAO,QAAQ,KAAK,OAAO,8BAA8B,QAAQ,UAAU;AAAA,IAC1F;AAAA,EACF;AAEA,MAAI,CAAC,SAAS,MAAM;AAClB,WAAO,EAAE,IAAI,OAAO,QAAQ,KAAK,OAAO,4BAA4B;AAAA,EACtE;AAEA,QAAM,SAAS,SAAS,KAAK,UAAU;AACvC,QAAM,SAAuB,CAAC;AAC9B,MAAI,QAAQ;AACZ,SAAO,MAAM;AACX,UAAM,EAAE,MAAM,MAAM,IAAI,MAAM,OAAO,KAAK;AAC1C,QAAI,KAAM;AACV,aAAS,MAAM;AACf,QAAI,QAAQ,UAAU;AACpB,YAAM,OAAO,OAAO;AACpB,aAAO,EAAE,IAAI,OAAO,QAAQ,KAAK,OAAO,8BAA8B,QAAQ,UAAU;AAAA,IAC1F;AACA,WAAO,KAAK,KAAK;AAAA,EACnB;AAEA,QAAM,OAAO,IAAI,WAAW,KAAK;AACjC,MAAI,SAAS;AACb,aAAW,SAAS,QAAQ;AAC1B,SAAK,IAAI,OAAO,MAAM;AACtB,cAAU,MAAM;AAAA,EAClB;AACA,SAAO,EAAE,IAAI,MAAM,KAAK;AAC1B;","names":[]}

package/dist/utils/proxy-body.d.cts

@@ -0,0 +1,22 @@
+/**
+ * Read an upstream `fetch` Response body into memory with a hard byte cap.
+ *
+ * `arrayBuffer()` buffers the whole body before any limit applies, so a public
+ * proxy route (image, IPFS) can be made to pin server memory by pointing it at
+ * a large file. This streams the body and aborts once `maxBytes` is crossed.
+ * A `Content-Length` larger than the cap short-circuits before a byte is read
+ * (advisory — some origins omit or lie, so the streaming guard is the real
+ * limit). Shared by both apps' `/api/img` and `/api/ipfs` routes so the cap
+ * can't drift between them.
+ */
+type CappedBody = {
+    ok: true;
+    body: Uint8Array<ArrayBuffer>;
+} | {
+    ok: false;
+    status: 413 | 502;
+    error: string;
+};
+declare function readBodyWithCap(upstream: Response, maxBytes: number): Promise<CappedBody>;
+
+export { type CappedBody, readBodyWithCap };

package/dist/utils/proxy-body.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Read an upstream `fetch` Response body into memory with a hard byte cap.
+ *
+ * `arrayBuffer()` buffers the whole body before any limit applies, so a public
+ * proxy route (image, IPFS) can be made to pin server memory by pointing it at
+ * a large file. This streams the body and aborts once `maxBytes` is crossed.
+ * A `Content-Length` larger than the cap short-circuits before a byte is read
+ * (advisory — some origins omit or lie, so the streaming guard is the real
+ * limit). Shared by both apps' `/api/img` and `/api/ipfs` routes so the cap
+ * can't drift between them.
+ */
+type CappedBody = {
+    ok: true;
+    body: Uint8Array<ArrayBuffer>;
+} | {
+    ok: false;
+    status: 413 | 502;
+    error: string;
+};
+declare function readBodyWithCap(upstream: Response, maxBytes: number): Promise<CappedBody>;
+
+export { type CappedBody, readBodyWithCap };

package/dist/utils/proxy-body.js

@@ -0,0 +1,36 @@
+async function readBodyWithCap(upstream, maxBytes) {
+  const declaredLength = upstream.headers.get("content-length");
+  if (declaredLength) {
+    const n = Number.parseInt(declaredLength, 10);
+    if (Number.isFinite(n) && n > maxBytes) {
+      return { ok: false, status: 413, error: `Response exceeds size cap (${maxBytes} bytes)` };
+    }
+  }
+  if (!upstream.body) {
+    return { ok: false, status: 502, error: "Upstream returned no body" };
+  }
+  const reader = upstream.body.getReader();
+  const chunks = [];
+  let total = 0;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    total += value.byteLength;
+    if (total > maxBytes) {
+      await reader.cancel();
+      return { ok: false, status: 413, error: `Response exceeds size cap (${maxBytes} bytes)` };
+    }
+    chunks.push(value);
+  }
+  const body = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return { ok: true, body };
+}
+export {
+  readBodyWithCap
+};
+//# sourceMappingURL=proxy-body.js.map

package/dist/utils/proxy-body.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/proxy-body.ts"],"sourcesContent":["/**\n * Read an upstream `fetch` Response body into memory with a hard byte cap.\n *\n * `arrayBuffer()` buffers the whole body before any limit applies, so a public\n * proxy route (image, IPFS) can be made to pin server memory by pointing it at\n * a large file. This streams the body and aborts once `maxBytes` is crossed.\n * A `Content-Length` larger than the cap short-circuits before a byte is read\n * (advisory — some origins omit or lie, so the streaming guard is the real\n * limit). Shared by both apps' `/api/img` and `/api/ipfs` routes so the cap\n * can't drift between them.\n */\nexport type CappedBody =\n  | { ok: true; body: Uint8Array<ArrayBuffer> }\n  | { ok: false; status: 413 | 502; error: string };\n\nexport async function readBodyWithCap(upstream: Response, maxBytes: number): Promise<CappedBody> {\n  const declaredLength = upstream.headers.get(\"content-length\");\n  if (declaredLength) {\n    const n = Number.parseInt(declaredLength, 10);\n    if (Number.isFinite(n) && n > maxBytes) {\n      return { ok: false, status: 413, error: `Response exceeds size cap (${maxBytes} bytes)` };\n    }\n  }\n\n  if (!upstream.body) {\n    return { ok: false, status: 502, error: \"Upstream returned no body\" };\n  }\n\n  const reader = upstream.body.getReader();\n  const chunks: Uint8Array[] = [];\n  let total = 0;\n  while (true) {\n    const { done, value } = await reader.read();\n    if (done) break;\n    total += value.byteLength;\n    if (total > maxBytes) {\n      await reader.cancel();\n      return { ok: false, status: 413, error: `Response exceeds size cap (${maxBytes} bytes)` };\n    }\n    chunks.push(value);\n  }\n\n  const body = new Uint8Array(total) as Uint8Array<ArrayBuffer>;\n  let offset = 0;\n  for (const chunk of chunks) {\n    body.set(chunk, offset);\n    offset += chunk.byteLength;\n  }\n  return { ok: true, body };\n}\n"],"mappings":"AAeA,eAAsB,gBAAgB,UAAoB,UAAuC;AAC/F,QAAM,iBAAiB,SAAS,QAAQ,IAAI,gBAAgB;AAC5D,MAAI,gBAAgB;AAClB,UAAM,IAAI,OAAO,SAAS,gBAAgB,EAAE;AAC5C,QAAI,OAAO,SAAS,CAAC,KAAK,IAAI,UAAU;AACtC,aAAO,EAAE,IAAI,OAAO,QAAQ,KAAK,OAAO,8BAA8B,QAAQ,UAAU;AAAA,IAC1F;AAAA,EACF;AAEA,MAAI,CAAC,SAAS,MAAM;AAClB,WAAO,EAAE,IAAI,OAAO,QAAQ,KAAK,OAAO,4BAA4B;AAAA,EACtE;AAEA,QAAM,SAAS,SAAS,KAAK,UAAU;AACvC,QAAM,SAAuB,CAAC;AAC9B,MAAI,QAAQ;AACZ,SAAO,MAAM;AACX,UAAM,EAAE,MAAM,MAAM,IAAI,MAAM,OAAO,KAAK;AAC1C,QAAI,KAAM;AACV,aAAS,MAAM;AACf,QAAI,QAAQ,UAAU;AACpB,YAAM,OAAO,OAAO;AACpB,aAAO,EAAE,IAAI,OAAO,QAAQ,KAAK,OAAO,8BAA8B,QAAQ,UAAU;AAAA,IAC1F;AACA,WAAO,KAAK,KAAK;AAAA,EACnB;AAEA,QAAM,OAAO,IAAI,WAAW,KAAK;AACjC,MAAI,SAAS;AACb,aAAW,SAAS,QAAQ;AAC1B,SAAK,IAAI,OAAO,MAAM;AACtB,cAAU,MAAM;AAAA,EAClB;AACA,SAAO,EAAE,IAAI,MAAM,KAAK;AAC1B;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@medialane/ui",
-  "version": "0.105.0",
+  "version": "0.106.0",
   "description": "Shared UI components for Medialane apps",
   "type": "module",
   "sideEffects": false,