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

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

@@ -0,0 +1,53 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Applies the given transformer to all entries in the given record and returns
+ * a new record containing the results.
+ *
+ * @typeParam T The type of the values in the input record.
+ * @typeParam O The type of the values in the output record.
+ *
+ * @param record The record to map entries from.
+ * @param transformer The function to transform each entry.
+ *
+ * @returns A new record with all entries transformed by the given transformer.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { mapEntries } from "@std/collections/map-entries";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const usersById = {
+ *   "a2e": { name: "Kim", age: 22 },
+ *   "dfe": { name: "Anna", age: 31 },
+ *   "34b": { name: "Tim", age: 58 },
+ * };
+ *
+ * const agesByNames = mapEntries(usersById, ([id, { name, age }]) => [name, age]);
+ *
+ * assertEquals(
+ *   agesByNames,
+ *   {
+ *     Kim: 22,
+ *     Anna: 31,
+ *     Tim: 58,
+ *   },
+ * );
+ * ```
+ */
+export function mapEntries<T, O>(
+  record: Readonly<Record<string, T>>,
+  transformer: (entry: [string, T]) => [string, O],
+): Record<string, O> {
+  const result: Record<string, O> = {};
+  const entries = Object.entries(record);
+
+  for (const entry of entries) {
+    const [mappedKey, mappedValue] = transformer(entry);
+
+    result[mappedKey] = mappedValue;
+  }
+
+  return result;
+}

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

@@ -0,0 +1,47 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Applies the given transformer to all keys in the given record's entries and
+ * returns a new record containing the transformed entries.
+ *
+ * If the transformed entries contain the same key multiple times, only the last
+ * one will appear in the returned record.
+ *
+ * @typeParam T The type of the values in the input record.
+ *
+ * @param record The record to map keys from.
+ * @param transformer The function to transform each key.
+ *
+ * @returns A new record with all keys transformed by the given transformer.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { mapKeys } from "@std/collections/map-keys";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const counts = { a: 5, b: 3, c: 8 };
+ *
+ * assertEquals(
+ *   mapKeys(counts, (key) => key.toUpperCase()),
+ *   {
+ *     A: 5,
+ *     B: 3,
+ *     C: 8,
+ *   },
+ * );
+ * ```
+ */
+export function mapKeys<T>(
+  record: Readonly<Record<string, T>>,
+  transformer: (key: string) => string,
+): Record<string, T> {
+  const result: Record<string, T> = {};
+
+  for (const [key, value] of Object.entries(record)) {
+    const mappedKey = transformer(key);
+    result[mappedKey] = value;
+  }
+
+  return result;
+}

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

@@ -0,0 +1,49 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Returns a new array, containing all elements in the given array transformed
+ * using the given transformer, except the ones that were transformed to `null`
+ * or `undefined`.
+ *
+ * @typeParam T The type of the elements in the input array.
+ * @typeParam O The type of the elements in the output array.
+ *
+ * @param array The array to map elements from.
+ * @param transformer The function to transform each element.
+ *
+ * @returns A new array with all elements transformed by the given transformer,
+ * except the ones that were transformed to `null` or `undefined`.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { mapNotNullish } from "@std/collections/map-not-nullish";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const people = [
+ *   { middleName: null },
+ *   { middleName: "William" },
+ *   { middleName: undefined },
+ *   { middleName: "Martha" },
+ * ];
+ * const foundMiddleNames = mapNotNullish(people, (people) => people.middleName);
+ *
+ * assertEquals(foundMiddleNames, ["William", "Martha"]);
+ * ```
+ */
+export function mapNotNullish<T, O>(
+  array: Iterable<T>,
+  transformer: (el: T) => O,
+): NonNullable<O>[] {
+  const result: NonNullable<O>[] = [];
+
+  for (const element of array) {
+    const transformedElement = transformer(element);
+
+    if (transformedElement !== undefined && transformedElement !== null) {
+      result.push(transformedElement as NonNullable<O>);
+    }
+  }
+
+  return result;
+}

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

@@ -0,0 +1,96 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Applies the given transformer to all values in the given record and returns a
+ * new record containing the resulting keys associated to the last value that
+ * produced them.
+ *
+ * @typeParam T The type of the values in the input record.
+ * @typeParam O The type of the values in the output record.
+ * @typeParam K The type of the keys in the input and output records.
+ *
+ * @param record The record to map values from.
+ * @param transformer The function to transform each value.
+ *
+ * @returns A new record with all values transformed by the given transformer.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { mapValues } from "@std/collections/map-values";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const usersById = {
+ *   a5ec: { name: "Mischa" },
+ *   de4f: { name: "Kim" },
+ * };
+ * const namesById = mapValues(usersById, (user) => user.name);
+ *
+ * assertEquals(
+ *   namesById,
+ *   {
+ *     a5ec: "Mischa",
+ *     de4f: "Kim",
+ *   },
+ * );
+ * ```
+ */
+export function mapValues<T, O, K extends string>(
+  record: Readonly<Record<K, T>>,
+  transformer: (value: T, key: K) => O,
+): Record<K, O>;
+/**
+ * Applies the given transformer to all values in the given record and returns a
+ * new record containing the resulting keys associated to the last value that
+ * produced them.
+ *
+ * @typeParam T The type of the values in the input record.
+ * @typeParam O The type of the values in the output record.
+ * @typeParam K The type of the keys in the input and output records.
+ *
+ * @param record The record to map values from.
+ * @param transformer The function to transform each value.
+ *
+ * @returns A new record with all values transformed by the given transformer.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { mapValues } from "@std/collections/map-values";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const usersById = {
+ *   "a5ec": { name: "Mischa" },
+ *   "de4f": { name: "Kim" },
+ * };
+ * const namesById = mapValues(usersById, (user) => user.name);
+ *
+ * assertEquals(
+ *   namesById,
+ *   {
+ *     "a5ec": "Mischa",
+ *     "de4f": "Kim",
+ *   },
+ * );
+ * ```
+ */
+export function mapValues<T, O, K extends string>(
+  record: Readonly<Partial<Record<K, T>>>,
+  transformer: (value: T, key: K) => O,
+): Partial<Record<K, O>>;
+export function mapValues<T, O, K extends string>(
+  record: Record<K, T>,
+  transformer: (value: T, key: K) => O,
+  // deno-lint-ignore no-explicit-any
+): any {
+  // deno-lint-ignore no-explicit-any
+  const result: any = {};
+  const entries = Object.entries<T>(record);
+
+  for (const [key, value] of entries) {
+    const mappedValue = transformer(value, key as K);
+
+    result[key] = mappedValue;
+  }
+
+  return result;
+}

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

