linqx 0.2.0 → 0.3.2

package/dist/operators/partition-by.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable, IGrouping } from '../types.js';
+export declare function partitionBy<T, TKey, TElement = T, TResult = IGrouping<TKey, TElement>>(this: IEnumerable<T>, keySelector: (element: T) => TKey, elementSelector?: (element: T) => TElement, resultSelector?: ((key: TKey, elements: IEnumerable<TElement>) => TResult) | undefined, compareSelector?: (key: TKey) => unknown): IEnumerable<TResult>;

package/dist/operators/position.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable, Positioned } from '../types.js';
+export declare function position<T>(this: IEnumerable<T>): IEnumerable<Positioned<T>>;

package/dist/operators/prepend.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function prepend<T>(this: IEnumerable<T>, element: T): IEnumerable<T>;

package/dist/operators/reverse.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function reverse<T>(this: IEnumerable<T>): IEnumerable<T>;

package/dist/operators/right-join.d.ts

@@ -0,0 +1,2 @@
+import type { EnumerableInput, IEnumerable } from '../types.js';
+export declare function rightJoin<TOuter, TInner, TKey, TResult>(this: IEnumerable<TOuter>, inner: EnumerableInput<TInner>, outerKeySelector: (outer: TOuter) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: TOuter | null, inner: TInner) => TResult, compareSelector?: (key: TKey) => unknown): IEnumerable<TResult>;

package/dist/operators/scan.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function scan<T, TAccumulate>(this: IEnumerable<T>, seedOrFunc: TAccumulate | ((prev: T, current: T) => T), optionalFunc?: (prev: TAccumulate, current: T) => TAccumulate): IEnumerable<T | TAccumulate>;

package/dist/operators/select-many.d.ts

@@ -0,0 +1,2 @@
+import type { EnumerableInput, IEnumerable } from '../types.js';
+export declare function selectMany<T, TCollection, TResult = TCollection>(this: IEnumerable<T>, collectionSelector: (element: T, index: number) => EnumerableInput<TCollection>, resultSelector?: (outer: T, inner: TCollection) => TResult): IEnumerable<TCollection | TResult>;

package/dist/operators/select.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function select<T, TResult>(this: IEnumerable<T>, selector: (element: T, index: number) => TResult): IEnumerable<TResult>;

package/dist/operators/sequence-equal.d.ts

@@ -0,0 +1,2 @@
+import type { EnumerableInput, IEnumerable } from '../types.js';
+export declare function sequenceEqual<T, TCompare>(this: IEnumerable<T>, second: EnumerableInput<T>, compareSelector?: (element: T) => TCompare): boolean;

package/dist/operators/share.d.ts

@@ -0,0 +1,2 @@
+import type { IDisposableEnumerable, IEnumerable } from '../types.js';
+export declare function share<T>(this: IEnumerable<T>): IDisposableEnumerable<T>;

package/dist/operators/shuffle.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function shuffle<T>(this: IEnumerable<T>): IEnumerable<T>;

package/dist/operators/single-or-default.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function singleOrDefault<T, TDefault>(this: IEnumerable<T>, predicateOrDefault?: ((element: T, index: number) => boolean) | TDefault, defaultValue?: TDefault): T | TDefault | undefined;

package/dist/operators/single.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function single<T>(this: IEnumerable<T>, predicate?: (element: T, index: number) => boolean): T;

package/dist/operators/skip-last.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function skipLast<T>(this: IEnumerable<T>, count: number): IEnumerable<T>;

package/dist/operators/skip-while.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function skipWhile<T>(this: IEnumerable<T>, predicate: (element: T, index: number) => boolean): IEnumerable<T>;

package/dist/operators/skip.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function skip<T>(this: IEnumerable<T>, count: number): IEnumerable<T>;

package/dist/operators/sum.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function sum<T>(this: IEnumerable<T>, selector?: (element: T) => number): number;

package/dist/operators/take-except-last.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function takeExceptLast<T>(this: IEnumerable<T>, count?: number): IEnumerable<T>;

package/dist/operators/take-from-last.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function takeFromLast<T>(this: IEnumerable<T>, count: number): IEnumerable<T>;

package/dist/operators/take-last.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function takeLast<T>(this: IEnumerable<T>, count: number): IEnumerable<T>;

package/dist/operators/take-while.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function takeWhile<T>(this: IEnumerable<T>, predicate: (element: T, index: number) => boolean): IEnumerable<T>;

package/dist/operators/take.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function take<T>(this: IEnumerable<T>, count: number): IEnumerable<T>;

package/dist/operators/then-by-descending.d.ts

