structured-outputs 0.1.0-beta.2 → 0.1.0-beta.20

package/src/deps/jsr.io/@std/assert/1.0.8/rejects.ts

@@ -0,0 +1,123 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { AssertionError } from "./assertion_error.js";
+import { assertIsError } from "./is_error.js";
+
+/**
+ * Executes a function which returns a promise, expecting it to reject.
+ *
+ * To assert that a synchronous function throws, use {@linkcode assertThrows}.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertRejects } from "@std/assert";
+ *
+ * await assertRejects(async () => Promise.reject(new Error())); // Doesn't throw
+ * await assertRejects(async () => console.log("Hello world")); // Throws
+ * ```
+ *
+ * @param fn The function to execute.
+ * @param msg The optional message to display if the assertion fails.
+ * @returns The promise which resolves to the thrown error.
+ */
+export function assertRejects(
+  fn: () => PromiseLike<unknown>,
+  msg?: string,
+): Promise<unknown>;
+/**
+ * Executes a function which returns a promise, expecting it to reject.
+ * If it does not, then it throws. An error class and a string that should be
+ * included in the error message can also be asserted.
+ *
+ * To assert that a synchronous function throws, use {@linkcode assertThrows}.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertRejects } from "@std/assert";
+ *
+ * await assertRejects(async () => Promise.reject(new Error()), Error); // Doesn't throw
+ * await assertRejects(async () => Promise.reject(new Error()), SyntaxError); // Throws
+ * ```
+ *
+ * @typeParam E The error class to assert.
+ * @param fn The function to execute.
+ * @param ErrorClass The error class to assert.
+ * @param msgIncludes The string that should be included in the error message.
+ * @param msg The optional message to display if the assertion fails.
+ * @returns The promise which resolves to the thrown error.
+ */
+export function assertRejects<E extends Error = Error>(
+  fn: () => PromiseLike<unknown>,
+  // deno-lint-ignore no-explicit-any
+  ErrorClass: abstract new (...args: any[]) => E,
+  msgIncludes?: string,
+  msg?: string,
+): Promise<E>;
+export async function assertRejects<E extends Error = Error>(
+  fn: () => PromiseLike<unknown>,
+  errorClassOrMsg?:
+    // deno-lint-ignore no-explicit-any
+    | (abstract new (...args: any[]) => E)
+    | string,
+  msgIncludesOrMsg?: string,
+  msg?: string,
+): Promise<E | Error | unknown> {
+  // deno-lint-ignore no-explicit-any
+  let ErrorClass: (abstract new (...args: any[]) => E) | undefined;
+  let msgIncludes: string | undefined;
+  let err;
+
+  if (typeof errorClassOrMsg !== "string") {
+    if (
+      errorClassOrMsg === undefined ||
+      errorClassOrMsg.prototype instanceof Error ||
+      errorClassOrMsg.prototype === Error.prototype
+    ) {
+      ErrorClass = errorClassOrMsg;
+      msgIncludes = msgIncludesOrMsg;
+    }
+  } else {
+    msg = errorClassOrMsg;
+  }
+  let doesThrow = false;
+  let isPromiseReturned = false;
+  const msgSuffix = msg ? `: ${msg}` : ".";
+  try {
+    const possiblePromise = fn();
+    if (
+      possiblePromise &&
+      typeof possiblePromise === "object" &&
+      typeof possiblePromise.then === "function"
+    ) {
+      isPromiseReturned = true;
+      await possiblePromise;
+    } else {
+      throw new Error();
+    }
+  } catch (error) {
+    if (!isPromiseReturned) {
+      throw new AssertionError(
+        `Function throws when expected to reject${msgSuffix}`,
+      );
+    }
+    if (ErrorClass) {
+      if (!(error instanceof Error)) {
+        throw new AssertionError(`A non-Error object was rejected${msgSuffix}`);
+      }
+      assertIsError(
+        error,
+        ErrorClass,
+        msgIncludes,
+        msg,
+      );
+    }
+    err = error;
+    doesThrow = true;
+  }
+  if (!doesThrow) {
+    throw new AssertionError(
+      `Expected function to reject${msgSuffix}`,
+    );
+  }
+  return err;
+}

package/src/deps/jsr.io/@std/assert/1.0.8/strict_equals.ts

