semantic-typescript 0.0.6 → 0.0.8

package/dist/semantic.d.ts

@@ -3,6 +3,8 @@ export type Valid<T> = T extends null | undefined ? never : T;
 export type MaybeInvalid<T> = T | null | undefined;
 export declare let validate: <T>(t: MaybeInvalid<T>) => t is T;
 export declare let invalidate: <T>(t: MaybeInvalid<T>) => t is (null | undefined);
+export type Primitive = string | number | boolean | symbol | bigint | Function | ((...args: any[]) => any);
+export type MaybePrimitive<T> = T | Primitive;
 export declare let isBoolean: (t: unknown) => t is boolean;
 export declare let isString: (t: unknown) => t is string;
 export declare let isNumber: (t: unknown) => t is number;
@@ -10,6 +12,7 @@ export declare let isFunction: (t: unknown) => t is Function;
 export declare let isObject: (t: unknown) => t is object;
 export declare let isSymbol: (t: unknown) => t is symbol;
 export declare let isBigint: (t: unknown) => t is bigint;
+export declare let isPrimitive: (t: MaybePrimitive<unknown>) => t is Primitive;
 export declare let isIterable: (t: unknown) => t is Iterable<unknown>;
 export declare let useCompare: <T>(t1: T, t2: T) => number;
 export declare let useRandom: <T = number | bigint>(index: T) => T;
@@ -78,11 +81,13 @@ declare class Optional<T> {
     static ofNullable<T>(value?: MaybeInvalid<T>): Optional<T>;
     static ofNonNull<T>(value: T): Optional<T>;
 }
