@farm.js/core 0.1.17 → 0.1.18

package/dist/chunk-TKNSDBBN.cjs

@@ -0,0 +1,193 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkTKJZFIMLcjs = require('./chunk-TKJZFIML.cjs');
+
+
+var _chunkEM6SBQKMcjs = require('./chunk-EM6SBQKM.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/metadata-image.ts
+var REACT_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.element");
+var REACT_TRANSITIONAL_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.transitional.element");
+var REACT_FORWARD_REF_TYPE = /* @__PURE__ */ Symbol.for("react.forward_ref");
+var REACT_MEMO_TYPE = /* @__PURE__ */ Symbol.for("react.memo");
+var REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy");
+function isResponse(value) {
+  return typeof Response !== "undefined" && (value instanceof Response || Boolean(
+    value && typeof value === "object" && typeof value.arrayBuffer === "function" && value.headers
+  ));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isResponse, "isResponse");
+function isThenable(value) {
+  return Boolean(
+    value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function"
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isThenable, "isThenable");
+function isReactElement(value) {
+  if (!value || typeof value !== "object") return false;
+  const marker = value.$$typeof;
+  return marker === REACT_ELEMENT_TYPE || marker === REACT_TRANSITIONAL_ELEMENT_TYPE;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isReactElement, "isReactElement");
+async function prepareMetadataImageNode(node) {
+  if (isThenable(node)) {
+    return prepareMetadataImageNode(await node);
+  }
+  if (Array.isArray(node)) {
+    return Promise.all(node.map((child) => prepareMetadataImageNode(child)));
+  }
+  if (!isReactElement(node)) {
+    return node;
+  }
+  const element = node;
+  const type = element.type;
+  const props = element.props || {};
+  if (typeof type === "function") {
+    if (_optionalChain([type, 'access', _ => _.prototype, 'optionalAccess', _2 => _2.isReactComponent])) {
+      throw new Error(
+        "Metadata image components must be stateless function components; React class components are not supported."
+      );
+    }
+    return prepareMetadataImageNode(await type(props));
+  }
+  if (type && typeof type === "object") {
+    if (type.$$typeof === REACT_MEMO_TYPE) {
+      const { createElement: createElement2 } = await import("react");
+      return prepareMetadataImageNode(createElement2(type.type, props));
+    }
+    if (type.$$typeof === REACT_FORWARD_REF_TYPE) {
+      return prepareMetadataImageNode(await type.render(props, null));
+    }
+    if (type.$$typeof === REACT_LAZY_TYPE) {
+      const { createElement: createElement2 } = await import("react");
+      let resolvedType;
+      try {
+        resolvedType = type._init(type._payload);
+      } catch (suspension) {
+        if (suspension && typeof suspension.then === "function") {
+          await suspension;
+          resolvedType = type._init(type._payload);
+        } else {
+          throw suspension;
+        }
+      }
+      return prepareMetadataImageNode(createElement2(resolvedType, props));
+    }
+  }
+  const preparedChildren = await prepareMetadataImageNode(props.children);
+  const preparedProps = { ...props };
+  if (typeof preparedProps.className === "string") {
+    preparedProps.tw = [preparedProps.tw, preparedProps.className].filter(Boolean).join(" ");
+    delete preparedProps.className;
+  }
+  delete preparedProps.children;
+  const { createElement } = await import("react");
+  return createElement(type, {
+    ...preparedProps,
+    key: element.key,
+    children: preparedChildren
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, prepareMetadataImageNode, "prepareMetadataImageNode");
+async function normalizeFonts(fonts) {
+  if (!_optionalChain([fonts, 'optionalAccess', _3 => _3.length])) return void 0;
+  return Promise.all(
+    fonts.map(async (font) => {
+      const data = await font.data;
+      const arrayBuffer = ArrayBuffer.isView(data) ? toArrayBuffer(data) : data;
+      return { ...font, data: arrayBuffer };
+    })
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeFonts, "normalizeFonts");
+function resolveCacheControl(revalidate) {
+  if (revalidate === false) {
+    return "public, max-age=31536000, immutable";
+  }
+  if (typeof revalidate === "number" && Number.isFinite(revalidate) && revalidate > 0) {
+    return `public, s-maxage=${Math.floor(revalidate)}, stale-while-revalidate=300`;
+  }
+  return "public, max-age=0, must-revalidate";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveCacheControl, "resolveCacheControl");
+function toArrayBuffer(value) {
+  if (value instanceof ArrayBuffer) return value;
+  const bytes = new Uint8Array(value.byteLength);
+  bytes.set(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
+  return bytes.buffer;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, toArrayBuffer, "toArrayBuffer");
+async function createEntityTag(body) {
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", body);
+  const hash = Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("").slice(0, 32);
+  return `"${hash}"`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createEntityTag, "createEntityTag");
+async function finalizeMetadataImageResponse(body, headers, options) {
+  const responseHeaders = new Headers(headers);
+  const etag = await createEntityTag(body);
+  responseHeaders.set("ETag", etag);
+  responseHeaders.set("Content-Length", String(body.byteLength));
+  responseHeaders.set("X-Content-Type-Options", "nosniff");
+  if (_chunkEM6SBQKMcjs.matchesFarmIfNoneMatch.call(void 0, options.ifNoneMatch, etag)) {
+    return new Response(null, { status: 304, headers: responseHeaders });
+  }
+  return new Response(_optionalChain([options, 'access', _4 => _4.method, 'optionalAccess', _5 => _5.toUpperCase, 'call', _6 => _6()]) === "HEAD" ? null : body, {
+    status: 200,
+    headers: responseHeaders
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, finalizeMetadataImageResponse, "finalizeMetadataImageResponse");
+async function createFarmMetadataImageResponse(value, imageModule, options = {}) {
+  const method = (options.method || "GET").toUpperCase();
+  if (method !== "GET" && method !== "HEAD") {
+    return new Response(null, { status: 405, headers: { Allow: "GET, HEAD" } });
+  }
+  if (isResponse(value)) {
+    return method === "HEAD" ? _chunkTKJZFIMLcjs.omitFarmResponseBody.call(void 0, value) : value;
+  }
+  const cacheControl = resolveCacheControl(imageModule.revalidate);
+  const explicitContentType = _optionalChain([imageModule, 'access', _7 => _7.contentType, 'optionalAccess', _8 => _8.split, 'call', _9 => _9(";", 1), 'access', _10 => _10[0], 'optionalAccess', _11 => _11.trim, 'call', _12 => _12(), 'access', _13 => _13.toLowerCase, 'call', _14 => _14()]);
+  if (isReactElement(value) && explicitContentType !== "image/svg+xml") {
+    const { ImageResponse } = await import("@vercel/og");
+    const element = await prepareMetadataImageNode(value);
+    const response = new ImageResponse(element, {
+      width: _optionalChain([imageModule, 'access', _15 => _15.size, 'optionalAccess', _16 => _16.width]) || 1200,
+      height: _optionalChain([imageModule, 'access', _17 => _17.size, 'optionalAccess', _18 => _18.height]) || 630,
+      fonts: await normalizeFonts(imageModule.fonts),
+      emoji: imageModule.emoji,
+      debug: imageModule.debug,
+      headers: { "cache-control": cacheControl }
+    });
+    const headers = new Headers(response.headers);
+    headers.set("Cache-Control", cacheControl);
+    return finalizeMetadataImageResponse(await response.arrayBuffer(), headers, options);
+  }
+  let body;
+  if (typeof value === "string") {
+    body = toArrayBuffer(new TextEncoder().encode(value));
+  } else if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
+    body = toArrayBuffer(value);
+  } else if (isReactElement(value)) {
+    const { renderToStaticMarkup } = await import("react-dom/server");
+    body = toArrayBuffer(new TextEncoder().encode(renderToStaticMarkup(value)));
+  } else {
+    throw new Error("Metadata image must return a Response, string, bytes, or React element");
+  }
+  return finalizeMetadataImageResponse(
+    body,
+    {
+      "Content-Type": imageModule.contentType || "image/svg+xml; charset=utf-8",
+      "Cache-Control": cacheControl
+    },
+    options
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmMetadataImageResponse, "createFarmMetadataImageResponse");
+
+
+
+exports.createFarmMetadataImageResponse = createFarmMetadataImageResponse;