@cadenya/cadenya 0.135.0 → 1.0.0

package/src/internal/qs/utils.ts

@@ -1,265 +0,0 @@
-import { RFC1738 } from './formats';
-import type { DefaultEncoder, Format } from './types';
-import { isArray } from '../utils/values';
-
-export let has = (obj: object, key: PropertyKey): boolean => (
-  (has = (Object as any).hasOwn ?? Function.prototype.call.bind(Object.prototype.hasOwnProperty)),
-  has(obj, key)
-);
-
-const hex_table = /* @__PURE__ */ (() => {
-  const array = [];
-  for (let i = 0; i < 256; ++i) {
-    array.push('%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase());
-  }
-
-  return array;
-})();
-
-function compact_queue<T extends Record<string, any>>(queue: Array<{ obj: T; prop: string }>) {
-  while (queue.length > 1) {
-    const item = queue.pop();
-    if (!item) continue;
-
-    const obj = item.obj[item.prop];
-
-    if (isArray(obj)) {
-      const compacted: unknown[] = [];
-
-      for (let j = 0; j < obj.length; ++j) {
-        if (typeof obj[j] !== 'undefined') {
-          compacted.push(obj[j]);
-        }
-      }
-
-      // @ts-ignore
-      item.obj[item.prop] = compacted;
-    }
-  }
-}
-
-function array_to_object(source: any[], options: { plainObjects: boolean }) {
-  const obj = options && options.plainObjects ? Object.create(null) : {};
-  for (let i = 0; i < source.length; ++i) {
-    if (typeof source[i] !== 'undefined') {
-      obj[i] = source[i];
-    }
-  }
-
-  return obj;
-}
-
-export function merge(
-  target: any,
-  source: any,
-  options: { plainObjects?: boolean; allowPrototypes?: boolean } = {},
-) {
-  if (!source) {
-    return target;
-  }
-
-  if (typeof source !== 'object') {
-    if (isArray(target)) {
-      target.push(source);
-    } else if (target && typeof target === 'object') {
-      if ((options && (options.plainObjects || options.allowPrototypes)) || !has(Object.prototype, source)) {
-        target[source] = true;
-      }
-    } else {
-      return [target, source];
-    }
-
-    return target;
-  }
-
-  if (!target || typeof target !== 'object') {
-    return [target].concat(source);
-  }
-
-  let mergeTarget = target;
-  if (isArray(target) && !isArray(source)) {
-    // @ts-ignore
-    mergeTarget = array_to_object(target, options);
-  }
-
-  if (isArray(target) && isArray(source)) {
-    source.forEach(function (item, i) {
-      if (has(target, i)) {
-        const targetItem = target[i];
-        if (targetItem && typeof targetItem === 'object' && item && typeof item === 'object') {
-          target[i] = merge(targetItem, item, options);
-        } else {
-          target.push(item);
-        }
-      } else {
-        target[i] = item;
-      }
-    });
-    return target;
-  }
-
-  return Object.keys(source).reduce(function (acc, key) {
-    const value = source[key];
-
-    if (has(acc, key)) {
-      acc[key] = merge(acc[key], value, options);
-    } else {
-      acc[key] = value;
-    }
-    return acc;
-  }, mergeTarget);
-}
-
-export function assign_single_source(target: any, source: any) {
-  return Object.keys(source).reduce(function (acc, key) {
-    acc[key] = source[key];
-    return acc;
-  }, target);
-}
-
-export function decode(str: string, _: any, charset: string) {
-  const strWithoutPlus = str.replace(/\+/g, ' ');
-  if (charset === 'iso-8859-1') {
-    // unescape never throws, no try...catch needed:
-    return strWithoutPlus.replace(/%[0-9a-f]{2}/gi, unescape);
-  }
-  // utf-8
-  try {
-    return decodeURIComponent(strWithoutPlus);
-  } catch (e) {
-    return strWithoutPlus;
-  }
-}
-
-const limit = 1024;
-
-export const encode: (
-  str: any,
-  defaultEncoder: DefaultEncoder,
-  charset: string,
-  type: 'key' | 'value',
-  format: Format,
-) => string = (str, _defaultEncoder, charset, _kind, format: Format) => {
-  // This code was originally written by Brian White for the io.js core querystring library.
-  // It has been adapted here for stricter adherence to RFC 3986
-  if (str.length === 0) {
-    return str;
-  }
-
-  let string = str;
-  if (typeof str === 'symbol') {
-    string = Symbol.prototype.toString.call(str);
-  } else if (typeof str !== 'string') {
-    string = String(str);
-  }
-
-  if (charset === 'iso-8859-1') {
-    return escape(string).replace(/%u[0-9a-f]{4}/gi, function ($0) {
-      return '%26%23' + parseInt($0.slice(2), 16) + '%3B';
-    });
-  }
-
-  let out = '';
-  for (let j = 0; j < string.length; j += limit) {
-    const segment = string.length >= limit ? string.slice(j, j + limit) : string;
-    const arr = [];
-
-    for (let i = 0; i < segment.length; ++i) {
-      let c = segment.charCodeAt(i);
-      if (
-        c === 0x2d || // -
-        c === 0x2e || // .
-        c === 0x5f || // _
-        c === 0x7e || // ~
-        (c >= 0x30 && c <= 0x39) || // 0-9
-        (c >= 0x41 && c <= 0x5a) || // a-z
-        (c >= 0x61 && c <= 0x7a) || // A-Z
-        (format === RFC1738 && (c === 0x28 || c === 0x29)) // ( )
-      ) {
-        arr[arr.length] = segment.charAt(i);
-        continue;
-      }
-
-      if (c < 0x80) {
-        arr[arr.length] = hex_table[c];
-        continue;
-      }
-
-      if (c < 0x800) {
-        arr[arr.length] = hex_table[0xc0 | (c >> 6)]! + hex_table[0x80 | (c & 0x3f)];
-        continue;
-      }
-
-      if (c < 0xd800 || c >= 0xe000) {
-        arr[arr.length] =
-          hex_table[0xe0 | (c >> 12)]! + hex_table[0x80 | ((c >> 6) & 0x3f)] + hex_table[0x80 | (c & 0x3f)];
-        continue;
-      }
-
-      i += 1;
-      c = 0x10000 + (((c & 0x3ff) << 10) | (segment.charCodeAt(i) & 0x3ff));
-
-      arr[arr.length] =
-        hex_table[0xf0 | (c >> 18)]! +
-        hex_table[0x80 | ((c >> 12) & 0x3f)] +
-        hex_table[0x80 | ((c >> 6) & 0x3f)] +
-        hex_table[0x80 | (c & 0x3f)];
-    }
-
-    out += arr.join('');
-  }
-
-  return out;
-};
-
-export function compact(value: any) {
-  const queue = [{ obj: { o: value }, prop: 'o' }];
-  const refs = [];
-
-  for (let i = 0; i < queue.length; ++i) {
-    const item = queue[i];
-    // @ts-ignore
-    const obj = item.obj[item.prop];
-
-    const keys = Object.keys(obj);
-    for (let j = 0; j < keys.length; ++j) {
-      const key = keys[j]!;
-      const val = obj[key];
-      if (typeof val === 'object' && val !== null && refs.indexOf(val) === -1) {
-        queue.push({ obj: obj, prop: key });
-        refs.push(val);
-      }
-    }
-  }
-
-  compact_queue(queue);
-
-  return value;
-}
-
-export function is_regexp(obj: any) {
-  return Object.prototype.toString.call(obj) === '[object RegExp]';
-}
-
-export function is_buffer(obj: any) {
-  if (!obj || typeof obj !== 'object') {
-    return false;
-  }
-
-  return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
-}
-
-export function combine(a: any, b: any) {
-  return [].concat(a, b);
-}
-
-export function maybe_map<T>(val: T[], fn: (v: T) => T) {
-  if (isArray(val)) {
-    const mapped = [];
-    for (let i = 0; i < val.length; i += 1) {
-      mapped.push(fn(val[i]!));
-    }
-    return mapped;
-  }
-  return fn(val);
-}

package/src/internal/request-options.ts

@@ -1,91 +0,0 @@
-import { NullableHeaders } from './headers';
-
-import type { BodyInit } from './builtin-types';
-import { Stream } from '../core/streaming';
-import type { HTTPMethod, MergedRequestInit } from './types';
-import { type HeadersLike } from './headers';
-
-export type FinalRequestOptions = RequestOptions & { method: HTTPMethod; path: string };
-
-export type RequestOptions = {
-  /**
-   * The HTTP method for the request (e.g., 'get', 'post', 'put', 'delete').
-   */
-  method?: HTTPMethod;
-
-  /**
-   * The URL path for the request.
-   *
-   * @example "/v1/foo"
-   */
-  path?: string;
-
-  /**
-   * Query parameters to include in the request URL.
-   */
-  query?: object | undefined | null;
-
-  /**
-   * The request body. Can be a string, JSON object, FormData, or other supported types.
-   */
-  body?: unknown;
-
-  /**
-   * HTTP headers to include with the request. Can be a Headers object, plain object, or array of tuples.
-   */
-  headers?: HeadersLike;
-
-  /**
-   * The maximum number of times that the client will retry a request in case of a
-   * temporary failure, like a network error or a 5XX error from the server.
-   *
-   * @default 0
-   */
-  maxRetries?: number;
-
-  stream?: boolean | undefined;
-
-  /**
-   * The maximum amount of time (in milliseconds) that the client should wait for a response
-   * from the server before timing out a single request.
-   *
-   * @unit milliseconds
-   */
-  timeout?: number;
-
-  /**
-   * Additional `RequestInit` options to be passed to the underlying `fetch` call.
-   * These options will be merged with the client's default fetch options.
-   */
-  fetchOptions?: MergedRequestInit;
-
-  /**
-   * An AbortSignal that can be used to cancel the request.
-   */
-  signal?: AbortSignal | undefined | null;
-
-  /**
-   * A unique key for this request to enable idempotency.
-   */
-  idempotencyKey?: string;
-
-  /**
-   * Override the default base URL for this specific request.
-   */
-  defaultBaseURL?: string | undefined;
-
-  __binaryResponse?: boolean | undefined;
-  __streamClass?: typeof Stream;
-};
-
-export type EncodedContent = { bodyHeaders: HeadersLike; body: BodyInit };
-export type RequestEncoder = (request: { headers: NullableHeaders; body: unknown }) => EncodedContent;
-
-export const FallbackEncoder: RequestEncoder = ({ headers, body }) => {
-  return {
-    bodyHeaders: {
-      'content-type': 'application/json',
-    },
-    body: JSON.stringify(body),
-  };
-};

package/src/internal/shim-types.ts

@@ -1,24 +0,0 @@
-/**
- * Shims for types that we can't always rely on being available globally.
- *
- * Note: these only exist at the type-level, there is no corresponding runtime
- * version for any of these symbols.
- */
-
-type NeverToAny<T> = T extends never ? any : T;
-
-/** @ts-ignore */
-type _DOMReadableStream<R = any> = globalThis.ReadableStream<R>;
-
-/** @ts-ignore */
-type _NodeReadableStream<R = any> = import('stream/web').ReadableStream<R>;
-
-type _ConditionalNodeReadableStream<R = any> =
-  typeof globalThis extends { ReadableStream: any } ? never : _NodeReadableStream<R>;
-
-type _ReadableStream<R = any> = NeverToAny<
-  | ([0] extends [1 & _DOMReadableStream<R>] ? never : _DOMReadableStream<R>)
-  | ([0] extends [1 & _ConditionalNodeReadableStream<R>] ? never : _ConditionalNodeReadableStream<R>)
->;
-
-export type { _ReadableStream as ReadableStream };

package/src/internal/shims.ts

@@ -1,105 +0,0 @@
-/**
- * This module provides internal shims and utility functions for environments where certain Node.js or global types may not be available.
- *
- * These are used to ensure we can provide a consistent behaviour between different JavaScript environments and good error
- * messages in cases where an environment isn't fully supported.
- */
-
-import type { Fetch } from './builtin-types';
-import type { ReadableStream } from './shim-types';
-
-export function getDefaultFetch(): Fetch {
-  if (typeof fetch !== 'undefined') {
-    return fetch as any;
-  }
-
-  throw new Error(
-    '`fetch` is not defined as a global; Either pass `fetch` to the client, `new Cadenya({ fetch })` or polyfill the global, `globalThis.fetch = fetch`',
-  );
-}
-
-type ReadableStreamArgs = ConstructorParameters<typeof ReadableStream>;
-
-export function makeReadableStream(...args: ReadableStreamArgs): ReadableStream {
-  const ReadableStream = (globalThis as any).ReadableStream;
-  if (typeof ReadableStream === 'undefined') {
-    // Note: All of the platforms / runtimes we officially support already define
-    // `ReadableStream` as a global, so this should only ever be hit on unsupported runtimes.
-    throw new Error(
-      '`ReadableStream` is not defined as a global; You will need to polyfill it, `globalThis.ReadableStream = ReadableStream`',
-    );
-  }
-
-  return new ReadableStream(...args);
-}
-
-export function ReadableStreamFrom<T>(iterable: Iterable<T> | AsyncIterable<T>): ReadableStream<T> {
-  let iter: AsyncIterator<T> | Iterator<T> =
-    Symbol.asyncIterator in iterable ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator]();
-
-  return makeReadableStream({
-    start() {},
-    async pull(controller: any) {
-      const { done, value } = await iter.next();
-      if (done) {
-        controller.close();
-      } else {
-        controller.enqueue(value);
-      }
-    },
-    async cancel() {
-      await iter.return?.();
-    },
-  });
-}
-
-/**
- * Most browsers don't yet have async iterable support for ReadableStream,
- * and Node has a very different way of reading bytes from its "ReadableStream".
- *
- * This polyfill was pulled from https://github.com/MattiasBuelens/web-streams-polyfill/pull/122#issuecomment-1627354490
- */
-export function ReadableStreamToAsyncIterable<T>(stream: any): AsyncIterableIterator<T> {
-  if (stream[Symbol.asyncIterator]) return stream;
-
-  const reader = stream.getReader();
-  return {
-    async next() {
-      try {
-        const result = await reader.read();
-        if (result?.done) reader.releaseLock(); // release lock when stream becomes closed
-        return result;
-      } catch (e) {
-        reader.releaseLock(); // release lock when stream becomes errored
-        throw e;
-      }
-    },
-    async return() {
-      const cancelPromise = reader.cancel();
-      reader.releaseLock();
-      await cancelPromise;
-      return { done: true, value: undefined };
-    },
-    [Symbol.asyncIterator]() {
-      return this;
-    },
-  };
-}
-
-/**
- * Cancels a ReadableStream we don't need to consume.
- * See https://undici.nodejs.org/#/?id=garbage-collection
- */
-export async function CancelReadableStream(stream: any): Promise<void> {
-  if (stream === null || typeof stream !== 'object') return;
-
-  if (stream[Symbol.asyncIterator]) {
-    await stream[Symbol.asyncIterator]().return?.();
-    return;
-  }
-
-  const reader = stream.getReader();
-  const cancelPromise = reader.cancel();
-  reader.releaseLock();
-  await cancelPromise;
-}

