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

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;
+}

package/src/deps/jsr.io/@std/collections/1.0.9/min_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 given collection and
+ * returns the min 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 minimum element in.
+ * @param selector The function to get the value to compare from each element.
+ *
+ * @returns The smallest value of the given function or undefined if there are
+ * no elements.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { minOf } from "@std/collections/min-of";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const inventory = [
+ *   { name: "mustard", count: 2 },
+ *   { name: "soy", count: 4 },
+ *   { name: "tomato", count: 32 },
+ * ];
+ *
+ * const minCount = minOf(inventory, (item) => item.count);
+ *
+ * assertEquals(minCount, 2);
+ * ```
+ */
+export function minOf<T>(
+  array: Iterable<T>,
+  selector: (el: T) => number,
+): number | undefined;
+/**
+ * Applies the given selector to all elements of the given collection and
+ * returns the min 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 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 { minOf } from "@std/collections/min-of";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const inventory = [
+ *   { name: "mustard", count: 2n },
+ *   { name: "soy", count: 4n },
+ *   { name: "tomato", count: 32n },
+ * ];
+ *
+ * const minCount = minOf(inventory, (item) => item.count);
+ *
+ * assertEquals(minCount, 2n);
+ * ```
+ */
+export function minOf<T>(
+  array: Iterable<T>,
+  selector: (el: T) => bigint,
+): bigint | undefined;
+export function minOf<T, S extends ((el: T) => number) | ((el: T) => bigint)>(
+  array: Iterable<T>,
+  selector: S,
+): ReturnType<S> | undefined {
+  let minimumValue: ReturnType<S> | undefined;
+
+  for (const element of array) {
+    const currentValue = selector(element) as ReturnType<S>;
+
+    if (minimumValue === undefined || currentValue < minimumValue) {
+      minimumValue = currentValue;
+      continue;
+    }
+
+    if (Number.isNaN(currentValue)) {
+      return currentValue;
+    }
+  }
+
+  return minimumValue;
+}