@effect/tsgo-linux-arm 0.51.1 → 0.52.0

package/artifacts/typescript/{7.1.0-dev.20261006.1 → 7.1.0-dev.20261012.1}/lib.esnext.d.ts

@@ -21,5 +21,6 @@ and limitations under the License.
 /// <reference lib="esnext.sharedmemory" />
 /// <reference lib="esnext.temporal" />
 /// <reference lib="esnext.date" />
+/// <reference lib="esnext.iterator" />
 /// <reference lib="esnext.modulesource" />
 /// <reference lib="esnext.promise" />

package/artifacts/typescript/7.1.0-dev.20261012.1/lib.esnext.iterator.d.ts

@@ -0,0 +1,149 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABILITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+
+
+/// <reference lib="es2026.iterator" />
+
+export {};
+
+type IteratorZipShortestOptions = {
+    /**
+     * Stops when any input is exhausted.
+     */
+    mode?: "shortest" | undefined;
+};
+
+type IteratorZipLongestOptions<T> = {
+    /**
+     * Continues until every input is exhausted.
+     */
+    mode: "longest";
+
+    /**
+     * Values used when an input is exhausted before the others.
+     */
+    padding?: (T & object) | undefined;
+};
+
+type IteratorZipStrictOptions = {
+    /**
+     * Requires every input to yield the same number of values.
+     * If not, a `TypeError` will be thrown when an input is exhausted before others.
+     */
+    mode: "strict";
+};
+
+type IteratorZipOptions<T> =
+    | IteratorZipShortestOptions
+    | IteratorZipLongestOptions<T>
+    | IteratorZipStrictOptions;
+
+type IteratorInput<T> = (Iterable<T> | Iterator<T>) & object;
+
+type IteratorYield<T> = T extends IteratorInput<infer U> ? U : never;
+
+type IteratorZipKey<K extends PropertyKey> = K extends number ? K | `${K}` | (number extends K ? "NaN" | "Infinity" | "-Infinity" : never)
+    : K extends `${infer N extends number}` ? `${N}` extends K ? K | N : K : K;
+
+type IteratorZipDefaultPadding<T> = {
+    readonly [K in keyof T]?: IteratorYield<T[K]> | undefined;
+};
+
+type IteratorZipPaddingKeys<T> = keyof {
+    [K in keyof T as {} extends Pick<T, K> ? never : IteratorZipKey<K>]: unknown;
+};
+
+type IteratorZipValue<T, K extends PropertyKey, TExtra, TPadding> =
+    | IteratorYield<T>
+    | (TPadding extends unknown ? TPadding[IteratorZipKey<K> & keyof TPadding] | (K extends "NaN" | "Infinity" | "-Infinity" ? TPadding[number & keyof TPadding] : never) : never)
+    | (IteratorZipKey<K> extends IteratorZipPaddingKeys<TPadding> ? never : TExtra);
+
+type IteratorZipResult<T, TExtra = never, TPadding = {}> = {
+    -readonly [K in keyof T]: IteratorZipValue<T[K], K, TExtra, TPadding>;
+};
+
+type IteratorZipKeyedInput<T> = {
+    [K in T extends unknown ? keyof T : never]?: IteratorInput<unknown> | undefined;
+};
+
+type IteratorZipKeyedResult<T, TExtra = never, TPadding = {}> = T extends Partial<Record<keyof T, undefined>> ? keyof T extends never ? Record<PropertyKey, unknown> : never
+    : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: IteratorZipValue<T[K], K, TExtra, TPadding>; } &
+    { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends undefined ? never : K : never]?: IteratorZipValue<T[K], K, TExtra, TPadding>; };
+
+declare global {
+    interface IteratorObject<T, TReturn, TNext> {
+        /**
+         * Creates an iterator whose values are arrays containing successive values from this iterator.
+         * @param chunkSize The maximum number of values in each array.
+         */
+        chunks(chunkSize: number): IteratorObject<T[], undefined, unknown>;
+
+        /**
+         * Creates a string by concatenating the values of this iterator, separated by the specified separator.
+         * `null` and `undefined` values contribute an empty string.
+         * @param separator A string used to separate values. If omitted, a comma is used.
+         */
+        join(separator?: string): string;
+
+        /**
+         * Determines whether this iterator yields the specified value using SameValueZero comparison.
+         * @param searchElement The value to locate.
+         * @param skippedElements The number of values to skip before searching.
+         */
+        includes(searchElement: T, skippedElements?: number): boolean;
+    }
+
+    interface IteratorConstructor {
+        /**
+         * Creates an iterator whose values are arrays containing values yielded at the same position by each input iterator or iterable.
+         * @param iterables An iterable of iterators or iterables to zip.
+         * @param options Controls how differing input lengths are handled.
+         */
+        zip(iterables: readonly [], options?: IteratorZipOptions<Iterable<unknown> & object>): IteratorObject<never, undefined, unknown>;
+
+        /**
+         * Creates an iterator whose values are arrays containing values yielded at the same position by each input iterator or iterable.
+         * @param iterables An iterable of iterators or iterables to zip.
+         * @param options Controls how differing input lengths are handled.
+         */
+        zip<T extends readonly IteratorInput<unknown>[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<IteratorZipResult<T>, undefined, unknown>;
+        zip<T extends readonly IteratorInput<unknown>[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions<TPadding> & { padding: TPadding; }): IteratorObject<IteratorZipResult<T, undefined, TPadding>, undefined, unknown>;
+        zip<T extends readonly IteratorInput<unknown>[] | [], TPadding extends readonly unknown[] | [] = IteratorZipDefaultPadding<T>>(iterables: T, options?: IteratorZipOptions<TPadding>): IteratorObject<IteratorZipResult<T, undefined, Partial<TPadding>>, undefined, unknown>;
+
+        /**
+         * Creates an iterator whose values are arrays containing values yielded at the same position by each input iterator or iterable.
+         * @param iterables An iterable of iterators or iterables to zip.
+         * @param options Controls how differing input lengths are handled.
+         */
+        zip<T extends IteratorInput<unknown>>(iterables: Iterable<T> & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<IteratorYield<T>[], undefined, unknown>;
+        zip<T extends IteratorInput<unknown>, TPadding = IteratorYield<T>>(iterables: Iterable<T> & object, options?: IteratorZipOptions<Iterable<TPadding> & object>): IteratorObject<(IteratorYield<T> | TPadding | undefined)[], undefined, unknown>;
+
+        /**
+         * Creates an iterator whose values are objects containing values yielded at the same position by each iterator or iterable in the input object.
+         * @param iterables An object whose enumerable own properties contain iterators or iterables to zip. Undefined values are ignored.
+         * @param options Controls how differing input lengths are handled.
+         */
+        zipKeyed<T extends object>(iterables: T & IteratorZipKeyedInput<T>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<IteratorZipKeyedResult<T>, undefined, unknown>;
+        zipKeyed<T extends object, TPadding>(iterables: T & IteratorZipKeyedInput<T>, options: IteratorZipLongestOptions<TPadding> & { padding: TPadding; }): IteratorObject<IteratorZipKeyedResult<T, undefined, TPadding>, undefined, unknown>;
+        zipKeyed<T extends object, TPadding = IteratorZipDefaultPadding<T>>(iterables: T & IteratorZipKeyedInput<T>, options?: IteratorZipOptions<TPadding>): IteratorObject<IteratorZipKeyedResult<T, undefined, Partial<TPadding>>, undefined, unknown>;
+
+        /**
+         * Accepts objects whose types include inherited or non-enumerable properties.
+         * Property ownership and enumerability are not represented in object types, so the result values are unknown.
+         * Iterator records use the preceding overloads to preserve their inferred result types.
+         */
+        zipKeyed<T extends object>(iterables: T & ([T] extends [IteratorZipKeyedInput<T>] ? never : unknown), options?: IteratorZipOptions<object>): IteratorObject<Record<PropertyKey, unknown>, undefined, unknown>;
+    }
+}