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

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

@@ -0,0 +1,42 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Returns all elements in the given array that produce a distinct value using
+ * the given selector, preserving order by first occurrence.
+ *
+ * @typeParam T The type of the elements in the input array.
+ * @typeParam D The type of the values produced by the selector function.
+ *
+ * @param array The array to filter for distinct elements.
+ * @param selector The function to extract the value to compare for
+ * distinctness.
+ *
+ * @returns An array of distinct elements in the input array.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { distinctBy } from "@std/collections/distinct-by";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const names = ["Anna", "Kim", "Arnold", "Kate"];
+ * const exampleNamesByFirstLetter = distinctBy(names, (name) => name.charAt(0));
+ *
+ * assertEquals(exampleNamesByFirstLetter, ["Anna", "Kim"]);
+ * ```
+ */
+export function distinctBy<T, D>(
+  array: Iterable<T>,
+  selector: (el: T) => D,
+): T[] {
+  const selectedValues = new Set<D>();
+  const result: T[] = [];
+  for (const element of array) {
+    const selected = selector(element);
+    if (!selectedValues.has(selected)) {
+      selectedValues.add(selected);
+      result.push(element);
+    }
+  }
+  return result;
+}

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

@@ -0,0 +1,36 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Returns a new array that drops all elements in the given collection until the
+ * last element that does not match the given predicate.
+ *
+ * @typeParam T The type of the elements in the input array.
+ *
+ * @param array The array to drop elements from.
+ * @param predicate The function to test each element for a condition.
+ *
+ * @returns A new array that drops all elements until the last element that does
+ * not match the given predicate.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { dropLastWhile } from "@std/collections/drop-last-while";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const numbers = [11, 42, 55, 20, 33, 44];
+ *
+ * const notFortyFour = dropLastWhile(numbers, (number) => number > 30);
+ *
+ * assertEquals(notFortyFour, [11, 42, 55, 20]);
+ * ```
+ */
+export function dropLastWhile<T>(
+  array: readonly T[],
+  predicate: (el: T) => boolean,
+): T[] {
+  let offset = array.length;
+  while (0 < offset && predicate(array[offset - 1] as T)) offset--;
+
+  return array.slice(0, offset);
+}

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

@@ -0,0 +1,39 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Returns a new array that drops all elements in the given collection until the
+ * first element that does not match the given predicate.
+ *
+ * @typeParam T The type of the elements in the input array.
+ *
+ * @param array The array to drop elements from.
+ * @param predicate The function to test each element for a condition.
+ *
+ * @returns A new array that drops all elements until the first element that
+ * does not match the given predicate.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { dropWhile } from "@std/collections/drop-while";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const numbers = [3, 2, 5, 2, 5];
+ * const dropWhileNumbers = dropWhile(numbers, (number) => number !== 2);
+ *
+ * assertEquals(dropWhileNumbers, [2, 5, 2, 5]);
+ * ```
+ */
+export function dropWhile<T>(
+  array: readonly T[],
+  predicate: (el: T) => boolean,
+): T[] {
+  let offset = 0;
+  const length = array.length;
+
+  while (length > offset && predicate(array[offset] as T)) {
+    offset++;
+  }
+
+  return array.slice(offset, length);
+}

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

@@ -0,0 +1,48 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Returns a new record with all entries of the given record except the ones
+ * that do not match the given predicate.
+ *
+ * @typeParam T The type of the values in the input record.
+ *
+ * @param record The record to filter entries from.
+ * @param predicate The function to test each entry for a condition.
+ *
+ * @returns A new record with all entries that match the given predicate.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { filterEntries } from "@std/collections/filter-entries";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const menu = {
+ *   Salad: 11,
+ *   Soup: 8,
+ *   Pasta: 13,
+ * };
+ *
+ * const myOptions = filterEntries(
+ *   menu,
+ *   ([item, price]) => item !== "Pasta" && price < 10,
+ * );
+ *
+ * assertEquals(myOptions, { Soup: 8 });
+ * ```
+ */
+export function filterEntries<T>(
+  record: Readonly<Record<string, T>>,
+  predicate: (entry: [string, T]) => boolean,
+): Record<string, T> {
+  const result: Record<string, T> = {};
+  const entries = Object.entries(record);
+
+  for (const [key, value] of entries) {
+    if (predicate([key, value])) {
+      result[key] = value;
+    }
+  }
+
+  return result;
+}

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