@@ -0,0 +1,67 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { buildMessage } from "../../internal/1.0.5/build_message.js";
+import { diff } from "../../internal/1.0.5/diff.js";
+import { diffStr } from "../../internal/1.0.5/diff_str.js";
+import { format } from "../../internal/1.0.5/format.js";
+import { red } from "../../internal/1.0.5/styles.js";
+import { AssertionError } from "./assertion_error.js";
+
+/**
+ * Make an assertion that `actual` and `expected` are strictly equal, using
+ * {@linkcode Object.is} for equality comparison. If not, then throw.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertStrictEquals } from "@std/assert";
+ *
+ * const a = {};
+ * const b = a;
+ * assertStrictEquals(a, b); // Doesn't throw
+ *
+ * const c = {};
+ * const d = {};
+ * assertStrictEquals(c, d); // Throws
+ * ```
+ *
+ * @typeParam T The type of the expected value.
+ * @param actual The actual value to compare.
+ * @param expected The expected value to compare.
+ * @param msg The optional message to display if the assertion fails.
+ */
+export function assertStrictEquals<T>(
+  actual: unknown,
+  expected: T,
+  msg?: string,
+): asserts actual is T {
+  if (Object.is(actual, expected)) {
+    return;
+  }
+
+  const msgSuffix = msg ? `: ${msg}` : ".";
+  let message: string;
+
+  const actualString = format(actual);
+  const expectedString = format(expected);
+
+  if (actualString === expectedString) {
+    const withOffset = actualString
+      .split("\n")
+      .map((l) => `    ${l}`)
+      .join("\n");
+    message =
+      `Values have the same structure but are not reference-equal${msgSuffix}\n\n${
+        red(withOffset)
+      }\n`;
+  } else {
+    const stringDiff = (typeof actual === "string") &&
+      (typeof expected === "string");
+    const diffResult = stringDiff
+      ? diffStr(actual as string, expected as string)
+      : diff(actualString.split("\n"), expectedString.split("\n"));
+    const diffMsg = buildMessage(diffResult, { stringDiff }).join("\n");
+    message = `Values are not strictly equal${msgSuffix}\n${diffMsg}`;
+  }
+
+  throw new AssertionError(message);
+}

package/src/deps/jsr.io/@std/assert/1.0.8/string_includes.ts

@@ -0,0 +1,30 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { AssertionError } from "./assertion_error.js";
+
+/**
+ * Make an assertion that actual includes expected. If not
+ * then throw.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertStringIncludes } from "@std/assert";
+ *
+ * assertStringIncludes("Hello", "ello"); // Doesn't throw
+ * assertStringIncludes("Hello", "world"); // Throws
+ * ```
+ *
+ * @param actual The actual string to check for inclusion.
+ * @param expected The expected string to check for inclusion.
+ * @param msg The optional message to display if the assertion fails.
+ */
+export function assertStringIncludes(
+  actual: string,
+  expected: string,
+  msg?: string,
+) {
+  if (actual.includes(expected)) return;
+  const msgSuffix = msg ? `: ${msg}` : ".";
+  msg = `Expected actual: "${actual}" to contain: "${expected}"${msgSuffix}`;
+  throw new AssertionError(msg);
+}

package/src/deps/jsr.io/@std/assert/1.0.8/throws.ts

@@ -0,0 +1,111 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { assertIsError } from "./is_error.js";
+import { AssertionError } from "./assertion_error.js";
+
+/**
+ * Executes a function, expecting it to throw. If it does not, then it
+ * throws.
+ *
+ * To assert that an asynchronous function rejects, use
+ * {@linkcode assertRejects}.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertThrows } from "@std/assert";
+ *
+ * assertThrows(() => { throw new TypeError("hello world!"); }); // Doesn't throw
+ * assertThrows(() => console.log("hello world!")); // Throws
+ * ```
+ *
+ * @param fn The function to execute.
+ * @param msg The optional message to display if the assertion fails.
+ * @returns The error that was thrown.
+ */
+export function assertThrows(
+  fn: () => unknown,
+  msg?: string,
+): unknown;
+/**
+ * Executes a function, expecting it to throw. If it does not, then it
+ * throws. An error class and a string that should be included in the
+ * error message can also be asserted.
+ *
+ * To assert that an asynchronous function rejects, use
+ * {@linkcode assertRejects}.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertThrows } from "@std/assert";
+ *
+ * assertThrows(() => { throw new TypeError("hello world!"); }, TypeError); // Doesn't throw
+ * assertThrows(() => { throw new TypeError("hello world!"); }, RangeError); // Throws
+ * ```
+ *
+ * @typeParam E The error class to assert.
+ * @param fn The function to execute.
+ * @param ErrorClass The error class to assert.
+ * @param msgIncludes The string that should be included in the error message.
+ * @param msg The optional message to display if the assertion fails.
+ * @returns The error that was thrown.
+ */
+export function assertThrows<E extends Error = Error>(
+  fn: () => unknown,
+  // deno-lint-ignore no-explicit-any
+  ErrorClass: abstract new (...args: any[]) => E,
+  msgIncludes?: string,
+  msg?: string,
+): E;
+export function assertThrows<E extends Error = Error>(
+  fn: () => unknown,
+  errorClassOrMsg?:
+    // deno-lint-ignore no-explicit-any
+    | (abstract new (...args: any[]) => E)
+    | string,
+  msgIncludesOrMsg?: string,
+  msg?: string,
+): E | Error | unknown {
+  // deno-lint-ignore no-explicit-any
+  let ErrorClass: (abstract new (...args: any[]) => E) | undefined;
+  let msgIncludes: string | undefined;
+  let err;
+
+  if (typeof errorClassOrMsg !== "string") {
+    if (
+      errorClassOrMsg === undefined ||
+      errorClassOrMsg?.prototype instanceof Error ||
+      errorClassOrMsg?.prototype === Error.prototype
+    ) {
+      ErrorClass = errorClassOrMsg;
+      msgIncludes = msgIncludesOrMsg;
+    } else {
+      msg = msgIncludesOrMsg;
+    }
+  } else {
+    msg = errorClassOrMsg;
+  }
+  let doesThrow = false;
+  const msgSuffix = msg ? `: ${msg}` : ".";
+  try {
+    fn();
+  } catch (error) {
+    if (ErrorClass) {
+      if (error instanceof Error === false) {
+        throw new AssertionError(`A non-Error object was thrown${msgSuffix}`);
+      }
+      assertIsError(
+        error,
+        ErrorClass,
+        msgIncludes,
+        msg,
+      );
+    }
+    err = error;
+    doesThrow = true;
+  }
+  if (!doesThrow) {
+    msg = `Expected function to throw${msgSuffix}`;
+    throw new AssertionError(msg);
+  }
+  return err;
+}