+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 function iterate<E>(generator: Generator<E>): Semantic<E>;
+export declare let iterate: <E>(generator: Generator<E>) => Semantic<E>;
+export declare let websocket: Functional<WebSocket, Semantic<MessageEvent | CloseEvent | Event>>;
 export declare class Semantic<E> {
     protected generator: Generator<E>;
     protected readonly Semantic: Symbol;
@@ -174,6 +179,8 @@ 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>;
 }
 export declare class UnorderedCollectable<E> extends Collectable<E> {
     protected generator: Generator<E>;

package/dist/semantic.js

@@ -25,6 +25,9 @@ export let isSymbol = (t) => {
 export let isBigint = (t) => {
     return typeof t === "bigint";
 };
+export let isPrimitive = (t) => {
+    return isBoolean(t) || isString(t) || isNumber(t) || isSymbol(t) || isBigint(t) || isFunction(t);
+};
 export let isIterable = (t) => {
     if (isObject(t)) {
         return isFunction(Reflect.get(t, Symbol.iterator));
@@ -41,7 +44,7 @@ export let useCompare = (t1, t2) => {
             case "bigint":
                 return Number(t1 - t2);
             case "boolean":
-                return t1 ? 1 : -1;
+                return t1 === t2 ? 0 : (t1 ? 1 : -1);
             case "symbol":
                 return t1.toString().localeCompare(t2.toString());
             case "function":
@@ -49,15 +52,19 @@ export let useCompare = (t1, t2) => {
             case "undefined":
                 return 0;
             case "object":
+                if (isFunction(Reflect.get(t1, Symbol.toPrimitive)) && isFunction(Reflect.get(t2, Symbol.toPrimitive))) {
+                    let a = Reflect.apply(Reflect.get(t1, Symbol.toPrimitive), t1, ["default"]);
+                    let b = Reflect.apply(Reflect.get(t2, Symbol.toPrimitive), t2, ["default"]);
+                    if (isPrimitive(a) && isPrimitive(b)) {
+                        return useCompare(a, b);
+                    }
+                }
                 let a = Object.prototype.valueOf.call(t1);
                 let b = Object.prototype.valueOf.call(t2);
-                if (a === b) {
-                    return 0;
+                if (isPrimitive(a) && isPrimitive(b)) {
+                    return useCompare(a, b);
                 }
-                if (a < b) {
-                    return -1;
-                }
-                return 1;
+                return useCompare(Object.prototype.toString.call(t1), Object.prototype.toString.call(t2));
             default:
                 throw new TypeError("Invalid type.");
         }
@@ -228,6 +235,64 @@ class Optional {
     }
 }
 ;
+export let blob = (blob, chunk = 64n * 1024n) => {
+    let size = Number(chunk);
+    if (size <= 0) {
+        throw new RangeError("Chunk size must be positive.");
+    }
+    if (invalidate(blob)) {
+        throw new TypeError("Blob is invalid.");
+    }
+    return new Semantic((accept, interrupt) => {
+        let stream = blob.stream();
+        let reader = stream.getReader();
+        let shouldStop = false;
+        let currentIndex = 0n;
+        let currentBuffer = new Uint8Array(size);
+        let bufferPosition = 0;
+        let readNext = () => {
+            if (shouldStop) {
+                return;
+            }
+            reader.read().then((readResult) => {
+                if (readResult.done) {
+                    if (bufferPosition > 0) {
+                        let finalChunk = currentBuffer.slice(0, bufferPosition);
+                        if (!interrupt(finalChunk)) {
+                            accept(finalChunk, currentIndex);
+                        }
+                    }
+                    shouldStop = true;
+                    return;
+                }
+                let chunkData = readResult.value;
+                let dataPosition = 0;
+                while (dataPosition < chunkData.length && !shouldStop) {
+                    let remainingSpace = size - bufferPosition;
+                    let bytesToCopy = Math.min(remainingSpace, chunkData.length - dataPosition);
+                    currentBuffer.set(chunkData.subarray(dataPosition, dataPosition + bytesToCopy), bufferPosition);
+                    bufferPosition += bytesToCopy;
+                    dataPosition += bytesToCopy;
+                    if (bufferPosition === size) {
+                        let completeChunk = currentBuffer.slice();
+                        if (!interrupt(completeChunk)) {
+                            accept(completeChunk, currentIndex);
+                        }
+                        currentIndex++;
+                        bufferPosition = 0;
+                    }
+                }
+                if (!shouldStop && !interrupt(chunkData)) {
+                    readNext();
+                }
+                else {
+                    shouldStop = true;
+                }
+            });
+        };
+        readNext();
+    });
+};
 export let empty = () => {
     return new Semantic(() => { });
 };
@@ -292,12 +357,48 @@ export let range = (start, end, step = (typeof start === 'bigint' ? 1n : 1)) =>
     }
     throw new TypeError("Invalid arguments.");
 };
-export function iterate(generator) {
+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.");
+    }
+    return new Semantic((accept, interrupt) => {
+        let index = 0n;
+        let stop = false;
+        websocket.addEventListener("message", (event) => {
+            if (stop || interrupt(event)) {
+                stop = true;
+            }
+            else {
+                accept(event, index);
+                index++;
+            }
+        });
+        websocket.addEventListener("error", (event) => {
+            if (stop || interrupt(event)) {
+                stop = true;
+            }
+            else {
+                accept(event, index);
+                index++;
+            }
+        });
+        websocket.addEventListener("close", (event) => {
+            if (stop || interrupt(event)) {
+                stop = true;
+            }
+            else {
+                accept(event, index);
+                index++;
+            }
+        });
+    });
+};
 export class Semantic {
     generator;
     Semantic = SemanticSymbol;
@@ -970,6 +1071,57 @@ export class Collectable {
             return result;
         });
     }
+    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 writer = stream.getWriter();
+                        await writer.write(String(element));
+                        resolve1(stream);
+                        return stream;
+                    }, reject1);
+                });
+            }, (promise) => {
+                return new Promise((resolve, reject) => {
+                    promise.then(async (stream) => {
+                        await stream.getWriter().close();
+                        resolve();
+                    }, (reason) => {
+                        reject(reason);
+                    });
+                });
+            });
+        }
+        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 writer = stream.getWriter();
+                        await writer.write(accumulator(element));
+                        resolve1(stream);
+                        return stream;
+                    }, reject1);
+                });
+            }, (promise) => {
+                return new Promise((resolve, reject) => {
+                    promise.then(async (stream) => {
+                        await stream.getWriter().close();
+                        resolve();
+                    }, (reason) => {
+                        reject(reason);
+                    });
+                });
+            });
+        }
+        else {
+            throw new TypeError("Invalid arguments.");
+        }
+    }
 }
 export class UnorderedCollectable extends Collectable {
     generator;

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "semantic-typescript",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "type": "module",
   "main": "dist/index.js",       
   "types": "dist/index.d.ts",    
-  "files": ["dist", "LICENSE", "readme.md", "readme.cn.md", "readme.jp.md", "readme.ko.md", "readme.tw.md", "readme.de.md", "readme.es.md", "readme.fr.md"],             
+  "files": ["dist"],             
   "scripts": {
     "build": "tsc",
     "prepublishOnly": "npm run build"