@farm.js/core 0.1.17 → 0.1.18

package/dist/chunk-ARJWXNQL.cjs

@@ -0,0 +1,256 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } 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 _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/api/transport.ts
+function multipart(schema) {
+  if (!Object.isExtensible(schema) && !isMultipartSchema(schema)) {
+    throw new TypeError("multipart() requires an extensible schema object");
+  }
+  if (!isMultipartSchema(schema)) {
+    Object.defineProperty(schema, "__farmMultipartSchema", {
+      value: true,
+      configurable: false,
+      enumerable: false,
+      writable: false
+    });
+  }
+  return schema;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, multipart, "multipart");
+function isMultipartSchema(value) {
+  return typeof value === "object" && value !== null && value.__farmMultipartSchema === true && typeof value.parse === "function";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isMultipartSchema, "isMultipartSchema");
+function toFormData(values) {
+  const formData = new FormData();
+  for (const [key, value] of Object.entries(values)) {
+    if (isUnsafeFormKey(key)) continue;
+    if (Array.isArray(value)) {
+      for (const entry of value) appendFormValue(formData, key, entry);
+      continue;
+    }
+    appendFormValue(formData, key, value);
+  }
+  return formData;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, toFormData, "toFormData");
+function jsonStream(source, init = {}) {
+  const iterator = toAsyncIterator(source);
+  const encoder = new TextEncoder();
+  let finished = false;
+  let cleanup;
+  const closeSource = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (reason) => _nullishCoalesce(cleanup, () => ( (cleanup = Promise.resolve().then(() => _optionalChain([iterator, 'access', _ => _.return, 'optionalCall', _2 => _2(reason)]))))), "closeSource");
+  const body = new ReadableStream(
+    {
+      async pull(controller) {
+        if (finished) return;
+        try {
+          const next = await iterator.next();
+          if (finished) return;
+          if (next.done) {
+            finished = true;
+            controller.close();
+            return;
+          }
+          const serialized = JSON.stringify(next.value);
+          if (serialized === void 0) {
+            throw new TypeError("Farm JSON stream chunks must be JSON-serializable values");
+          }
+          controller.enqueue(encoder.encode(`${serialized}
+`));
+        } catch (error) {
+          if (finished) return;
+          finished = true;
+          try {
+            await closeSource(error);
+          } catch (e) {
+          }
+          controller.error(error);
+        }
+      },
+      async cancel(reason) {
+        finished = true;
+        await closeSource(reason);
+      }
+    },
+    {
+      // Do not read the next application event until the response consumer
+      // requests another chunk.
+      highWaterMark: 0
+    }
+  );
+  const headers = new Headers(init.headers);
+  if (!headers.has("content-type")) {
+    headers.set("content-type", "application/x-ndjson; charset=utf-8");
+  }
+  headers.set("cache-control", _nullishCoalesce(headers.get("cache-control"), () => ( "no-store")));
+  return new Response(body, {
+    ...init,
+    headers
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, jsonStream, "jsonStream");
+function isJSONStreamResponse(response) {
+  const contentType = _nullishCoalesce(_optionalChain([response, 'access', _3 => _3.headers, 'optionalAccess', _4 => _4.get, 'optionalCall', _5 => _5("content-type"), 'optionalAccess', _6 => _6.toLowerCase, 'call', _7 => _7()]), () => ( ""));
+  return contentType.includes("application/x-ndjson") || contentType.includes("application/ndjson");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isJSONStreamResponse, "isJSONStreamResponse");
+function readJSONStream(response) {
+  if (!response.body) {
+    throw new TypeError("Cannot read a JSON stream response without a body");
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let completed = false;
+  let cancelled = false;
+  let claimed = false;
+  let released = false;
+  const releaseReader = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
+    if (released) return;
+    released = true;
+    reader.releaseLock();
+  }, "releaseReader");
+  const parseLine = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, async (line) => {
+    try {
+      return JSON.parse(line);
+    } catch (error) {
+      completed = true;
+      buffer = "";
+      void reader.cancel(error).catch(() => {
+      });
+      releaseReader();
+      throw error;
+    }
+  }, "parseLine");
+  const readNext = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, async () => {
+    while (true) {
+      if (cancelled) return { done: true, value: void 0 };
+      const lineEnd = buffer.indexOf("\n");
+      if (lineEnd >= 0) {
+        const line = buffer.slice(0, lineEnd).trim();
+        buffer = buffer.slice(lineEnd + 1);
+        if (!line) continue;
+        return { done: false, value: await parseLine(line) };
+      }
+      if (completed) {
+        const line = buffer.trim();
+        buffer = "";
+        if (!line) {
+          releaseReader();
+          return { done: true, value: void 0 };
+        }
+        return { done: false, value: await parseLine(line) };
+      }
+      let chunk;
+      try {
+        chunk = await reader.read();
+      } catch (error) {
+        if (cancelled) return { done: true, value: void 0 };
+        completed = true;
+        buffer = "";
+        releaseReader();
+        throw error;
+      }
+      if (cancelled) return { done: true, value: void 0 };
+      completed = chunk.done;
+      buffer += decoder.decode(chunk.value, { stream: !chunk.done });
+    }
+  }, "readNext");
+  let readQueue = Promise.resolve();
+  const iterator = {
+    next() {
+      const result = readQueue.then(readNext);
+      readQueue = result.then(
+        () => {
+        },
+        () => {
+        }
+      );
+      return result;
+    },
+    async return() {
+      cancelled = true;
+      completed = true;
+      buffer = "";
+      if (!released) {
+        try {
+          await reader.cancel();
+        } finally {
+          releaseReader();
+        }
+      }
+      return { done: true, value: void 0 };
+    }
+  };
+  return {
+    response,
+    async cancel(reason) {
+      cancelled = true;
+      completed = true;
+      buffer = "";
+      if (!released) {
+        try {
+          await reader.cancel(reason);
+        } finally {
+          releaseReader();
+        }
+      }
+    },
+    [Symbol.asyncIterator]() {
+      if (claimed) {
+        throw new TypeError("Farm API streams can only be consumed once");
+      }
+      claimed = true;
+      return iterator;
+    }
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, readJSONStream, "readJSONStream");
+function isFarmAPIStream(value) {
+  return typeof value === "object" && value !== null && "response" in value && typeof value.cancel === "function" && typeof value[Symbol.asyncIterator] === "function";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isFarmAPIStream, "isFarmAPIStream");
+function appendFormValue(formData, key, value) {
+  if (value === void 0) return;
+  if (value === null) {
+    formData.append(key, "");
+    return;
+  }
+  if (value instanceof Blob) {
+    formData.append(key, value);
+    return;
+  }
+  if (value instanceof Date) {
+    formData.append(key, value.toISOString());
+    return;
+  }
+  formData.append(key, String(value));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, appendFormValue, "appendFormValue");
+function isUnsafeFormKey(key) {
+  return key === "__proto__" || key === "constructor" || key === "prototype";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isUnsafeFormKey, "isUnsafeFormKey");
+function toAsyncIterator(source) {
+  if (Symbol.asyncIterator in Object(source)) {
+    return source[Symbol.asyncIterator]();
+  }
+  const iterator = source[Symbol.iterator]();
+  return {
+    next: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, async () => iterator.next(), "next"),
+    return: iterator.return ? async (value) => iterator.return(value) : void 0
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, toAsyncIterator, "toAsyncIterator");
+
+
+
+
+
+
+
+
+
+exports.multipart = multipart; exports.isMultipartSchema = isMultipartSchema; exports.toFormData = toFormData; exports.jsonStream = jsonStream; exports.isJSONStreamResponse = isJSONStreamResponse; exports.readJSONStream = readJSONStream; exports.isFarmAPIStream = isFarmAPIStream;