@mnaoumov/obsidian-lib 10.5.1 → 10.7.0

package/dist/lib/esm/request-url.mjs

@@ -0,0 +1,428 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+ensureDisposeSymbols();
+ensureBrowserProcess();
+})();
+
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    if (async) dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
+import {
+  abortSignalAny,
+  abortSignalTimeout,
+  onAbort
+} from "@mnaoumov/typescript-lib/abort-controller";
+import { noop } from "@mnaoumov/typescript-lib/function";
+import { normalizeOptionalProperties } from "@mnaoumov/typescript-lib/object-utils";
+import {
+  Platform,
+  requestUrl
+} from "obsidian";
+const HTTP_ERROR_STATUS_MIN = 400;
+const ERROR_MESSAGE_BODY_LENGTH = 200;
+const HTTP_SWITCHING_PROTOCOLS_STATUS = 101;
+const HTTP_EARLY_HINTS_STATUS = 103;
+const HTTP_NO_CONTENT_STATUS = 204;
+const HTTP_RESET_CONTENT_STATUS = 205;
+const HTTP_NOT_MODIFIED_STATUS = 304;
+const NULL_BODY_STATUSES = /* @__PURE__ */ new Set([
+  HTTP_EARLY_HINTS_STATUS,
+  HTTP_NO_CONTENT_STATUS,
+  HTTP_NOT_MODIFIED_STATUS,
+  HTTP_RESET_CONTENT_STATUS,
+  HTTP_SWITCHING_PROTOCOLS_STATUS
+]);
+const SUPPORTED_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:"]);
+const CONTENT_TYPE_HEADER = "content-type";
+const HEX_RADIX = 16;
+const BOUNDARY_RANDOM_PART_COUNT = 2;
+const RANDOM_PART_START = 2;
+class RequestUrlError extends Error {
+  /**
+   * The response headers.
+   */
+  headers;
+  /**
+   * The HTTP method.
+   */
+  method;
+  /**
+   * The status code.
+   */
+  status;
+  /**
+   * The response body as text.
+   */
+  text;
+  /**
+   * The URL.
+   */
+  url;
+  /**
+   * Creates a {@link RequestUrlError}.
+   *
+   * @param params - The failed request and its response.
+   */
+  constructor(params) {
+    const bodyExcerpt = params.text.length > ERROR_MESSAGE_BODY_LENGTH ? `${params.text.slice(0, ERROR_MESSAGE_BODY_LENGTH)}\u2026` : params.text;
+    super(`${params.method} ${params.url} failed with status ${String(params.status)}${bodyExcerpt ? `: ${bodyExcerpt}` : ""}`);
+    this.name = "RequestUrlError";
+    this.headers = params.headers;
+    this.method = params.method;
+    this.status = params.status;
+    this.text = params.text;
+    this.url = params.url;
+  }
+  /**
+   * Parses the response body as JSON.
+   *
+   * @returns The parsed body.
+   */
+  json() {
+    return JSON.parse(this.text);
+  }
+}
+function createRequestUrlFetch(options = {}) {
+  return async (input, init = {}) => {
+    let request = null;
+    let url;
+    if (typeof input === "string") {
+      url = input;
+    } else if ("method" in input) {
+      request = input;
+      url = input.url;
+    } else {
+      url = input.href;
+    }
+    const method = (init.method ?? request?.method ?? "GET").toUpperCase();
+    const headers = toHeaderRecord(request?.headers, init.headers);
+    let body = init.body ?? void 0;
+    if (body === void 0 && request && method !== "GET" && method !== "HEAD") {
+      body = await request.arrayBuffer();
+    }
+    const params = {
+      abortSignal: init.signal ?? request?.signal ?? void 0,
+      body,
+      headers,
+      method,
+      shouldThrowOnHttpError: false,
+      timeoutInMilliseconds: options.timeoutInMilliseconds,
+      url
+    };
+    if (options.shouldStream) {
+      const streamResponse = await requestUrlStream(params);
+      return createResponse(streamResponse.status, streamResponse.headers, streamResponse.body, streamResponse.url);
+    }
+    const response = await requestUrlEx(params);
+    return createResponse(response.status, response.headers, response.arrayBuffer, url);
+  };
+}
+async function encodeRequestUrlRequest(params) {
+  const url = assertHttpUrl(params.url);
+  const abortSignal = abortSignalAny(
+    params.abortSignal,
+    params.timeoutInMilliseconds === void 0 ? void 0 : abortSignalTimeout(params.timeoutInMilliseconds)
+  );
+  abortSignal.throwIfAborted();
+  const encodedBody = await encodeBody(params.body);
+  abortSignal.throwIfAborted();
+  const headers = { ...params.headers };
+  const hasContentTypeHeader = Object.keys(headers).some((name) => name.toLowerCase() === CONTENT_TYPE_HEADER);
+  const contentType = params.contentType ?? (hasContentTypeHeader ? void 0 : encodedBody.contentType);
+  if (contentType !== void 0) {
+    for (const name of Object.keys(headers)) {
+      if (name.toLowerCase() === CONTENT_TYPE_HEADER) {
+        delete headers[name];
+      }
+    }
+    headers["Content-Type"] = contentType;
+  }
+  return normalizeOptionalProperties({
+    abortSignal,
+    body: encodedBody.body,
+    headers,
+    method: (params.method ?? "GET").toUpperCase(),
+    url
+  });
+}
+async function requestUrlEx(params) {
+  const request = await encodeRequestUrlRequest(params);
+  const obsidianRequest = normalizeOptionalProperties({
+    body: request.body,
+    headers: { ...request.headers },
+    method: request.method,
+    throw: false,
+    url: request.url
+  });
+  const response = await raceWithAbort(Promise.resolve(requestUrl(obsidianRequest)), request.abortSignal);
+  if ((params.shouldThrowOnHttpError ?? true) && response.status >= HTTP_ERROR_STATUS_MIN) {
+    throw new RequestUrlError({
+      headers: response.headers,
+      method: request.method,
+      status: response.status,
+      text: response.text,
+      url: request.url
+    });
+  }
+  return response;
+}
+async function requestUrlStream(params) {
+  const request = await encodeRequestUrlRequest(params);
+  let response;
+  if (Platform.isDesktopApp) {
+    const { openDesktopRequestUrlStream } = await import("./desktop-request-url-stream.mjs");
+    response = await openDesktopRequestUrlStream(request);
+  } else {
+    const bufferedResponse = await requestUrlEx({
+      abortSignal: request.abortSignal,
+      body: request.body,
+      headers: request.headers,
+      method: request.method,
+      shouldThrowOnHttpError: false,
+      url: request.url
+    });
+    response = {
+      body: createSingleChunkStream(bufferedResponse.arrayBuffer),
+      headers: bufferedResponse.headers,
+      status: bufferedResponse.status,
+      url: request.url
+    };
+  }
+  if ((params.shouldThrowOnHttpError ?? true) && response.status >= HTTP_ERROR_STATUS_MIN) {
+    const text = new TextDecoder().decode(await readStream(response.body));
+    throw new RequestUrlError({
+      headers: response.headers,
+      method: request.method,
+      status: response.status,
+      text,
+      url: response.url
+    });
+  }
+  return response;
+}
+function assertHttpUrl(url) {
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(url);
+  } catch {
+    throw new TypeError(`Invalid URL: ${url}`);
+  }
+  if (!SUPPORTED_PROTOCOLS.has(parsedUrl.protocol)) {
+    throw new TypeError(`Unsupported protocol ${parsedUrl.protocol} in ${url}: only http: and https: URLs can be requested`);
+  }
+  return url;
+}
+function concatBytes(chunks) {
+  const length = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
+  const bytes = new Uint8Array(length);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return bytes.buffer;
+}
+function createResponse(status, headers, body, url) {
+  const response = new Response(NULL_BODY_STATUSES.has(status) ? null : body, {
+    headers: new Headers({ ...headers }),
+    status
+  });
+  Object.defineProperty(response, "url", { value: url });
+  return response;
+}
+function createSingleChunkStream(arrayBuffer) {
+  return new ReadableStream({
+    start(controller) {
+      if (arrayBuffer.byteLength > 0) {
+        controller.enqueue(new Uint8Array(arrayBuffer));
+      }
+      controller.close();
+    }
+  });
+}
+async function encodeBody(body) {
+  if (body === void 0 || typeof body === "string") {
+    return normalizeOptionalProperties({ body });
+  }
+  switch (Object.prototype.toString.call(body)) {
+    case "[object ArrayBuffer]": {
+      return { body };
+    }
+    case "[object Blob]":
+    case "[object File]": {
+      const blob = body;
+      return normalizeOptionalProperties({ body: await blob.arrayBuffer(), contentType: blob.type || void 0 });
+    }
+    case "[object FormData]": {
+      return await encodeFormData(body);
+    }
+    case "[object ReadableStream]": {
+      return { body: await readStream(body) };
+    }
+    case "[object URLSearchParams]": {
+      return { body: body.toString(), contentType: "application/x-www-form-urlencoded;charset=UTF-8" };
+    }
+    default: {
+      if (ArrayBuffer.isView(body)) {
+        return { body: new Uint8Array(body.buffer, body.byteOffset, body.byteLength).slice().buffer };
+      }
+      throw new TypeError(`Unsupported request body: ${Object.prototype.toString.call(body)}`);
+    }
+  }
+}
+async function encodeFormData(formData) {
+  const boundary = `----ObsidianLibFormBoundary${generateRandomHex()}`;
+  const textEncoder = new TextEncoder();
+  const chunks = [];
+  const entries = [];
+  formData.forEach((value, name) => {
+    entries.push([name, value]);
+  });
+  for (const [name, value] of entries) {
+    let header = `--${boundary}\r
+Content-Disposition: form-data; name="${escapeMultipartName(name)}"`;
+    if (typeof value === "string") {
+      chunks.push(textEncoder.encode(`${header}\r
+\r
+${value}\r
+`));
+      continue;
+    }
+    header += `; filename="${escapeMultipartName(value.name)}"\r
+Content-Type: ${value.type || "application/octet-stream"}\r
+\r
+`;
+    chunks.push(textEncoder.encode(header), new Uint8Array(await value.arrayBuffer()), textEncoder.encode("\r\n"));
+  }
+  chunks.push(textEncoder.encode(`--${boundary}--\r
+`));
+  return { body: concatBytes(chunks), contentType: `multipart/form-data; boundary=${boundary}` };
+}
+function escapeMultipartName(name) {
+  return name.replaceAll('"', "%22").replaceAll("\r", "%0D").replaceAll("\n", "%0A");
+}
+function generateRandomHex() {
+  return Array.from({ length: BOUNDARY_RANDOM_PART_COUNT }, () => Math.random().toString(HEX_RADIX).slice(RANDOM_PART_START)).join("");
+}
+async function raceWithAbort(promise, abortSignal) {
+  var _stack = [];
+  try {
+    let rejectOnAbort = noop;
+    const abortPromise = new Promise((_resolve, reject) => {
+      rejectOnAbort = reject;
+    });
+    const _abortListener = __using(_stack, onAbort(abortSignal, () => {
+      rejectOnAbort(abortSignal.reason);
+    }));
+    return await Promise.race([promise, abortPromise]);
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+async function readStream(stream) {
+  const reader = stream.getReader();
+  const chunks = [];
+  for (; ; ) {
+    const result = await reader.read();
+    if (result.done) {
+      break;
+    }
+    chunks.push(result.value);
+  }
+  return concatBytes(chunks);
+}
+function toHeaderRecord(requestHeaders, initHeaders) {
+  const headers = new Headers(requestHeaders);
+  new Headers(initHeaders).forEach((value, name) => {
+    headers.set(name, value);
+  });
+  const record = {};
+  headers.forEach((value, name) => {
+    record[name] = value;
+  });
+  return record;
+}
+export {
+  RequestUrlError,
+  createRequestUrlFetch,
+  encodeRequestUrlRequest,
+  requestUrlEx,
+  requestUrlStream
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/request-url.ts"],"sourcesContent":["/* eslint-disable n/no-unsupported-features/node-builtins -- These are Obsidian renderer Web APIs, not Node builtins. */\n/**\n * @file\n *\n * A wrapper over Obsidian's {@link requestUrl} that fills the gaps plugins keep hand-rolling: an abort signal and a\n * timeout, request bodies beyond `string | ArrayBuffer` (`FormData`, `URLSearchParams`, `Blob`, typed arrays and\n * streams), an error that carries the status and the body, an up-front protocol check, a streamed response body, and\n * a `fetch`-compatible adapter that third-party SDKs can take.\n *\n * `requestUrl` itself cannot be cancelled: an abort or a timeout settles the returned promise at once, while the\n * underlying request runs to completion and its result is dropped. The streamed variant really cancels on desktop,\n * where it goes through `node:http` / `node:https`; that module is imported dynamically, so this one stays\n * cross-platform-loadable. On mobile the streamed variant falls back to `requestUrl` and delivers the whole body as a\n * single chunk.\n */\n\nimport type {\n  RequestUrlParam,\n  RequestUrlResponse\n} from 'obsidian';\n\nimport {\n  abortSignalAny,\n  abortSignalTimeout,\n  onAbort\n} from '@mnaoumov/typescript-lib/abort-controller';\nimport { noop } from '@mnaoumov/typescript-lib/function';\nimport { normalizeOptionalProperties } from '@mnaoumov/typescript-lib/object-utils';\nimport {\n  Platform,\n  requestUrl\n} from 'obsidian';\n\n/**\n * Options for {@link createRequestUrlFetch}.\n */\nexport interface CreateRequestUrlFetchOptions {\n  /**\n   * Whether to stream the response body through {@link requestUrlStream} rather than buffer it. Streaming is real on\n   * desktop only; on mobile the body still arrives as one chunk. Defaults to `false`.\n   */\n  readonly shouldStream?: boolean;\n\n  /**\n   * The timeout in milliseconds applied to every request, on top of the request's own `signal`.\n   */\n  readonly timeoutInMilliseconds?: number;\n}\n\n/**\n * The request in the form the transports take: validated, with the body encoded.\n */\nexport interface EncodedRequestUrlRequest {\n  /**\n   * Aborts the request.\n   */\n  readonly abortSignal: AbortSignal;\n\n  /**\n   * The encoded body.\n   */\n  readonly body?: ArrayBuffer | string;\n\n  /**\n   * The request headers, including the content type.\n   */\n  readonly headers: Readonly<Record<string, string>>;\n\n  /**\n   * The HTTP method, uppercase.\n   */\n  readonly method: string;\n\n  /**\n   * The URL.\n   */\n  readonly url: string;\n}\n\n/**\n * Parameters for {@link encodeRequestUrlRequest}.\n */\nexport type EncodeRequestUrlRequestParams = RequestUrlExParams;\n\n/**\n * Parameters for the {@link RequestUrlError} constructor.\n */\nexport interface RequestUrlErrorConstructorParams {\n  /**\n   * The response headers.\n   */\n  readonly headers: Readonly<Record<string, string>>;\n\n  /**\n   * The HTTP method.\n   */\n  readonly method: string;\n\n  /**\n   * The status code.\n   */\n  readonly status: number;\n\n  /**\n   * The response body as text.\n   */\n  readonly text: string;\n\n  /**\n   * The URL.\n   */\n  readonly url: string;\n}\n\n/**\n * A request body {@link requestUrlEx} accepts: everything `fetch` accepts.\n */\nexport type RequestUrlExBody = ArrayBuffer | ArrayBufferView | Blob | FormData | ReadableStream<Uint8Array> | string | URLSearchParams;\n\n/**\n * Parameters for {@link requestUrlEx}.\n */\nexport interface RequestUrlExParams {\n  /**\n   * Aborts the request. The promise rejects with the signal's reason.\n   */\n  readonly abortSignal?: AbortSignal | undefined;\n\n  /**\n   * The request body.\n   */\n  readonly body?: RequestUrlExBody | undefined;\n\n  /**\n   * The content type. When omitted, it is derived from the body: a `FormData` body gets `multipart/form-data` with its\n   * boundary, a `URLSearchParams` body `application/x-www-form-urlencoded` and a `Blob` body its own type — unless\n   * {@link RequestUrlExParams.headers} already carries a `Content-Type`.\n   */\n  readonly contentType?: string | undefined;\n\n  /**\n   * The request headers.\n   */\n  readonly headers?: Readonly<Record<string, string>> | undefined;\n\n  /**\n   * The HTTP method. Defaults to `GET`.\n   */\n  readonly method?: string | undefined;\n\n  /**\n   * Whether to throw a {@link RequestUrlError} when the status code is 400 or higher. Defaults to `true`.\n   */\n  readonly shouldThrowOnHttpError?: boolean | undefined;\n\n  /**\n   * The timeout in milliseconds. The promise rejects with a `TimeoutError` {@link DOMException} once it elapses.\n   */\n  readonly timeoutInMilliseconds?: number | undefined;\n\n  /**\n   * The URL. Only `http:` and `https:` URLs are accepted.\n   */\n  readonly url: string;\n}\n\n/**\n * A `fetch`-compatible function built on {@link requestUrl}.\n */\nexport type RequestUrlFetch = (input: Request | string | URL, init?: RequestInit) => Promise<Response>;\n\n/**\n * Parameters for {@link requestUrlStream}.\n */\nexport type RequestUrlStreamParams = RequestUrlExParams;\n\n/**\n * The response of {@link requestUrlStream}.\n */\nexport interface RequestUrlStreamResponse {\n  /**\n   * The response body.\n   */\n  readonly body: ReadableStream<Uint8Array>;\n\n  /**\n   * The response headers, with lowercase names.\n   */\n  readonly headers: Readonly<Record<string, string>>;\n\n  /**\n   * The status code.\n   */\n  readonly status: number;\n\n  /**\n   * The final URL, after any redirects.\n   */\n  readonly url: string;\n}\n\ninterface EncodedBody {\n  readonly body?: ArrayBuffer | string;\n  readonly contentType?: string;\n}\n\nconst HTTP_ERROR_STATUS_MIN = 400;\nconst ERROR_MESSAGE_BODY_LENGTH = 200;\nconst HTTP_SWITCHING_PROTOCOLS_STATUS = 101;\nconst HTTP_EARLY_HINTS_STATUS = 103;\nconst HTTP_NO_CONTENT_STATUS = 204;\nconst HTTP_RESET_CONTENT_STATUS = 205;\nconst HTTP_NOT_MODIFIED_STATUS = 304;\n// The statuses a Response refuses a body for.\nconst NULL_BODY_STATUSES = new Set([\n  HTTP_EARLY_HINTS_STATUS,\n  HTTP_NO_CONTENT_STATUS,\n  HTTP_NOT_MODIFIED_STATUS,\n  HTTP_RESET_CONTENT_STATUS,\n  HTTP_SWITCHING_PROTOCOLS_STATUS\n]);\nconst SUPPORTED_PROTOCOLS = new Set(['http:', 'https:']);\nconst CONTENT_TYPE_HEADER = 'content-type';\nconst HEX_RADIX = 16;\nconst BOUNDARY_RANDOM_PART_COUNT = 2;\nconst RANDOM_PART_START = 2;\n\n/**\n * The error {@link requestUrlEx} and {@link requestUrlStream} throw for a status code of 400 or higher.\n */\nexport class RequestUrlError extends Error {\n  /**\n   * The response headers.\n   */\n  public readonly headers: Readonly<Record<string, string>>;\n\n  /**\n   * The HTTP method.\n   */\n  public readonly method: string;\n\n  /**\n   * The status code.\n   */\n  public readonly status: number;\n\n  /**\n   * The response body as text.\n   */\n  public readonly text: string;\n\n  /**\n   * The URL.\n   */\n  public readonly url: string;\n\n  /**\n   * Creates a {@link RequestUrlError}.\n   *\n   * @param params - The failed request and its response.\n   */\n  public constructor(params: RequestUrlErrorConstructorParams) {\n    const bodyExcerpt = params.text.length > ERROR_MESSAGE_BODY_LENGTH ? `${params.text.slice(0, ERROR_MESSAGE_BODY_LENGTH)}…` : params.text;\n    super(`${params.method} ${params.url} failed with status ${String(params.status)}${bodyExcerpt ? `: ${bodyExcerpt}` : ''}`);\n    this.name = 'RequestUrlError';\n    this.headers = params.headers;\n    this.method = params.method;\n    this.status = params.status;\n    this.text = params.text;\n    this.url = params.url;\n  }\n\n  /**\n   * Parses the response body as JSON.\n   *\n   * @returns The parsed body.\n   */\n  public json(): unknown {\n    return JSON.parse(this.text);\n  }\n}\n\n/**\n * Creates a `fetch`-compatible function built on {@link requestUrl}, for SDKs that take a custom `fetch` (OpenAI,\n * LangChain, OAuth clients) and would otherwise hit CORS.\n *\n * Unlike `fetch`, it never rejects on an HTTP error status: it resolves with a {@link Response} carrying that status,\n * exactly as `fetch` does. It rejects with a `TypeError` for a URL that is not `http:` or `https:`.\n *\n * @param options - The options.\n * @returns The `fetch`-compatible function.\n */\nexport function createRequestUrlFetch(options: CreateRequestUrlFetchOptions = {}): RequestUrlFetch {\n  return async (input, init = {}) => {\n    let request: null | Request = null;\n    let url: string;\n    if (typeof input === 'string') {\n      url = input;\n    } else if ('method' in input) {\n      // A `URL` has no `method`; `instanceof` would fail across windows.\n      request = input;\n      url = input.url;\n    } else {\n      url = input.href;\n    }\n    const method = (init.method ?? request?.method ?? 'GET').toUpperCase();\n    const headers = toHeaderRecord(request?.headers, init.headers);\n    let body: RequestUrlExBody | undefined = init.body ?? undefined;\n    if (body === undefined && request && method !== 'GET' && method !== 'HEAD') {\n      body = await request.arrayBuffer();\n    }\n    const params: RequestUrlExParams = {\n      abortSignal: init.signal ?? request?.signal ?? undefined,\n      body,\n      headers,\n      method,\n      shouldThrowOnHttpError: false,\n      timeoutInMilliseconds: options.timeoutInMilliseconds,\n      url\n    };\n\n    if (options.shouldStream) {\n      const streamResponse = await requestUrlStream(params);\n      return createResponse(streamResponse.status, streamResponse.headers, streamResponse.body, streamResponse.url);\n    }\n\n    const response = await requestUrlEx(params);\n    return createResponse(response.status, response.headers, response.arrayBuffer, url);\n  };\n}\n\n/**\n * Encodes a request for a transport: validates the URL, combines the abort signal with the timeout, encodes the body\n * and settles the content type.\n *\n * @param params - The request.\n * @returns The encoded request.\n */\nexport async function encodeRequestUrlRequest(params: EncodeRequestUrlRequestParams): Promise<EncodedRequestUrlRequest> {\n  const url = assertHttpUrl(params.url);\n  const abortSignal = abortSignalAny(\n    params.abortSignal,\n    params.timeoutInMilliseconds === undefined ? undefined : abortSignalTimeout(params.timeoutInMilliseconds)\n  );\n  abortSignal.throwIfAborted();\n\n  const encodedBody = await encodeBody(params.body);\n  abortSignal.throwIfAborted();\n\n  const headers: Record<string, string> = { ...params.headers };\n  const hasContentTypeHeader = Object.keys(headers).some((name) => name.toLowerCase() === CONTENT_TYPE_HEADER);\n  const contentType = params.contentType ?? (hasContentTypeHeader ? undefined : encodedBody.contentType);\n  if (contentType !== undefined) {\n    for (const name of Object.keys(headers)) {\n      if (name.toLowerCase() === CONTENT_TYPE_HEADER) {\n        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- A header record is keyed by name.\n        delete headers[name];\n      }\n    }\n    headers['Content-Type'] = contentType;\n  }\n\n  return normalizeOptionalProperties<EncodedRequestUrlRequest>({\n    abortSignal,\n    body: encodedBody.body,\n    headers,\n    method: (params.method ?? 'GET').toUpperCase(),\n    url\n  });\n}\n\n/**\n * Requests a URL through {@link requestUrl}, with an abort signal, a timeout, richer bodies, a protocol check and a\n * {@link RequestUrlError} for an HTTP error status.\n *\n * @param params - The request.\n * @returns The response.\n */\nexport async function requestUrlEx(params: RequestUrlExParams): Promise<RequestUrlResponse> {\n  const request = await encodeRequestUrlRequest(params);\n  const obsidianRequest: RequestUrlParam = normalizeOptionalProperties<RequestUrlParam>({\n    body: request.body,\n    headers: { ...request.headers },\n    method: request.method,\n    throw: false,\n    url: request.url\n  });\n  const response = await raceWithAbort(Promise.resolve(requestUrl(obsidianRequest)), request.abortSignal);\n  if ((params.shouldThrowOnHttpError ?? true) && response.status >= HTTP_ERROR_STATUS_MIN) {\n    throw new RequestUrlError({\n      headers: response.headers,\n      method: request.method,\n      status: response.status,\n      text: response.text,\n      url: request.url\n    });\n  }\n  return response;\n}\n\n/**\n * Requests a URL and returns its body as a stream.\n *\n * On desktop the request goes through `node:http` / `node:https`, so the body streams as it arrives, an abort really\n * cancels the request, and redirects are followed. On mobile it falls back to {@link requestUrl}, and the whole body\n * arrives as a single chunk.\n *\n * @param params - The request.\n * @returns The response, with a streamed body.\n */\nexport async function requestUrlStream(params: RequestUrlStreamParams): Promise<RequestUrlStreamResponse> {\n  const request = await encodeRequestUrlRequest(params);\n  let response: RequestUrlStreamResponse;\n  if (Platform.isDesktopApp) {\n    const { openDesktopRequestUrlStream } = await import('./desktop-request-url-stream.ts');\n    response = await openDesktopRequestUrlStream(request);\n  } else {\n    const bufferedResponse = await requestUrlEx({\n      abortSignal: request.abortSignal,\n      body: request.body,\n      headers: request.headers,\n      method: request.method,\n      shouldThrowOnHttpError: false,\n      url: request.url\n    });\n    response = {\n      body: createSingleChunkStream(bufferedResponse.arrayBuffer),\n      headers: bufferedResponse.headers,\n      status: bufferedResponse.status,\n      url: request.url\n    };\n  }\n\n  if ((params.shouldThrowOnHttpError ?? true) && response.status >= HTTP_ERROR_STATUS_MIN) {\n    const text = new TextDecoder().decode(await readStream(response.body));\n    throw new RequestUrlError({\n      headers: response.headers,\n      method: request.method,\n      status: response.status,\n      text,\n      url: response.url\n    });\n  }\n  return response;\n}\n\nfunction assertHttpUrl(url: string): string {\n  let parsedUrl: URL;\n  try {\n    parsedUrl = new URL(url);\n  } catch {\n    throw new TypeError(`Invalid URL: ${url}`);\n  }\n  if (!SUPPORTED_PROTOCOLS.has(parsedUrl.protocol)) {\n    throw new TypeError(`Unsupported protocol ${parsedUrl.protocol} in ${url}: only http: and https: URLs can be requested`);\n  }\n  return url;\n}\n\nfunction concatBytes(chunks: readonly Uint8Array[]): ArrayBuffer {\n  const length = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);\n  const bytes = new Uint8Array(length);\n  let offset = 0;\n  for (const chunk of chunks) {\n    bytes.set(chunk, offset);\n    offset += chunk.byteLength;\n  }\n  return bytes.buffer;\n}\n\nfunction createResponse(status: number, headers: Readonly<Record<string, string>>, body: ArrayBuffer | ReadableStream<Uint8Array>, url: string): Response {\n  const response = new Response(NULL_BODY_STATUSES.has(status) ? null : body, {\n    headers: new Headers({ ...headers }),\n    status\n  });\n  Object.defineProperty(response, 'url', { value: url });\n  return response;\n}\n\nfunction createSingleChunkStream(arrayBuffer: ArrayBuffer): ReadableStream<Uint8Array> {\n  return new ReadableStream<Uint8Array>({\n    start(controller): void {\n      if (arrayBuffer.byteLength > 0) {\n        controller.enqueue(new Uint8Array(arrayBuffer));\n      }\n      controller.close();\n    }\n  });\n}\n\nasync function encodeBody(body: RequestUrlExBody | undefined): Promise<EncodedBody> {\n  if (body === undefined || typeof body === 'string') {\n    return normalizeOptionalProperties<EncodedBody>({ body });\n  }\n\n  // `instanceof` fails across windows, so the body kinds are told apart by their built-in tags.\n  switch (Object.prototype.toString.call(body)) {\n    case '[object ArrayBuffer]': {\n      return { body: body as ArrayBuffer };\n    }\n    case '[object Blob]':\n    case '[object File]': {\n      const blob = body as Blob;\n      return normalizeOptionalProperties<EncodedBody>({ body: await blob.arrayBuffer(), contentType: blob.type || undefined });\n    }\n    case '[object FormData]': {\n      return await encodeFormData(body as FormData);\n    }\n    case '[object ReadableStream]': {\n      return { body: await readStream(body as ReadableStream<Uint8Array>) };\n    }\n    case '[object URLSearchParams]': {\n      return { body: (body as URLSearchParams).toString(), contentType: 'application/x-www-form-urlencoded;charset=UTF-8' };\n    }\n    default: {\n      if (ArrayBuffer.isView(body)) {\n        return { body: new Uint8Array(body.buffer, body.byteOffset, body.byteLength).slice().buffer };\n      }\n      throw new TypeError(`Unsupported request body: ${Object.prototype.toString.call(body)}`);\n    }\n  }\n}\n\nasync function encodeFormData(formData: FormData): Promise<EncodedBody> {\n  const boundary = `----ObsidianLibFormBoundary${generateRandomHex()}`;\n  const textEncoder = new TextEncoder();\n  const chunks: Uint8Array[] = [];\n  const entries: [string, FormDataEntryValue][] = [];\n  formData.forEach((value, name) => {\n    entries.push([name, value]);\n  });\n\n  for (const [name, value] of entries) {\n    let header = `--${boundary}\\r\\nContent-Disposition: form-data; name=\"${escapeMultipartName(name)}\"`;\n    if (typeof value === 'string') {\n      chunks.push(textEncoder.encode(`${header}\\r\\n\\r\\n${value}\\r\\n`));\n      continue;\n    }\n    header += `; filename=\"${escapeMultipartName(value.name)}\"\\r\\nContent-Type: ${value.type || 'application/octet-stream'}\\r\\n\\r\\n`;\n    chunks.push(textEncoder.encode(header), new Uint8Array(await value.arrayBuffer()), textEncoder.encode('\\r\\n'));\n  }\n\n  chunks.push(textEncoder.encode(`--${boundary}--\\r\\n`));\n  return { body: concatBytes(chunks), contentType: `multipart/form-data; boundary=${boundary}` };\n}\n\nfunction escapeMultipartName(name: string): string {\n  // The escaping the HTML standard prescribes for multipart/form-data names and file names.\n  return name.replaceAll('\"', '%22').replaceAll('\\r', '%0D').replaceAll('\\n', '%0A');\n}\n\nfunction generateRandomHex(): string {\n  return Array.from({ length: BOUNDARY_RANDOM_PART_COUNT }, () => Math.random().toString(HEX_RADIX).slice(RANDOM_PART_START)).join('');\n}\n\nasync function raceWithAbort<T>(promise: Promise<T>, abortSignal: AbortSignal): Promise<T> {\n  let rejectOnAbort: (reason: Error) => void = noop;\n  const abortPromise = new Promise<never>((_resolve, reject) => {\n    rejectOnAbort = reject;\n  });\n  using _abortListener = onAbort(abortSignal, () => {\n    // The reason is whatever the caller aborted with, an `AbortError` or `TimeoutError` by default.\n    rejectOnAbort(abortSignal.reason as Error);\n  });\n  return await Promise.race([promise, abortPromise]);\n}\n\nasync function readStream(stream: ReadableStream<Uint8Array>): Promise<ArrayBuffer> {\n  const reader = stream.getReader();\n  const chunks: Uint8Array[] = [];\n  for (;;) {\n    const result = await reader.read();\n    if (result.done) {\n      break;\n    }\n    chunks.push(result.value);\n  }\n  return concatBytes(chunks);\n}\n\nfunction toHeaderRecord(requestHeaders: Headers | undefined, initHeaders: HeadersInit | undefined): Record<string, string> {\n  const headers = new Headers(requestHeaders);\n  new Headers(initHeaders).forEach((value, name) => {\n    headers.set(name, value);\n  });\n  const record: Record<string, string> = {};\n  headers.forEach((value, name) => {\n    record[name] = value;\n  });\n  return record;\n}\n/* eslint-enable n/no-unsupported-features/node-builtins -- These are Obsidian renderer Web APIs, not Node builtins. */\n"],"mappings":"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","names":[]}

package/dist/lib/esm/setting-components/folder-list-component.d.mts

@@ -0,0 +1,73 @@
+/// <reference path="../library-references.d.mts" />
+/// <reference lib="dom" />
+/**
+ * @file
+ *
+ * Contains a component that edits a reorderable list of folders, with a folder suggest.
+ */
+import type { App, TFolder } from 'obsidian';
+import { AbstractInputSuggest } from 'obsidian';
+import { ListComponent } from './list-component.mjs';
+/**
+ * Suggests the vault's folders, the root included, in an `<input>`, matching the typed text against the folder path.
+ */
+export declare class FolderInputSuggest extends AbstractInputSuggest<TFolder> {
+    /**
+     * The input the suggest completes.
+     */
+    protected readonly inputEl: HTMLInputElement;
+    /**
+     * Creates a new folder suggest.
+     *
+     * @param app - The Obsidian app.
+     * @param inputEl - The input.
+     */
+    constructor(app: App, inputEl: HTMLInputElement);
+    /**
+     * Renders a folder.
+     *
+     * @param folder - The folder.
+     * @param el - The element to render into.
+     */
+    renderSuggestion(folder: TFolder, el: HTMLElement): void;
+    /**
+     * Puts the folder path into the input, dispatches an `input` event, then calls the `onSelect` callback.
+     *
+     * @param folder - The folder.
+     * @param $event - The event that picked it.
+     */
+    selectSuggestion(folder: TFolder, $event: KeyboardEvent | MouseEvent): void;
+    /**
+     * Gets the folders matching the typed text.
+     *
+     * @param query - The typed text.
+     * @returns The folders, best match first.
+     */
+    protected getSuggestions(query: string): TFolder[];
+}
+/**
+ * A {@link ListComponent} of vault folder paths: the add row suggests the vault's folders, and a typed path is
+ * normalized with Obsidian's `normalizePath`, so the root reads as `/`. A path need not exist yet.
+ *
+ * You can add this component using {@link SettingEx.addFolderList}.
+ */
+export declare class FolderListComponent extends ListComponent {
+    /**
+     * The folder suggest attached to {@link ListComponent.newItemInputEl}.
+     */
+    readonly suggest: FolderInputSuggest;
+    /**
+     * Creates a new folder list component.
+     *
+     * @param containerEl - The container element.
+     * @param app - The Obsidian app.
+     */
+    constructor(containerEl: HTMLElement, app: App);
+    /**
+     * Normalizes a typed folder path.
+     *
+     * @param text - The typed text.
+     * @returns The normalized path, or `null` for empty text.
+     */
+    protected normalizeItem(text: string): null | string;
+}