@@ -0,0 +1,153 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Returns the first element that is the largest value of the given function or
+ * undefined if there are no elements.
+ *
+ * @typeParam T The type of the elements in the array.
+ *
+ * @param array The array to find the maximum element in.
+ * @param selector The function to get the value to compare from each element.
+ *
+ * @returns The first element that is the largest value of the given function or
+ * undefined if there are no elements.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { maxBy } from "@std/collections/max-by";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const people = [
+ *   { name: "Anna", age: 34 },
+ *   { name: "Kim", age: 42 },
+ *   { name: "John", age: 23 },
+ * ];
+ *
+ * const personWithMaxAge = maxBy(people, (person) => person.age);
+ *
+ * assertEquals(personWithMaxAge, { name: "Kim", age: 42 });
+ * ```
+ */
+export function maxBy<T>(
+  array: Iterable<T>,
+  selector: (el: T) => number,
+): T | undefined;
+/**
+ * Returns the first element that is the largest value of the given function or
+ * undefined if there are no elements.
+ *
+ * @typeParam T The type of the elements in the array.
+ *
+ * @param array The array to find the maximum element in.
+ * @param selector The function to get the value to compare from each element.
+ *
+ * @returns The first element that is the largest value of the given function or
+ * undefined if there are no elements.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { maxBy } from "@std/collections/max-by";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const people = [
+ *   { name: "Anna" },
+ *   { name: "Kim" },
+ *   { name: "John" },
+ * ];
+ *
+ * const personWithMaxName = maxBy(people, (person) => person.name);
+ *
+ * assertEquals(personWithMaxName, { name: "Kim" });
+ * ```
+ */
+export function maxBy<T>(
+  array: Iterable<T>,
+  selector: (el: T) => string,
+): T | undefined;
+/**
+ * Returns the first element that is the largest value of the given function or
+ * undefined if there are no elements.
+ *
+ * @typeParam T The type of the elements in the array.
+ *
+ * @param array The array to find the maximum element in.
+ * @param selector The function to get the value to compare from each element.
+ *
+ * @returns The first element that is the largest value of the given function or
+ * undefined if there are no elements.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { maxBy } from "@std/collections/max-by";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const people = [
+ *   { name: "Anna", age: 34n },
+ *   { name: "Kim", age: 42n },
+ *   { name: "John", age: 23n },
+ * ];
+ *
+ * const personWithMaxAge = maxBy(people, (person) => person.age);
+ *
+ * assertEquals(personWithMaxAge, { name: "Kim", age: 42n });
+ * ```
+ */
+export function maxBy<T>(
+  array: Iterable<T>,
+  selector: (el: T) => bigint,
+): T | undefined;
+/**
+ * Returns the first element that is the largest value of the given function or
+ * undefined if there are no elements.
+ *
+ * @typeParam T The type of the elements in the array.
+ *
+ * @param array The array to find the maximum element in.
+ * @param selector The function to get the value to compare from each element.
+ *
+ * @returns The first element that is the largest value of the given function or
+ * undefined if there are no elements.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { maxBy } from "@std/collections/max-by";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const people = [
+ *   { name: "Anna", startedAt: new Date("2020-01-01") },
+ *   { name: "Kim", startedAt: new Date("2021-03-01") },
+ *   { name: "John", startedAt: new Date("2020-03-01") },
+ * ];
+ *
+ * const personWithLastStartedAt = maxBy(people, (person) => person.startedAt);
+ *
+ * assertEquals(personWithLastStartedAt, { name: "Kim", startedAt: new Date("2021-03-01") });
+ * ```
+ */
+export function maxBy<T>(
+  array: Iterable<T>,
+  selector: (el: T) => Date,
+): T | undefined;
+export function maxBy<T>(
+  array: Iterable<T>,
+  selector:
+    | ((el: T) => number)
+    | ((el: T) => string)
+    | ((el: T) => bigint)
+    | ((el: T) => Date),
+): T | undefined {
+  let max: T | undefined;
+  let maxValue: ReturnType<typeof selector> | undefined;
+
+  for (const current of array) {
+    const currentValue = selector(current);
+
+    if (maxValue === undefined || currentValue > maxValue) {
+      max = current;
+      maxValue = currentValue;
+    }
+  }
+
+  return max;
+}

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