package/src/deps/jsr.io/@std/assert/1.0.8/unimplemented.ts

@@ -0,0 +1,21 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { AssertionError } from "./assertion_error.js";
+
+/**
+ * Use this to stub out methods that will throw when invoked.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { unimplemented } from "@std/assert";
+ *
+ * unimplemented(); // Throws
+ * ```
+ *
+ * @param msg Optional message to include in the error.
+ * @returns Never returns, always throws.
+ */
+export function unimplemented(msg?: string): never {
+  const msgSuffix = msg ? `: ${msg}` : ".";
+  throw new AssertionError(`Unimplemented${msgSuffix}`);
+}

package/src/deps/jsr.io/@std/assert/1.0.8/unreachable.ts

@@ -0,0 +1,21 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { AssertionError } from "./assertion_error.js";
+
+/**
+ * Use this to assert unreachable code.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { unreachable } from "@std/assert";
+ *
+ * unreachable(); // Throws
+ * ```
+ *
+ * @param msg Optional message to include in the error.
+ * @returns Never returns, always throws.
+ */
+export function unreachable(msg?: string): never {
+  const msgSuffix = msg ? `: ${msg}` : ".";
+  throw new AssertionError(`Unreachable${msgSuffix}`);
+}

package/src/deps/jsr.io/@std/collections/1.0.9/_utils.ts

@@ -0,0 +1,26 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Filters the given array, removing all elements that do not match the given predicate
+ * **in place. This means `array` will be modified!**.
+ */
+export function filterInPlace<T>(
+  array: Array<T>,
+  predicate: (el: T) => boolean,
+): Array<T> {
+  let outputIndex = 0;
+
+  for (const cur of array) {
+    if (!predicate(cur)) {
+      continue;
+    }
+
+    array[outputIndex] = cur;
+    outputIndex += 1;
+  }
+
+  array.splice(outputIndex);
+
+  return array;
+}

package/src/deps/jsr.io/@std/collections/1.0.9/aggregate_groups.ts

@@ -0,0 +1,62 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+import { mapEntries } from "./map_entries.js";
+
+/**
+ * Applies the given aggregator to each group in the given grouping, returning the
+ * results together with the respective group keys
+ *
+ * @typeParam T Type of the values in the input record.
+ * @typeParam A Type of the accumulator value, which will match the returned
+ * record's values.
+ *
+ * @param record The grouping to aggregate.
+ * @param aggregator The function to apply to each group.
+ *
+ * @returns A record with the same keys as the input record, but with the values
+ * being the result of applying the aggregator to each group.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { aggregateGroups } from "@std/collections/aggregate-groups";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const foodProperties = {
+ *   Curry: ["spicy", "vegan"],
+ *   Omelette: ["creamy", "vegetarian"],
+ * };
+ *
+ * const descriptions = aggregateGroups(
+ *   foodProperties,
+ *   (current, key, first, acc) => {
+ *     return first
+ *       ? `${key} is ${current}`
+ *       : `${acc} and ${current}`;
+ *   },
+ * );
+ *
+ * assertEquals(descriptions, {
+ *   Curry: "Curry is spicy and vegan",
+ *   Omelette: "Omelette is creamy and vegetarian",
+ * });
+ * ```
+ */
+export function aggregateGroups<T, A>(
+  record: Readonly<Record<string, ReadonlyArray<T>>>,
+  aggregator: (current: T, key: string, first: boolean, accumulator?: A) => A,
+): Record<string, A> {
+  return mapEntries(
+    record,
+    ([key, values]) => [
+      key,
+      // Need the type assertions here because the reduce type does not support
+      // the type transition we need
+      values.reduce(
+        (accumulator, current, currentIndex) =>
+          aggregator(current, key, currentIndex === 0, accumulator),
+        undefined as A | undefined,
+      ) as A,
+    ],
+  );
+}

