change project structure to remove namespaces

2024-05-11 16:46:47 +02:00
parent 727cdc3b2b
commit 486abefba6
17 changed files with 1201 additions and 1155 deletions
--- a/src/sync/index.ts
+++ b/src/sync/index.ts
@@ -0,0 +1,147 @@
+import { mathRandom } from "../random/index.js";
+import { RandomGenerator } from "../random/types.js";
+import { BigIntRangeEnumerable, ConcatEnumerable, EmptyEnumerable, EnumerableMarker, FunctionEnumerable, GeneratorEnumerable, RangeEnumerable, RepeatEnumerable, RepeatForeverEnumerable, WrappedArray, WrappedArrayLike, WrappedIterable, WrappedMap, WrappedObject, WrappedSet } from "./impl.js";
+import { Enumerable } from "./types.js";
+
+export function wrap<T>(iterable: Iterable<T>): Enumerable<T> {
+  if (isEnumerable<T>(iterable)) {
+    return iterable;
+  }
+
+  if (Array.isArray(iterable)) {
+    return array(iterable);
+  }
+
+  if (iterable instanceof Set) {
+    return set<T>(iterable);
+  }
+
+  if (iterable instanceof Map) {
+    return map(iterable) as unknown as Enumerable<T>;
+  }
+
+  return sequence(iterable);
+}
+
+export function sequence<T>(iterable: Iterable<T>): Enumerable<T> {
+  return new WrappedIterable(iterable);
+}
+
+export function empty<T>(): Enumerable<T> {
+  return EmptyEnumerable.INSTANCE;
+}
+
+export function single<T>(obj: T): Enumerable<T> {
+  return new WrappedObject(obj);
+}
+
+export function array<T>(array: T[]): Enumerable<T> {
+  return new WrappedArray(array);
+}
+
+export function arrayLike<T>(arrayLike: ArrayLike<T>): Enumerable<T> {
+  return new WrappedArrayLike(arrayLike);
+}
+
+export function set<T>(set: Set<T>): Enumerable<T> {
+  return new WrappedSet(set);
+}
+
+export function map<K, V>(map: Map<K, V>): Enumerable<[K, V]> {
+  return new WrappedMap(map);
+}
+
+export function of<T>(...elements: T[]): Enumerable<T> {
+  switch (elements.length) {
+    case 0:
+      return empty();
+    case 1:
+      return single(elements[0]);
+    default:
+      return array(elements);
+  }
+}
+
+export function ofPropertyKeys<T extends PropertyKey>(...elements: T[]): Enumerable<T> {
+  return of(...elements);
+}
+
+export function entries<T>(o: Record<string, T> | ArrayLike<T>): Enumerable<[string, T]> {
+  return array(Object.entries(o));
+}
+
+export function keys(o: object): Enumerable<string> {
+  return array(Object.keys(o));
+}
+
+export function func<T>(f: () => T): Enumerable<T> {
+  return new FunctionEnumerable(f);
+}
+
+export function generator<T>(generator: () => Iterable<T>): Enumerable<T> {
+  return new GeneratorEnumerable(generator);
+}
+
+export function range(max: number): Enumerable<number>
+export function range(min: number, max: number): Enumerable<number>
+export function range(min: number, max: number, step: number): Enumerable<number>
+export function range(a: number, b?: number, c?: number): Enumerable<number> {
+  if (b === undefined) {
+    b = a;
+    a = 0;
+  }
+
+  if (c === undefined) {
+    c = 1;
+  }
+
+  return new RangeEnumerable(a, b, c);
+}
+
+export function bigintRange(max: bigint): Enumerable<bigint>
+export function bigintRange(min: bigint, max: bigint): Enumerable<bigint>
+export function bigintRange(min: bigint, max: bigint, step: bigint): Enumerable<bigint>
+export function bigintRange(a: bigint, b?: bigint, c?: bigint): Enumerable<bigint> {
+  if (b === undefined) {
+    b = a;
+    a = 0n;
+  }
+
+  if (c === undefined) {
+    c = 1n;
+  }
+
+  return new BigIntRangeEnumerable(a, b, c);
+}
+
+export function repeat<T>(value: T, count?: number): Enumerable<T> {
+  if (count == undefined) {
+    return new RepeatForeverEnumerable(value);
+  }
+
+  if (count < 0) {
+    throw new RangeError();
+  }
+
+  if (count === 0) {
+    return empty();
+  }
+
+  if (count === 1) {
+    return new WrappedObject(value);
+  }
+
+  return new RepeatEnumerable(value, count);
+}
+
+export function randomSequence(random?: RandomGenerator): Enumerable<number> {
+  return new FunctionEnumerable(random ?? mathRandom);
+}
+
+export function concat<T>(...enumerables: Enumerable<T>[]): Enumerable<T> {
+  return new ConcatEnumerable(enumerables);
+}
+
+export function isEnumerable<T = any>(obj: any): obj is Enumerable<T> {
+  return obj instanceof EnumerableMarker;
+}