@@ -0,0 +1,51 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Returns a new record with all entries of the given record except the ones that
+ * have a key that does not match the given predicate.
+ *
+ * @typeParam T The type of the values in the input record.
+ *
+ * @param record The record to filter keys from.
+ * @param predicate The function to test each key for a condition.
+ *
+ * @returns A new record with all entries that have a key that matches the given
+ * predicate.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { filterKeys } from "@std/collections/filter-keys";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const menu = {
+ *   Salad: 11,
+ *   Soup: 8,
+ *   Pasta: 13,
+ * };
+ *
+ * const menuWithoutSalad = filterKeys(menu, (item) => item !== "Salad");
+ *
+ * assertEquals(
+ *   menuWithoutSalad,
+ *   {
+ *     Soup: 8,
+ *     Pasta: 13,
+ *   },
+ * );
+ * ```
+ */
+export function filterKeys<T>(
+  record: Readonly<Record<string, T>>,
+  predicate: (key: string) => boolean,
+): Record<string, T> {
+  const result: Record<string, T> = {};
+
+  for (const [key, value] of Object.entries(record)) {
+    if (predicate(key)) {
+      result[key] = value;
+    }
+  }
+
+  return result;
+}

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

@@ -0,0 +1,51 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Returns a new record with all entries of the given record except the ones
+ * that have a value that does not match the given predicate.
+ *
+ * @typeParam T The type of the values in the input record.
+ *
+ * @param record The record to filter values from.
+ * @param predicate The function to test each value for a condition.
+ *
+ * @returns A new record with all entries that have a value that matches the
+ * given predicate.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { filterValues } from "@std/collections/filter-values";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const people = {
+ *   Arnold: 37,
+ *   Sarah: 7,
+ *   Kim: 23,
+ * };
+ * const adults = filterValues(people, (person) => person >= 18);
+ *
+ * assertEquals(
+ *   adults,
+ *   {
+ *     Arnold: 37,
+ *     Kim: 23,
+ *   },
+ * );
+ * ```
+ */
+export function filterValues<T>(
+  record: Readonly<Record<string, T>>,
+  predicate: (value: T) => boolean,
+): Record<string, T> {
+  const result: Record<string, T> = {};
+  const entries = Object.entries(record);
+
+  for (const [key, value] of entries) {
+    if (predicate(value)) {
+      result[key] = value;
+    }
+  }
+
+  return result;
+}

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

@@ -0,0 +1,48 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Returns an element if and only if that element is the only one matching the
+ * given condition. Returns `undefined` otherwise.
+ *
+ * @typeParam T The type of the elements in the input array.
+ *
+ * @param array The array to find a single element in.
+ * @param predicate The function to test each element for a condition.
+ *
+ * @returns The single element that matches the given condition or `undefined`
+ * if there are zero or more than one matching elements.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { findSingle } from "@std/collections/find-single";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const bookings = [
+ *   { month: "January", active: false },
+ *   { month: "March", active: false },
+ *   { month: "June", active: true },
+ * ];
+ * const activeBooking = findSingle(bookings, (booking) => booking.active);
+ * const inactiveBooking = findSingle(bookings, (booking) => !booking.active);
+ *
+ * assertEquals(activeBooking, { month: "June", active: true });
+ * assertEquals(inactiveBooking, undefined); // There are two applicable items
+ * ```
+ */
+export function findSingle<T>(
+  array: Iterable<T>,
+  predicate: (el: T) => boolean,
+): T | undefined {
+  let match: T | undefined;
+  let found = false;
+  for (const element of array) {
+    if (predicate(element)) {
+      if (found) return undefined;
+      found = true;
+      match = element;
+    }
+  }
+
+  return match;
+}

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

@@ -0,0 +1,47 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Applies the given selector to elements in the given array until a value is
+ * produced that is neither `null` nor `undefined` and returns that value.
+ * Returns `undefined` if no such value is produced.
+ *
+ * @typeParam T The type of the elements in the input array.
+ * @typeParam O The type of the value produced by the selector function.
+ *
+ * @param array The array to select a value from.
+ * @param selector The function to extract a value from an element.
+ *
+ * @returns The first non-`null` and non-`undefined` value produced by the
+ * selector function, or `undefined` if no such value is produced.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { firstNotNullishOf } from "@std/collections/first-not-nullish-of";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const tables = [
+ *   { number: 11, order: null },
+ *   { number: 12, order: "Soup" },
+ *   { number: 13, order: "Salad" },
+ * ];
+ *
+ * const nextOrder = firstNotNullishOf(tables, (table) => table.order);
+ *
+ * assertEquals(nextOrder, "Soup");
+ * ```
+ */
+export function firstNotNullishOf<T, O>(
+  array: Iterable<T>,
+  selector: (item: T) => O | undefined | null,
+): NonNullable<O> | undefined {
+  for (const current of array) {
+    const selected = selector(current);
+
+    if (selected !== null && selected !== undefined) {
+      return selected as NonNullable<O>;
+    }
+  }
+
+  return undefined;
+}

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