package/src/deps/jsr.io/@std/collections/1.0.9/associate_by.ts

@@ -0,0 +1,50 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Creates a record by associating each element of the input array with a key
+ * generated by the selector function.
+ *
+ * If the selector produces the same key for multiple elements, the latest one
+ * will be used (overriding the ones before it).
+ *
+ * @typeParam T Type of the elements in the input array.
+ *
+ * @param array The array to transform.
+ * @param selector The function to extract the key from each element.
+ *
+ * @returns A record with the keys produced by the selector and the elements as
+ * values.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { associateBy } from "@std/collections/associate-by";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const users = [
+ *   { id: "a2e", userName: "Anna" },
+ *   { id: "5f8", userName: "Arnold" },
+ *   { id: "d2c", userName: "Kim" },
+ * ];
+ *
+ * const usersById = associateBy(users, (user) => user.id);
+ *
+ * assertEquals(usersById, {
+ *   "a2e": { id: "a2e", userName: "Anna" },
+ *   "5f8": { id: "5f8", userName: "Arnold" },
+ *   "d2c": { id: "d2c", userName: "Kim" },
+ * });
+ * ```
+ */
+export function associateBy<T>(
+  array: Iterable<T>,
+  selector: (el: T) => string,
+): Record<string, T> {
+  const result: Record<string, T> = {};
+
+  for (const element of array) {
+    result[selector(element)] = element;
+  }
+
+  return result;
+}

package/src/deps/jsr.io/@std/collections/1.0.9/associate_with.ts

@@ -0,0 +1,46 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Associates each string element of an array with a value returned by a selector
+ * function.
+ *
+ * If any of two pairs would have the same value, the latest one will be used
+ * (overriding the ones before it).
+ *
+ * @typeParam T The type of the values returned by the selector function.
+ *
+ * @param array The array of elements to associate with values.
+ * @param selector The selector function that returns a value for each element.
+ *
+ * @returns An object where each element of the array is associated with a value
+ * returned by the selector function.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { associateWith } from "@std/collections/associate-with";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const names = ["Kim", "Lara", "Jonathan"];
+ *
+ * const namesToLength = associateWith(names, (person) => person.length);
+ *
+ * assertEquals(namesToLength, {
+ *   "Kim": 3,
+ *   "Lara": 4,
+ *   "Jonathan": 8,
+ * });
+ * ```
+ */
+export function associateWith<T>(
+  array: Iterable<string>,
+  selector: (key: string) => T,
+): Record<string, T> {
+  const result: Record<string, T> = {};
+
+  for (const element of array) {
+    result[element] = selector(element);
+  }
+
+  return result;
+}

package/src/deps/jsr.io/@std/collections/1.0.9/chunk.ts

@@ -0,0 +1,56 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Splits the given array into chunks of the given size and returns them.
+ *
+ * @typeParam T Type of the elements in the input array.
+ *
+ * @param array The array to split into chunks.
+ * @param size The size of the chunks. This must be a positive integer.
+ *
+ * @returns An array of chunks of the given size.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { chunk } from "@std/collections/chunk";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const words = [
+ *   "lorem",
+ *   "ipsum",
+ *   "dolor",
+ *   "sit",
+ *   "amet",
+ *   "consetetur",
+ *   "sadipscing",
+ * ];
+ * const chunks = chunk(words, 3);
+ *
+ * assertEquals(
+ *   chunks,
+ *   [
+ *     ["lorem", "ipsum", "dolor"],
+ *     ["sit", "amet", "consetetur"],
+ *     ["sadipscing"],
+ *   ],
+ * );
+ * ```
+ */
+export function chunk<T>(array: readonly T[], size: number): T[][] {
+  if (size <= 0 || !Number.isInteger(size)) {
+    throw new RangeError(
+      `Expected size to be an integer greater than 0 but found ${size}`,
+    );
+  }
+
+  const result: T[][] = [];
+  let index = 0;
+
+  while (index < array.length) {
+    result.push(array.slice(index, index + size));
+    index += size;
+  }
+
+  return result;
+}