semantic-typescript 0.0.7 → 0.1.4

package/dist/semantic.d.ts

@@ -21,15 +21,21 @@ export declare let SemanticSymbol: symbol;
 export declare let CollectorsSymbol: symbol;
 export declare let CollectableSymbol: symbol;
 export declare let OrderedCollectableSymbol: symbol;
-export declare let UnorderedCollectableSymbol: symbol;
+export declare let WindowCollectableSymbol: symbol;
 export declare let StatisticsSymbol: symbol;
+export declare let NumericStatisticsSymbol: symbol;
+export declare let BigIntStatisticsSymbol: symbol;
+export declare let UnorderedCollectableSymbol: symbol;
 export declare let isOptional: (t: unknown) => t is Optional<unknown>;
 export declare let isSemantic: (t: unknown) => t is Semantic<unknown>;
 export declare let isCollector: (t: unknown) => t is Collector<unknown, unknown, unknown>;
 export declare let isCollectable: (t: unknown) => t is Collectable<unknown>;
 export declare let isOrderedCollectable: (t: unknown) => t is OrderedCollectable<unknown>;
+export declare let isWindowCollectable: (t: unknown) => t is OrderedCollectable<unknown>;
 export declare let isUnorderedCollectable: (t: unknown) => t is UnorderedCollectable<unknown>;
 export declare let isStatistics: (t: unknown) => t is Statistics<unknown, number | bigint>;
+export declare let isNumericStatistics: (t: unknown) => t is Statistics<unknown, number | bigint>;
+export declare let isBigIntStatistics: (t: unknown) => t is Statistics<unknown, number | bigint>;
 export interface Runnable {
     (): void;
 }