@@ -0,0 +1,45 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Returns true if the given value is part of the given object, otherwise it
+ * returns false.
+ *
+ * Note: this doesn't work with non-primitive values. For example,
+ * `includesValue({x: {}}, {})` returns false.
+ *
+ * @typeParam T The type of the values in the input record.
+ *
+ * @param record The record to check for the given value.
+ * @param value The value to check for in the record.
+ *
+ * @returns `true` if the value is part of the record, otherwise `false`.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { includesValue } from "@std/collections/includes-value";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const input = {
+ *   first: 33,
+ *   second: 34,
+ * };
+ *
+ * assertEquals(includesValue(input, 34), true);
+ * ```
+ */
+export function includesValue<T>(
+  record: Readonly<Record<string, T>>,
+  value: T,
+): boolean {
+  for (const i in record) {
+    if (
+      Object.hasOwn(record, i) &&
+      (record[i] === value || Number.isNaN(value) && Number.isNaN(record[i]))
+    ) {
+      return true;
+    }
+  }
+
+  return false;
+}

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

@@ -0,0 +1,35 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Returns all distinct elements that appear at least once in each of the given
+ * arrays.
+ *
+ * @typeParam T The type of the elements in the input arrays.
+ *
+ * @param arrays The arrays to intersect.
+ *
+ * @returns An array of distinct elements that appear at least once in each of
+ * the given arrays.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { intersect } from "@std/collections/intersect";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const lisaInterests = ["Cooking", "Music", "Hiking"];
+ * const kimInterests = ["Music", "Tennis", "Cooking"];
+ * const commonInterests = intersect(lisaInterests, kimInterests);
+ *
+ * assertEquals(commonInterests, ["Cooking", "Music"]);
+ * ```
+ */
+export function intersect<T>(...arrays: (readonly T[])[]): T[] {
+  const [array, ...otherArrays] = arrays;
+  let set = new Set(array);
+  for (const array of otherArrays) {
+    set = set.intersection(new Set(array));
+    if (set.size === 0) break;
+  }
+  return [...set];
+}

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

@@ -0,0 +1,38 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/** Return type for {@linkcode invert}. */
+export type InvertResult<T extends Record<PropertyKey, PropertyKey>> = {
+  [P in keyof T as T[P]]: P;
+};
+
+/**
+ * Composes a new record with all keys and values inverted.
+ *
+ * If the record contains duplicate values, subsequent values overwrite property
+ * assignments of previous values. If the record contains values which aren't
+ * {@linkcode PropertyKey}s their string representation is used as the key.
+ *
+ * @typeParam T The type of the input record.
+ *
+ * @param record The record to invert.
+ *
+ * @returns A new record with all keys and values inverted.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { invert } from "@std/collections/invert";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const record = { a: "x", b: "y", c: "z" };
+ *
+ * assertEquals(invert(record), { x: "a", y: "b", z: "c" });
+ * ```
+ */
+export function invert<T extends Record<PropertyKey, PropertyKey>>(
+  record: Readonly<T>,
+): InvertResult<T> {
+  return Object.fromEntries(
+    Object.entries(record).map(([key, value]) => [value, key]),
+  );
+}

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