package/src/internal/to-file.ts

@@ -1,154 +0,0 @@
-import { BlobPart, getName, makeFile, isAsyncIterable } from './uploads';
-import type { FilePropertyBag } from './builtin-types';
-import { checkFileSupport } from './uploads';
-
-type BlobLikePart = string | ArrayBuffer | ArrayBufferView | BlobLike | DataView;
-
-/**
- * Intended to match DOM Blob, node-fetch Blob, node:buffer Blob, etc.
- * Don't add arrayBuffer here, node-fetch doesn't have it
- */
-interface BlobLike {
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/size) */
-  readonly size: number;
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/type) */
-  readonly type: string;
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/text) */
-  text(): Promise<string>;
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/slice) */
-  slice(start?: number, end?: number): BlobLike;
-}
-
-/**
- * This check adds the arrayBuffer() method type because it is available and used at runtime
- */
-const isBlobLike = (value: any): value is BlobLike & { arrayBuffer(): Promise<ArrayBuffer> } =>
-  value != null &&
-  typeof value === 'object' &&
-  typeof value.size === 'number' &&
-  typeof value.type === 'string' &&
-  typeof value.text === 'function' &&
-  typeof value.slice === 'function' &&
-  typeof value.arrayBuffer === 'function';
-
-/**
- * Intended to match DOM File, node:buffer File, undici File, etc.
- */
-interface FileLike extends BlobLike {
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/File/lastModified) */
-  readonly lastModified: number;
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/File/name) */
-  readonly name?: string | undefined;
-}
-
-/**
- * This check adds the arrayBuffer() method type because it is available and used at runtime
- */
-const isFileLike = (value: any): value is FileLike & { arrayBuffer(): Promise<ArrayBuffer> } =>
-  value != null &&
-  typeof value === 'object' &&
-  typeof value.name === 'string' &&
-  typeof value.lastModified === 'number' &&
-  isBlobLike(value);
-
-/**
- * Intended to match DOM Response, node-fetch Response, undici Response, etc.
- */
-export interface ResponseLike {
-  url: string;
-  blob(): Promise<BlobLike>;
-}
-
-const isResponseLike = (value: any): value is ResponseLike =>
-  value != null &&
-  typeof value === 'object' &&
-  typeof value.url === 'string' &&
-  typeof value.blob === 'function';
-
-export type ToFileInput =
-  | FileLike
-  | ResponseLike
-  | Exclude<BlobLikePart, string>
-  | AsyncIterable<BlobLikePart>;
-
-/**
- * Helper for creating a {@link File} to pass to an SDK upload method from a variety of different data formats
- * @param value the raw content of the file. Can be an {@link Uploadable}, BlobLikePart, or AsyncIterable of BlobLikeParts
- * @param {string=} name the name of the file. If omitted, toFile will try to determine a file name from bits if possible
- * @param {Object=} options additional properties
- * @param {string=} options.type the MIME type of the content
- * @param {number=} options.lastModified the last modified timestamp
- * @returns a {@link File} with the given properties
- */
-export async function toFile(
-  value: ToFileInput | PromiseLike<ToFileInput>,
-  name?: string | null | undefined,
-  options?: FilePropertyBag | undefined,
-): Promise<File> {
-  checkFileSupport();
-
-  // If it's a promise, resolve it.
-  value = await value;
-
-  // If we've been given a `File` we don't need to do anything
-  if (isFileLike(value)) {
-    if (value instanceof File) {
-      return value;
-    }
-    return makeFile([await value.arrayBuffer()], value.name);
-  }
-
-  if (isResponseLike(value)) {
-    const blob = await value.blob();
-    name ||= new URL(value.url).pathname.split(/[\\/]/).pop();
-
-    return makeFile(await getBytes(blob), name, options);
-  }
-
-  const parts = await getBytes(value);
-
-  name ||= getName(value);
-
-  if (!options?.type) {
-    const type = parts.find((part) => typeof part === 'object' && 'type' in part && part.type);
-    if (typeof type === 'string') {
-      options = { ...options, type };
-    }
-  }
-
-  return makeFile(parts, name, options);
-}
-
-async function getBytes(value: BlobLikePart | AsyncIterable<BlobLikePart>): Promise<Array<BlobPart>> {
-  let parts: Array<BlobPart> = [];
-  if (
-    typeof value === 'string' ||
-    ArrayBuffer.isView(value) || // includes Uint8Array, Buffer, etc.
-    value instanceof ArrayBuffer
-  ) {
-    parts.push(value);
-  } else if (isBlobLike(value)) {
-    parts.push(value instanceof Blob ? value : await value.arrayBuffer());
-  } else if (
-    isAsyncIterable(value) // includes Readable, ReadableStream, etc.
-  ) {
-    for await (const chunk of value) {
-      parts.push(...(await getBytes(chunk as BlobLikePart))); // TODO, consider validating?
-    }
-  } else {
-    const constructor = value?.constructor?.name;
-    throw new Error(
-      `Unexpected data type: ${typeof value}${
-        constructor ? `; constructor: ${constructor}` : ''
-      }${propsForError(value)}`,
-    );
-  }
-
-  return parts;
-}
-
-function propsForError(value: unknown): string {
-  if (typeof value !== 'object' || value === null) return '';
-  const props = Object.getOwnPropertyNames(value);
-  return `; props: [${props.map((p) => `"${p}"`).join(', ')}]`;
-}