@@ -0,0 +1,90 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Applies the given selector to all elements of the provided collection and
+ * returns the max value of all elements. If an empty array is provided the
+ * function will return undefined.
+ *
+ * @typeParam T The type of the elements in the array.
+ *
+ * @param array The array to find the maximum element in.
+ * @param selector The function to get the value to compare from each element.
+ *
+ * @returns The largest value of the given function or undefined if there are no
+ * elements.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { maxOf } from "@std/collections/max-of";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const inventory = [
+ *   { name: "mustard", count: 2 },
+ *   { name: "soy", count: 4 },
+ *   { name: "tomato", count: 32 },
+ * ];
+ *
+ * const maxCount = maxOf(inventory, (item) => item.count);
+ *
+ * assertEquals(maxCount, 32);
+ * ```
+ */
+export function maxOf<T>(
+  array: Iterable<T>,
+  selector: (el: T) => number,
+): number | undefined;
+/**
+ * Applies the given selector to all elements of the provided collection and
+ * returns the max value of all elements. If an empty array is provided the
+ * function will return undefined.
+ *
+ * @typeParam T The type of the elements in the array.
+ *
+ * @param array The array to find the maximum element in.
+ * @param selector The function to get the value to compare from each element.
+ *
+ * @returns The first element that is the largest value of the given function or
+ * undefined if there are no elements.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { maxOf } from "@std/collections/max-of";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const inventory = [
+ *   { name: "mustard", count: 2n },
+ *   { name: "soy", count: 4n },
+ *   { name: "tomato", count: 32n },
+ * ];
+ *
+ * const maxCount = maxOf(inventory, (i) => i.count);
+ *
+ * assertEquals(maxCount, 32n);
+ * ```
+ */
+export function maxOf<T>(
+  array: Iterable<T>,
+  selector: (el: T) => bigint,
+): bigint | undefined;
+export function maxOf<T, S extends ((el: T) => number) | ((el: T) => bigint)>(
+  array: Iterable<T>,
+  selector: S,
+): ReturnType<S> | undefined {
+  let maximumValue: ReturnType<S> | undefined;
+
+  for (const element of array) {
+    const currentValue = selector(element) as ReturnType<S>;
+
+    if (maximumValue === undefined || currentValue > maximumValue) {
+      maximumValue = currentValue;
+      continue;
+    }
+
+    if (Number.isNaN(currentValue)) {
+      return currentValue;
+    }
+  }
+
+  return maximumValue;
+}

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