@@ -0,0 +1,2 @@
+import type { Comparer, IOrderedEnumerable } from '../types.js';
+export declare function thenByDescending<T, TKey>(this: IOrderedEnumerable<T>, keySelector: (element: T) => TKey, comparer?: Comparer<TKey>): IOrderedEnumerable<T>;

package/dist/operators/then-by.d.ts

@@ -0,0 +1,2 @@
+import type { Comparer, IOrderedEnumerable } from '../types.js';
+export declare function thenBy<T, TKey>(this: IOrderedEnumerable<T>, keySelector: (element: T) => TKey, comparer?: Comparer<TKey>): IOrderedEnumerable<T>;

package/dist/operators/to-array.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function toArray<T>(this: IEnumerable<T>): T[];

package/dist/operators/to-dictionary.d.ts

@@ -0,0 +1,2 @@
+import type { IDictionary, IEnumerable } from '../types.js';
+export declare function toDictionary<T, TKey, TValue = T>(this: IEnumerable<T>, keySelector: (element: T) => TKey, elementSelector?: (element: T) => TValue, compareSelector?: (key: TKey) => unknown): IDictionary<TKey, TValue>;

package/dist/operators/to-joined-string.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function toJoinedString<T, TResult = T>(this: IEnumerable<T>, separator?: string, selector?: (element: T, index: number) => TResult): string;

package/dist/operators/to-json-string.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function toJSONString<T>(this: IEnumerable<T>, replacer?: ((key: string, value: unknown) => unknown) | (string | number)[], space?: string | number): string;

package/dist/operators/to-lookup.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable, ILookup } from '../types.js';
+export declare function toLookup<T, TKey, TElement = T>(this: IEnumerable<T>, keySelector: (element: T) => TKey, elementSelector?: (element: T) => TElement, compareSelector?: (key: TKey) => unknown): ILookup<TKey, TElement>;

package/dist/operators/to-map.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function toMap<T, TKey, TValue>(this: IEnumerable<T>, keySelector: (element: T) => TKey, valueSelector: (element: T) => TValue): Map<TKey, TValue>;

package/dist/operators/to-object.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function toObject<T, TKey extends PropertyKey, TElement = T>(this: IEnumerable<T>, keySelector: (element: T) => TKey, elementSelector?: (element: T) => TElement): Record<TKey, TElement>;

package/dist/operators/to-set.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function toSet<T>(this: IEnumerable<T>): Set<T>;

package/dist/operators/trace.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function trace<T, TValue = T>(this: IEnumerable<T>, message?: string, selector?: (element: T) => TValue): IEnumerable<T>;

package/dist/operators/traverse-breadth-first.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function traverseBreadthFirst<T, TResult = T>(this: IEnumerable<T>, childrenSelector: (element: T) => IEnumerable<T>, resultSelector?: (element: T, nestLevel: number) => TResult): IEnumerable<TResult>;

package/dist/operators/traverse-depth-first.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function traverseDepthFirst<T, TResult = T>(this: IEnumerable<T>, childrenSelector: (element: T) => IEnumerable<T>, resultSelector?: (element: T, nestLevel: number) => TResult): IEnumerable<TResult>;

package/dist/operators/union-by.d.ts

@@ -0,0 +1,2 @@
+import type { EnumerableInput, IEnumerable } from '../types.js';
+export declare function unionBy<T, TKey, TCompare = TKey>(this: IEnumerable<T>, second: EnumerableInput<T>, keySelector: (element: T) => TKey, compareSelector?: (key: TKey) => TCompare): IEnumerable<T>;

package/dist/operators/union.d.ts

@@ -0,0 +1,2 @@
+import type { EnumerableInput, IEnumerable } from '../types.js';
+export declare function union<T, TCompare>(this: IEnumerable<T>, second: EnumerableInput<T>, compareSelector?: (element: T) => TCompare): IEnumerable<T>;

package/dist/operators/weighted-sample.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function weightedSample<T>(this: IEnumerable<T>, weightSelector: (element: T) => number): IEnumerable<T>;

package/dist/operators/where-if.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function whereIf<T>(this: IEnumerable<T>, flag: boolean | string | undefined | null, filter: (element: T) => boolean): IEnumerable<T>;

package/dist/operators/where.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function where<T>(this: IEnumerable<T>, predicate: (element: T, index: number) => boolean): IEnumerable<T>;

package/dist/operators/with-neighbors.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable, Neighbors } from '../types.js';
+export declare function withNeighbors<T>(this: IEnumerable<T>): IEnumerable<Neighbors<T>>;

package/dist/operators/zip.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function zip<T, TResult>(this: IEnumerable<T>, ...params: unknown[]): IEnumerable<TResult>;