@@ -72,11 +78,13 @@ declare class Optional<T> {
     protected constructor(value: MaybeInvalid<T>);
     filter(predicate: Predicate<T>): Optional<T>;
     get(): T;
-    getOrDefault(defaultValue: T): T;
+    get(defaultValue: T): T;
     ifPresent(action: Consumer<T>): void;
+    ifPresent(action: Consumer<T>, elseAction: Runnable): void;
     isEmpty(): boolean;
     isPresent(): boolean;
     map<R>(mapper: Functional<T, R>): Optional<R>;
+    static empty<T>(): Optional<T>;
     static of<T>(value: MaybeInvalid<T>): Optional<T>;
     static ofNullable<T>(value?: MaybeInvalid<T>): Optional<T>;
     static ofNonNull<T>(value: T): Optional<T>;
@@ -85,8 +93,9 @@ export declare let blob: BiFunctional<Blob, bigint, Semantic<Uint8Array>>;
 export declare let empty: <E>() => Semantic<E>;
 export declare let fill: <E>(element: E | Supplier<E>, count: bigint) => Semantic<E>;
 export declare let from: <E>(iterable: Iterable<E>) => Semantic<E>;
-export declare let range: <N extends number | bigint>(start: N, end: N, step: N) => Semantic<N>;
+export declare let interval: Functional<number, Semantic<number>> & BiFunctional<number, number, Semantic<number>>;
 export declare let iterate: <E>(generator: Generator<E>) => Semantic<E>;
+export declare let range: <N extends number | bigint>(start: N, end: N, step: N) => Semantic<N>;
 export declare let websocket: Functional<WebSocket, Semantic<MessageEvent | CloseEvent | Event>>;
 export declare class Semantic<E> {
     protected generator: Generator<E>;
@@ -139,6 +148,7 @@ export declare class Collector<E, A, R> {
     static shortable<E, A, R>(identity: Supplier<A>, interruptor: Predicate<E>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Collector<E, A, R>;
 }
 export declare abstract class Collectable<E> {
+    protected readonly Collectable: symbol;
     constructor();
     anyMatch(predicate: Predicate<E>): boolean;
     allMatch(predicate: Predicate<E>): boolean;
@@ -179,10 +189,12 @@ export declare abstract class Collectable<E> {
     toArray(): Array<E>;
     toMap<K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>): Map<K, V>;
     toSet(): Set<E>;
-    write(stream: WritableStream<string>): Promise<void>;
-    write(stream: WritableStream<Uint8Array>, accumulator: Functional<E, Uint8Array>): Promise<void>;
+    write(stream: WritableStream<string>): Promise<WritableStream<string>>;
+    write(stream: WritableStream<string>, accumulator: BiFunctional<E, bigint, string>): Promise<WritableStream<string>>;
+    write(stream: WritableStream<Uint8Array>, accumulator: BiFunctional<E, bigint, Uint8Array>): Promise<WritableStream<Uint8Array>>;
 }
 export declare class UnorderedCollectable<E> extends Collectable<E> {
+    protected readonly UnorderedCollectable: symbol;
     protected generator: Generator<E>;
     constructor(generator: Generator<E>);
     source(): Generator<E>;
@@ -192,6 +204,7 @@ type Indexed<K, V> = {
     value: V;
 };
 export declare class OrderedCollectable<E> extends Collectable<E> {
+    protected readonly OrderedCollectable: symbol;
     protected ordered: Array<Indexed<bigint, E>>;
     constructor(iterable: Iterable<E>);
     constructor(iterable: Iterable<E>, comparator: Comparator<E>);
@@ -200,6 +213,7 @@ export declare class OrderedCollectable<E> extends Collectable<E> {
     source(): Generator<E> | Iterable<E>;
 }
 export declare class WindowCollectable<E> extends OrderedCollectable<E> {
+    protected readonly WindowCollectable: symbol;
     constructor(iterable: Iterable<E>);
     constructor(iterable: Iterable<E>, comparator: Comparator<E>);
     constructor(generator: Generator<E>);
@@ -208,6 +222,7 @@ export declare class WindowCollectable<E> extends OrderedCollectable<E> {
     tumble(size: bigint): Semantic<Semantic<E>>;
 }
 export declare abstract class Statistics<E, D extends number | bigint> extends OrderedCollectable<E> {
+    protected readonly Statistics: symbol;
     constructor(iterable: Iterable<E>);
     constructor(iterable: Iterable<E>, comparator: Comparator<E>);
     constructor(generator: Generator<E>);
@@ -243,6 +258,7 @@ export declare abstract class Statistics<E, D extends number | bigint> extends O
     abstract kurtosis(mapper: Functional<E, D>): D;
 }
 export declare class NumericStatistics<E> extends Statistics<E, number> {
+    protected readonly NumericStatistics: symbol;
     constructor(iterable: Iterable<E>);
     constructor(iterable: Iterable<E>, comparator: Comparator<E>);
     constructor(generator: Generator<E>);
@@ -273,6 +289,7 @@ export declare class NumericStatistics<E> extends Statistics<E, number> {
     kurtosis(mapper: Functional<E, number>): number;
 }
 export declare class BigIntStatistics<E> extends Statistics<E, bigint> {
+    protected readonly BigIntStatistics: symbol;
     constructor(iterable: Iterable<E>);
     constructor(iterable: Iterable<E>, comparator: Comparator<E>);
     constructor(generator: Generator<E>);

package/dist/semantic.js

@@ -123,8 +123,11 @@ export let SemanticSymbol = Symbol.for("Semantic");
 export let CollectorsSymbol = Symbol.for("Collector");
 export let CollectableSymbol = Symbol.for("Collectable");
 export let OrderedCollectableSymbol = Symbol.for("OrderedCollectable");
-export let UnorderedCollectableSymbol = Symbol.for("UnorderedCollectable");
+export let WindowCollectableSymbol = Symbol.for("WindowCollectable");
 export let StatisticsSymbol = Symbol.for("Statistics");
+export let NumericStatisticsSymbol = Symbol.for("NumericStatistics");
+export let BigIntStatisticsSymbol = Symbol.for("BigIntStatistics");
+export let UnorderedCollectableSymbol = Symbol.for("UnorderedCollectable");
 export let isOptional = (t) => {
     if (isObject(t)) {
         return Reflect.get(t, "Optional") === OptionalSymbol;
@@ -155,6 +158,12 @@ export let isOrderedCollectable = (t) => {
     }
     return false;
 };
+export let isWindowCollectable = (t) => {
+    if (isObject(t)) {
+        return Reflect.get(t, "WindowCollectable") === OrderedCollectableSymbol;
+    }
+    return false;
+};
 export let isUnorderedCollectable = (t) => {
     if (isObject(t)) {
         return Reflect.get(t, "UnorderedCollectable") === UnorderedCollectableSymbol;
@@ -167,6 +176,18 @@ export let isStatistics = (t) => {
     }
     return false;
 };
+export let isNumericStatistics = (t) => {
+    if (isObject(t)) {
+        return Reflect.get(t, "NumericStatistics") === NumericStatisticsSymbol;
+    }
+    return false;
+};
+export let isBigIntStatistics = (t) => {
+    if (isObject(t)) {
+        return Reflect.get(t, "BigIntStatistics") === BigIntStatisticsSymbol;
+    }
+    return false;
+};
 ;
 ;
 ;
@@ -189,25 +210,26 @@ class Optional {
         }
         return new Optional((void 0));
     }
-    get() {
-        if (this.isPresent()) {
-            return this.value;
-        }
-        throw new TypeError("Optional is empty");
-    }
-    getOrDefault(defaultValue) {
+    get(defaultValue) {
         if (this.isPresent()) {
             return this.value;
         }
-        if (validate(defaultValue)) {
-            return defaultValue;
+        else {
+            if (validate(defaultValue)) {
+                return defaultValue;
+            }
+            else {
+                throw new TypeError("Invalid default value and optional is empty.");
+            }
         }
-        throw new TypeError("Default value is not valid");
     }
-    ifPresent(action) {
+    ifPresent(action, elseAction) {
         if (this.isPresent() && isFunction(action)) {
             action(this.value);
         }
+        else if (isFunction(elseAction)) {
+            elseAction();
+        }
     }
     isEmpty() {
         return invalidate(this.value);
@@ -221,6 +243,9 @@ class Optional {
         }
         return new Optional(null);
     }
+    static empty() {
+        return new Optional(null);
+    }
     static of(value) {
         return Optional.ofNullable(value);
     }
@@ -325,6 +350,29 @@ export let from = (iterable) => {
     }
     throw new TypeError("Invalid arguments");
 };
+export let interval = (period, delay = 0) => {
+    if (period > 0 && delay >= 0) {
+        return new Semantic((accept, interrupt) => {
+            setTimeout(() => {
+                let index = 0;
+                let timer = setInterval(() => {
+                    if (interrupt(index)) {
+                        clearInterval(timer);
+                    }
+                    accept(period, BigInt(index));
+                    index++;
+                }, period);
+            }, delay);
+        });
+    }
+    throw new TypeError("Invalid arguments.");
+};
+export let iterate = (generator) => {
+    if (isFunction(generator)) {
+        return new Semantic(generator);
+    }
+    throw new TypeError("Invalid arguments.");
+};
 export let range = (start, end, step = (typeof start === 'bigint' ? 1n : 1)) => {
     if ((isNumber(step) && step === 0) || (isBigint(step) && step === 0n)) {
         throw new TypeError("Step cannot be zero.");
@@ -357,12 +405,6 @@ export let range = (start, end, step = (typeof start === 'bigint' ? 1n : 1)) =>
     }
     throw new TypeError("Invalid arguments.");
 };
-export let iterate = (generator) => {
-    if (isFunction(generator)) {
-        return new Semantic(generator);
-    }
-    throw new TypeError("Invalid arguments.");
-};
 export let websocket = (websocket) => {
     if (invalidate(websocket)) {
         throw new TypeError("WebSocket is invalid.");
@@ -370,6 +412,15 @@ export let websocket = (websocket) => {
     return new Semantic((accept, interrupt) => {
         let index = 0n;
         let stop = false;
+        websocket.addEventListener("open", (event) => {
+            if (stop || interrupt(event)) {
+                stop = true;
+            }
+            else {
+                accept(event, index);
+                index++;
+            }
+        });
         websocket.addEventListener("message", (event) => {
             if (stop || interrupt(event)) {
                 stop = true;
@@ -768,6 +819,7 @@ export class Collector {
 }
 ;
 export class Collectable {
+    Collectable = CollectableSymbol;
     constructor() {
     }
     anyMatch(predicate) {
@@ -1073,49 +1125,45 @@ export class Collectable {
     }
     write(stream, accumulator) {
         if (isObject(stream) && invalidate(accumulator)) {
-            return this.collect(() => {
-                return Promise.resolve(stream);
-            }, (promise, element) => {
-                return new Promise((resolve1, reject1) => {
-                    promise.then(async (stream) => {
+            let optional = this.collect(() => {
+                return Optional.ofNonNull(stream);
+            }, (result, element) => {
+                try {
+                    return result.map((stream) => {
                         let writer = stream.getWriter();
-                        await writer.write(String(element));
-                        resolve1(stream);
+                        writer.write(String(element));
                         return stream;
-                    }, reject1);
-                });
-            }, (promise) => {
-                return new Promise((resolve, reject) => {
-                    promise.then(async (stream) => {
-                        await stream.getWriter().close();
-                        resolve();
-                    }, (reason) => {
-                        reject(reason);
                     });
-                });
+                }
+                catch (reason) {
+                    return Optional.empty();
+                }
+            }, (a) => {
+                return a;
+            });
+            return new Promise((resolve, reject) => {
+                optional.ifPresent(resolve, reject);
             });
         }
         else if (isObject(stream) && isFunction(accumulator)) {
-            return this.collect(() => {
-                return Promise.resolve(stream);
-            }, (promise, element) => {
-                return new Promise((resolve1, reject1) => {
-                    promise.then(async (stream) => {
+            let optional = this.collect(() => {
+                return Optional.ofNonNull(stream);
+            }, (result, element, index) => {
+                try {
+                    return result.map((stream) => {
                         let writer = stream.getWriter();
-                        await writer.write(accumulator(element));
-                        resolve1(stream);
+                        writer.write(accumulator(element, index));
                         return stream;
-                    }, reject1);
-                });
-            }, (promise) => {
-                return new Promise((resolve, reject) => {
-                    promise.then(async (stream) => {
-                        await stream.getWriter().close();
-                        resolve();
-                    }, (reason) => {
-                        reject(reason);
                     });
-                });
+                }
+                catch (reason) {
+                    return Optional.empty();
+                }
+            }, (a) => {
+                return a;
+            });
+            return new Promise((resolve, reject) => {
+                optional.ifPresent(resolve, reject);
             });
         }
         else {
@@ -1124,6 +1172,7 @@ export class Collectable {
     }
 }
 export class UnorderedCollectable extends Collectable {
+    UnorderedCollectable = UnorderedCollectableSymbol;
     generator;
     constructor(generator) {
         super();
@@ -1134,6 +1183,7 @@ export class UnorderedCollectable extends Collectable {
     }
 }
 export class OrderedCollectable extends Collectable {
+    OrderedCollectable = OrderedCollectableSymbol;
     ordered = [];
     constructor(argument1, argument2) {
         super();
@@ -1182,6 +1232,7 @@ export class OrderedCollectable extends Collectable {
     }
 }
 export class WindowCollectable extends OrderedCollectable {
+    WindowCollectable = WindowCollectableSymbol;
     constructor(parameter, comparator) {
         if (isIterable(parameter)) {
             if (isFunction(comparator)) {
@@ -1223,6 +1274,7 @@ export class WindowCollectable extends OrderedCollectable {
 }
 ;
 export class Statistics extends OrderedCollectable {
+    Statistics = StatisticsSymbol;
     constructor(parameter, comparator) {
         if (isIterable(parameter)) {
             if (isFunction(comparator)) {
@@ -1341,6 +1393,7 @@ export class Statistics extends OrderedCollectable {
 }
 ;
 export class NumericStatistics extends Statistics {
+    NumericStatistics = NumericStatisticsSymbol;
     constructor(parameter, comparator) {
         if (isIterable(parameter)) {
             if (isFunction(comparator)) {
@@ -1659,6 +1712,7 @@ export class NumericStatistics extends Statistics {
 }
 ;
 export class BigIntStatistics extends Statistics {
+    BigIntStatistics = BigIntStatisticsSymbol;
     constructor(parameter, comparator) {
         if (isIterable(parameter)) {
             if (isFunction(comparator)) {

package/package.json

@@ -1,17 +1,62 @@
 {
   "name": "semantic-typescript",
-  "version": "0.0.7",
+  "author": {
+    "name": "Eloy Kim",
+    "email": "eloy.kim@outlook.com",
+    "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.1.4",
   "type": "module",
-  "main": "dist/index.js",       
-  "types": "dist/index.d.ts",    
-  "files": ["dist"],             
+  "readme": "readme.md",
+  "main": "dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "typescript",
+    "stream",
+    "async-stream",
+    "functional-programming",
+    "lazy-evaluation",
+    "data-processing",
+    "pipeline",
+    "statistics",
+    "generator",
+    "optional",
+    "blob-stream",
+    "websocket-stream",
+    "frontend",
+    "bigInt"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eloyhere/semantic-typescript.git"
+  },
+  "bugs": {
+    "url": "https://github.com/eloyhere/semantic-typescript/issues"
+  },
+  "homepage": "https://github.com/eloyhere/semantic-typescript#readme",
+  "license": "MIT",
+  "engines": {
+    "node": ">=14.0.0"
+  },
   "scripts": {
     "build": "tsc",
     "prepublishOnly": "npm run build"
   },
   "devDependencies": {
-    "typescript": "~5.9.3"       
-},
-  "peerDependencies": {},         
-  "dependencies": {}              
+    "typescript": "~5.9.3"
+  },
+  "peerDependencies": {},
+  "dependencies": {}
 }