@@ -0,0 +1,46 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Returns the first element having the largest value according to the provided
+ * comparator or undefined if there are no elements.
+ *
+ * The comparator is expected to work exactly like one passed to `Array.sort`,
+ * which means that `comparator(a, b)` should return a negative number if
+ * `a < b`, a positive number if `a > b` and `0` if `a === b`.
+ *
+ * @typeParam T The type of the elements in the array.
+ *
+ * @param array The array to find the maximum element in.
+ * @param comparator The function to compare elements.
+ *
+ * @returns The first element that is the largest value of the given function or
+ * undefined if there are no elements.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { maxWith } from "@std/collections/max-with";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const people = ["Kim", "Anna", "John", "Arthur"];
+ * const largestName = maxWith(people, (a, b) => a.length - b.length);
+ *
+ * assertEquals(largestName, "Arthur");
+ * ```
+ */
+export function maxWith<T>(
+  array: Iterable<T>,
+  comparator: (a: T, b: T) => number,
+): T | undefined {
+  let max: T | undefined;
+  let isFirst = true;
+
+  for (const current of array) {
+    if (isFirst || comparator(current, <T> max) > 0) {
+      max = current;
+      isFirst = false;
+    }
+  }
+
+  return max;
+}

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

@@ -0,0 +1,151 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Returns the first element that is the smallest value of the given function or
+ * undefined if there are no elements.
+ *
+ * @typeParam T The type of the elements in the array.
+ *
+ * @param array The array to find the minimum element in.
+ * @param selector The function to get the value to compare from each element.
+ *
+ * @returns The first element that is the smallest value of the given function
+ * or undefined if there are no elements.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { minBy } from "@std/collections/min-by";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const people = [
+ *   { name: "Anna", age: 34 },
+ *   { name: "Kim", age: 42 },
+ *   { name: "John", age: 23 },
+ * ];
+ *
+ * const personWithMinAge = minBy(people, (i) => i.age);
+ *
+ * assertEquals(personWithMinAge, { name: "John", age: 23 });
+ * ```
+ */
+export function minBy<T>(
+  array: Iterable<T>,
+  selector: (el: T) => number,
+): T | undefined;
+/**
+ * Returns the first element that is the smallest value of the given function or
+ * undefined if there are no elements.
+ *
+ * @typeParam T The type of the elements in the array.
+ *
+ * @param array The array to find the minimum element in.
+ * @param selector The function to get the value to compare from each element.
+ *
+ * @returns The first element that is the smallest value of the given function
+ * or undefined if there are no elements.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { minBy } from "@std/collections/min-by";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const people = [
+ *   { name: "Anna" },
+ *   { name: "Kim" },
+ *   { name: "John" },
+ * ];
+ *
+ * const personWithMinName = minBy(people, (person) => person.name);
+ *
+ * assertEquals(personWithMinName, { name: "Anna" });
+ * ```
+ */
+export function minBy<T>(
+  array: Iterable<T>,
+  selector: (el: T) => string,
+): T | undefined;
+/**
+ * Returns the first element that is the smallest value of the given function or
+ * undefined if there are no elements.
+ *
+ * @typeParam T The type of the elements in the array.
+ *
+ * @param array The array to find the minimum element in.
+ * @param selector The function to get the value to compare from each element.
+ *
+ * @returns The first element that is the smallest value of the given function
+ * or undefined if there are no elements.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { minBy } from "@std/collections/min-by";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const people = [
+ *   { name: "Anna", age: 34n },
+ *   { name: "Kim", age: 42n },
+ *   { name: "John", age: 23n },
+ * ];
+ *
+ * const personWithMinAge = minBy(people, (i) => i.age);
+ *
+ * assertEquals(personWithMinAge, { name: "John", age: 23n });
+ * ```
+ */
+export function minBy<T>(
+  array: Iterable<T>,
+  selector: (el: T) => bigint,
+): T | undefined;
+/**
+ * Returns the first element that is the smallest value of the given function or
+ * undefined if there are no elements.
+ *
+ * @typeParam T The type of the elements in the array.
+ *
+ * @param array The array to find the minimum element in.
+ * @param selector The function to get the value to compare from each element.
+ *
+ * @returns The first element that is the smallest value of the given function
+ * or undefined if there are no elements.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { minBy } from "@std/collections/min-by";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const people = [
+ *   { name: "Anna", startedAt: new Date("2020-01-01") },
+ *   { name: "Kim", startedAt: new Date("2020-03-01") },
+ *   { name: "John", startedAt: new Date("2019-01-01") },
+ * ];
+ *
+ * const personWithMinStartedAt = minBy(people, (person) => person.startedAt);
+ * ```
+ */
+export function minBy<T>(
+  array: Iterable<T>,
+  selector: (el: T) => Date,
+): T | undefined;
+export function minBy<T>(
+  array: Iterable<T>,
+  selector:
+    | ((el: T) => number)
+    | ((el: T) => string)
+    | ((el: T) => bigint)
+    | ((el: T) => Date),
+): T | undefined {
+  let min: T | undefined;
+  let minValue: ReturnType<typeof selector> | undefined;
+
+  for (const current of array) {
+    const currentValue = selector(current);
+
+    if (minValue === undefined || currentValue < minValue) {
+      min = current;
+      minValue = currentValue;
+    }
+  }
+
+  return min;
+}