semantic-typescript 0.3.3 → 0.3.8

package/dist/utility.d.ts

@@ -54,3 +54,7 @@ export interface Generator<T> {
     (accept: BiConsumer<T, bigint>, interrupt: Predicate<T>): void;
     (accept: BiConsumer<T, bigint>, interrupt: BiPredicate<T, bigint>): void;
 }
+export interface Indexed<E> {
+    element: E;
+    index: bigint;
+}

package/dist/utility.js

@@ -2,7 +2,7 @@ export let validate = (t) => {
     return t !== null && t !== (void 0);
 };
 export let invalidate = (t) => {
-    return t === null || t === undefined;
+    return t === null || t === (void 0);
 };
 ;
 ;
@@ -15,3 +15,4 @@ export let invalidate = (t) => {
 ;
 ;
 ;
+;

package/dist/window.d.ts

@@ -0,0 +1,12 @@
+import { OrderedCollectable } from "./collectable";
+import type { Semantic } from "./semantic";
+import type { Comparator, Generator } from "./utility";
+export declare class WindowCollectable<E> extends OrderedCollectable<E> {
+    protected readonly WindowCollectable: symbol;
+    constructor(generator: Generator<E>);
+    constructor(generator: Generator<E>, comparator: Comparator<E>);
+    [Symbol.iterator](): globalThis.Generator<E, void, undefined>;
+    [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
+    slide(size: bigint, step?: bigint): Semantic<Semantic<E>>;
+    tumble(size: bigint): Semantic<Semantic<E>>;
+}

package/dist/window.js

@@ -0,0 +1,70 @@
+import { OrderedCollectable } from "./collectable";
+import { useToAsyncGeneratorFunction, useToGeneratorFunction } from "./collector";
+import { from } from "./factory";
+import { useCompare } from "./hook";
+import { WindowCollectableSymbol } from "./symbol";
+export class WindowCollectable extends OrderedCollectable {
+    WindowCollectable = WindowCollectableSymbol;
+    constructor(parameter, comparator = useCompare) {
+        super(parameter, comparator);
+        Object.defineProperty(this, "WindowCollectable", {
+            value: WindowCollectableSymbol,
+            enumerable: false,
+            writable: false,
+            configurable: false
+        });
+        Object.freeze(this);
+    }
+    *[Symbol.iterator]() {
+        try {
+            let collector = useToGeneratorFunction();
+            yield* collector.collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on Generator.");
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        try {
+            let collector = useToAsyncGeneratorFunction();
+            yield* collector.collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on AsyncGenerator.");
+        }
+    }
+    slide(size, step = 1n) {
+        if (size > 0n && step > 0n) {
+            try {
+                let source = this.toArray();
+                let windows = [];
+                let windowStartIndex = 0n;
+                while (windowStartIndex < BigInt(source.length)) {
+                    let windowEnd = windowStartIndex + size;
+                    let window = source.slice(Number(windowStartIndex), Number(windowEnd));
+                    if (window.length > 0) {
+                        windows.push(window);
+                    }
+                    windowStartIndex += step;
+                }
+                return from(windows).map((window) => from(window));
+            }
+            catch (error) {
+                throw new Error("Invalid arguments.");
+            }
+        }
+        throw new RangeError("Invalid arguments.");
+    }
+    tumble(size) {
+        try {
+            return this.slide(size, size);
+        }
+        catch (error) {
+            throw new Error("Invalid arguments.");
+        }
+    }
+}
+;
+Object.freeze(WindowCollectable);
+Object.freeze(WindowCollectable.prototype);
+Object.freeze(Object.getPrototypeOf(WindowCollectable));

package/package.json

@@ -6,7 +6,7 @@
     "url": "https://github.com/eloyhere"
   },
   "description": "A modern type-safe stream processing library inspired by JavaScript Generator, Java Stream, and MySQL Index. Supports lazy evaluation, async streams, statistics, and IO-like operations.",
-  "version": "0.3.3",
+  "version": "0.3.8",
   "type": "module",
   "readme": "readme.md",
   "main": "dist/index.js",