@@ -0,0 +1,56 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/** Return type for {@linkcode invertBy}. */
+export type InvertByResult<
+  T extends Record<PropertyKey, PropertyKey>,
+  K extends keyof T,
+> = Record<PropertyKey, K[]>;
+
+/**
+ * Composes a new record with all keys and values inverted.
+ *
+ * The new record is generated from the result of running each element of the
+ * input record through the given transformer function.
+ *
+ * The corresponding inverted value of each inverted key is an array of keys
+ * responsible for generating the inverted value.
+ *
+ * @typeParam R The type of the input record.
+ * @typeParam T The type of the iterator function.
+ *
+ * @param record The record to invert.
+ * @param transformer The function to transform keys.
+ *
+ * @returns A new record with all keys and values inverted.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { invertBy } from "@std/collections/invert-by";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const record = { a: "x", b: "y", c: "z" };
+ *
+ * assertEquals(
+ *   invertBy(record, (key) => String(key).toUpperCase()),
+ *   { X: ["a"], Y: ["b"], Z: ["c"] }
+ * );
+ * ```
+ */
+export function invertBy<
+  R extends Record<PropertyKey, PropertyKey>,
+  T extends (key: PropertyKey) => PropertyKey,
+>(record: Readonly<R>, transformer: T): InvertByResult<R, keyof R> {
+  const result = {} as InvertByResult<R, keyof R>;
+
+  for (const [key, value] of Object.entries(record)) {
+    const mappedKey = transformer(value);
+    if (!Object.hasOwn(result, mappedKey)) {
+      result[mappedKey] = [key];
+    } else {
+      result[mappedKey]!.push(key);
+    }
+  }
+
+  return result;
+}

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

@@ -0,0 +1,109 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/** Options for {@linkcode joinToString}. */
+export type JoinToStringOptions = {
+  /**
+   * The string to use as a separator between the elements.
+   *
+   * @default {","}
+   */
+  separator?: string;
+  /**
+   * The string to use as a prefix for the resulting string.
+   *
+   * @default {""}
+   */
+  prefix?: string;
+  /**
+   * The string to use as a suffix for the resulting string.
+   *
+   * @default {""}
+   */
+  suffix?: string;
+  /**
+   * The maximum number of elements to append. If the value is negative, all
+   * elements will be appended, which is the default.
+   *
+   * @default {-1}
+   */
+  limit?: number;
+  /**
+   * The string to use as a placeholder for the truncated elements.
+   *
+   * @default {"..."}
+   */
+  truncated?: string;
+};
+
+/**
+ * Transforms the elements in the given array to strings using the given
+ * selector. Joins the produced strings into one using the given `separator`
+ * and applying the given `prefix` and `suffix` to the whole string afterwards.
+ *
+ * If the array could be huge, you can specify a non-negative value of `limit`,
+ * in which case only the first `limit` elements will be appended, followed by
+ * the `truncated` string.
+ *
+ * @typeParam T The type of the elements in the input array.
+ *
+ * @param array The array to join elements from.
+ * @param selector The function to transform elements to strings.
+ * @param options The options to configure the joining.
+ *
+ * @returns The resulting string.
+ *
+ * @example Usage with options
+ * ```ts
+ * import { joinToString } from "@std/collections/join-to-string";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const users = [
+ *   { name: "Kim" },
+ *   { name: "Anna" },
+ *   { name: "Tim" },
+ * ];
+ *
+ * const message = joinToString(users, (user) => user.name, {
+ *   suffix: " are winners",
+ *   prefix: "result: ",
+ *   separator: " and ",
+ *   limit: 1,
+ *   truncated: "others",
+ * });
+ *
+ * assertEquals(message, "result: Kim and others are winners");
+ * ```
+ */
+export function joinToString<T>(
+  array: Iterable<T>,
+  selector: (el: T) => string,
+  options: Readonly<JoinToStringOptions> = {},
+): string {
+  const {
+    separator = ",",
+    prefix = "",
+    suffix = "",
+    limit = -1,
+    truncated = "...",
+  } = options;
+
+  let result = "";
+
+  let index = 0;
+  for (const el of array) {
+    if (index > 0) {
+      result += separator;
+    }
+
+    if (limit >= 0 && index >= limit) {
+      result += truncated;
+      break;
+    }
+
+    result += selector(el);
+    index++;
+  }
+
+  return prefix + result + suffix;
+}