semantic-typescript 0.3.0 → 0.3.2

package/dist/factory.d.ts

@@ -1,6 +1,11 @@
 import { Semantic } from "./semantic";
 import type { BiFunctional, BiPredicate, Functional, Predicate, Supplier, TriFunctional, Generator } from "./utility";
 export declare let animationFrame: Functional<number, Semantic<number>> & BiFunctional<number, number, Semantic<number>>;
+interface Attribute<T> {
+    key: keyof T;
+    value: T[keyof T];
+}
+export declare let attribute: <T extends object>(target: T) => Semantic<Attribute<T>>;
 export declare let blob: Functional<Blob, Semantic<Uint8Array>> & BiFunctional<Blob, bigint, Semantic<Uint8Array>>;
 export declare let empty: <E>() => Semantic<E>;
 export declare let fill: (<E>(element: E, count: bigint) => Semantic<E>) & (<E>(supplier: Supplier<E>, count: bigint) => Semantic<E>);
@@ -11,3 +16,4 @@ export declare let iterate: <E>(generator: Generator<E>) => Semantic<E>;
 export declare let promise: (<T>(promise: Promise<T>) => Semantic<T>);
 export declare let range: BiFunctional<number, number, Semantic<number>> & TriFunctional<number, number, number, Semantic<number>>;
 export declare let websocket: Functional<WebSocket, Semantic<MessageEvent | CloseEvent | Event>>;
+export {};

package/dist/factory.js

@@ -1,5 +1,5 @@
-import { isBigInt, isFunction, isIterable, isNumber, isPromise } from "./guard";
-import { useCompare } from "./hook";
+import { isBigInt, isFunction, isIterable, isNumber, isObject, isPromise } from "./guard";
+import { useCompare, useTraverse } from "./hook";
 import { Semantic } from "./semantic";
 import { invalidate, validate } from "./utility";
 export let animationFrame = (period, delay = 0) => {
@@ -25,6 +25,27 @@ export let animationFrame = (period, delay = 0) => {
         };
     });
 };
+;
+export let attribute = (target) => {
+    if (isObject(target)) {
+        return new Semantic((accept, interrupt) => {
+            let index = 0n;
+            useTraverse(target, (key, value) => {
+                let attribute = {
+                    key: key,
+                    value: value
+                };
+                if (interrupt(attribute, index)) {
+                    return false;
+                }
+                accept(attribute, index);
+                index++;
+                return true;
+            });
+        });
+    }
+    throw new TypeError("Target must be an object.");
+};
 export let blob = (blob, chunk = 64n * 1024n) => {
     let size = Number(chunk);
     if (size <= 0 || !Number.isSafeInteger(size)) {

package/dist/hook.d.ts

@@ -1,4 +1,4 @@
-import { type BiConsumer, type DeepPropertyKey, type DeepPropertyValue } from "./utility";
+import { type BiPredicate, type DeepPropertyKey, type DeepPropertyValue } from "./utility";
 export declare let useCompare: <T>(t1: T, t2: T) => number;
 export declare let useRandom: <T = number | bigint>(index: T) => T;
-export declare let useTraverse: <T extends object>(t: T, callback: BiConsumer<DeepPropertyKey<T>, DeepPropertyValue<T>>) => void;
+export declare let useTraverse: <T extends object>(t: T, callback: BiPredicate<DeepPropertyKey<T>, DeepPropertyValue<T>>) => void;

package/dist/hook.js

@@ -69,26 +69,38 @@ export let useTraverse = (t, callback) => {
         let traverse = (target) => {
             if (!seen.has(target)) {
                 seen.add(target);
+                let stop = false;
                 let properties = Reflect.ownKeys(target);
                 for (let property of properties) {
                     let value = target[property];
+                    if (stop) {
+                        break;
+                    }
                     if (validate(value)) {
                         if (isObject(value)) {
                             if (isIterable(value)) {
+                                let index = 0;
                                 for (let item of value) {
                                     if (validate(item)) {
                                         if (isObject(item)) {
                                             traverse(item);
                                         }
                                         else {
-                                            callback(property, item);
+                                            if (!callback(index, item)) {
+                                                stop = true;
+                                                break;
+                                            }
                                         }
                                     }
+                                    index++;
                                 }
                             }
                         }
                         else {
-                            callback(property, value);
+                            if (!callback(property, value)) {
+                                stop = true;
+                                break;
+                            }
                         }
                     }
                 }

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.0",
+  "version": "0.3.2",
   "type": "module",
   "readme": "readme.md",
   "main": "dist/index.js",

package/readme.md

@@ -111,13 +111,33 @@ if(isIterable(value)){
 |------|------|------------|------------|
 | `useCompare<T>(t1: T, t2: T): number` | Generic comparison function | O(1) | O(1) |
 | `useRandom<T = number \| bigint>(index: T): T` | Pseudo-random number generator | O(log n) | O(1) |
+| `useTraverse(t, callback)` | Deep traverse an object without cyclic references | O(n) | O(1) |
 
 ```typescript
 // Utility function usage examples
 let numbers: Array<number> = [3, 1, 4, 1, 5];
 numbers.sort(useCompare); // [1, 1, 3, 4, 5]
 
-let randomNum = useRandom(42); // Seed-based random number
+let randomNum: number = useRandom(42); // Seed-based random number
+
+let o = {
+    a: 1,
+    b: {
+        c: 2,
+        d: o
+    },
+    c: [1, 3, 5, o]
+};
+useTraverse(o, (value, key): boolean => {
+    console.log(key, value); 
+    /*
+    a 1
+    c 2
+    1 3 5
+    Cyclic references are not traversed.
+    */
+    return true; // Returns true to continue traversing.
+});
 ```
 
 ## Factory Methods
@@ -209,9 +229,9 @@ find.collect(from([1,2,3,4,5])); // Finds the first element
 find.collect([1,2,3,4,5]); // Finds the first element
 
 // Calculates the sum of elements
-let sum: Collector<number, number, number> = useSummate();
-sum.collect(from([1,2,3,4,5])); // Sums from a stream
-sum.collect([1,2,3,4,5]); // Sums from an iterable object
+let summate: Collector<number, number, number> = useSummate();
+summate.collect(from([1,2,3,4,5])); // Sums from a stream
+summate.collect([1,2,3,4,5]); // Sums from an iterable object
 
 // Calculates the average of elements
 let average: Collector<number, number, number> = useNumericAverage();
@@ -219,11 +239,23 @@ average.collect(from([1,2,3,4,5])); // Averages from a stream
 average.collect([1,2,3,4,5]); // Averages from an iterable object
 ```
 
+## Collector Class Methods
+
+| Method | Description | Time Complexity | Space Complexity |
+|------------|------------|------------|------------|
+| `collect(stream)` | Collect elements from a stream | O(n) | O(1) |
+| `collect(iterable)` | Collect elements from an iterable object | O(n) | O(1) |
+| `collect(generator)` | Collect elements from a generator | O(n) | O(1) |
+| `collect(semantic)` | Collect elements from a semantic stream | O(n) | O(1) |
+| `collect(collectable)` | Collect elements from a collectable stream | O(n) | O(1) |
+| `collect(start, endExelusive)` | Collect elements from a range | O(n) | O(1) |
+
 ### Semantic Factory Methods
 
 | Method | Description | Time Complexity | Space Complexity |
 |------|------|------------|------------|
 | `animationFrame(period: number, delay: number = 0)` | Create a timed animation frame stream | O(1)* | O(1) |
+| `attribute(target)` | Create a stream from an object deep attributes | O(n) | O(1) |
 | `blob(blob, chunkSize)` | Create a stream from a Blob | O(n) | O(chunkSize) |
 | `empty<E>()` | Create an empty stream | O(1) | O(1) |
 | `fill<E>(element, count)` | Create a filled stream | O(n) | O(1) |
@@ -281,7 +313,8 @@ websocket(ws)
 
 | Method | Description | Time Complexity | Space Complexity |
 |------|------|------------|------------|
-| `concat(other)` | Concatenate two streams | O(n) | O(1) |
+| `concat(semantic)` | Concatenate two streams | O(n) | O(1) |
+| `concat(iterable)` | Concatenate from an iterable object | O(n) | O(1) |
 | `distinct()` | Remove duplicates | O(n) | O(n) |
 | `distinct(comparator)` | Remove duplicates using a comparator | O(n²) | O(n) |
 | `dropWhile(predicate)` | Discard elements satisfying condition | O(n) | O(1) |
@@ -389,27 +422,41 @@ let customizedCollector = from([1, 2, 3, 4, 5]).toCollectable((generator: Genera
 
 | Method | Description | Time Complexity | Space Complexity |
 |------|------|------------|------------|
-| `anyMatch(predicate)` | Whether any element matches | O(n) | O(1) |
-| `allMatch(predicate)` | Whether all elements match | O(n) | O(1) |
-| `count()` | Element count | O(n) | O(1) |
-| `isEmpty()` | Whether it is empty | O(1) | O(1) |
-| `findAny()` | Find any element | O(n) | O(1) |
-| `findFirst()` | Find the first element | O(n) | O(1) |
-| `findLast()` | Find the last element | O(n) | O(1) |
-| `forEach(action)` | Iterate over all elements | O(n) | O(1) |
-| `group(classifier)` | Group by classifier | O(n) | O(n) |
-| `groupBy(keyExtractor, valueExtractor)` | Group by key-value extractor | O(n) | O(n) |
-| `join()` | Join as string | O(n) | O(n) |
-| `join(delimiter)` | Join using a delimiter | O(n) | O(n) |
-| `nonMatch(predicate)` | Whether no elements match | O(n) | O(1) |
-| `partition(count)` | Partition by count | O(n) | O(n) |
-| `partitionBy(classifier)` | Partition by classifier | O(n) | O(n) |
-| `reduce(accumulator)` | Reduction operation | O(n) | O(1) |
-| `reduce(identity, accumulator)` | Reduction with initial value | O(n) | O(1) |
-| `toArray()` | Convert to array | O(n) | O(n) |
-| `toMap(keyExtractor, valueExtractor)` | Convert to Map | O(n) | O(n) |
-| `toSet()` | Convert to Set | O(n) | O(n) |
-| `write(stream)` | Write to stream | O(n) | O(1) |
+| `anyMatch(predicate)` | Whether any element matches the predicate | O(n) | O(1) |
+| `allMatch(predicate)` | Whether all elements match the predicate | O(n) | O(1) |
+| `collect(collector)` | Collect elements using the given collector | O(n) | O(1) |
+| `collect(identity, accumulator, finisher)` | Collect elements with identity, accumulator, and finisher | O(n) | O(1) |
+| `collect(identity, interruptor, accumulator, finisher)` | Collect elements with identity, interruptor, accumulator, and finisher | O(n) | O(1) |
+| `count()` | Count the number of elements | O(n) | O(1) |
+| `error()` | Log elements to console with default error format | O(n) | O(1) |
+| `error(accumulator)` | Log elements via custom accumulator error format | O(n) | O(1) |
+| `error(prefix, accumulator, suffix)` | Log elements with prefix, custom accumulator, and suffix | O(n) | O(1) |
+| `isEmpty()` | Check whether the collectable is empty | O(n) | O(1) |
+| `findAny()` | Find any element in the collectable | O(n) | O(1) |
+| `findFirst()` | Find the first element in the collectable | O(n) | O(1) |
+| `findLast()` | Find the last element in the collectable | O(n) | O(1) |
+| `forEach(action)` | Iterate over all elements with a consumer or bi-consumer | O(n) | O(1) |
+| `group(classifier)` | Group elements by a classifier function | O(n) | O(n) |
+| `groupBy(keyExtractor, valueExtractor)` | Group elements by key and value extractors | O(n) | O(n) |
+| `join()` | Join elements into a string with default format | O(n) | O(n) |
+| `join(delimiter)` | Join elements into a string with a delimiter | O(n) | O(n) |
+| `join(prefix, delimiter, suffix)` | Join elements with prefix, delimiter, and suffix | O(n) | O(n) |
+| `join(prefix, accumulator, suffix)` | Join elements via custom accumulator with prefix and suffix | O(n) | O(n) |
+| `log()` | Log elements to console with default format | O(n) | O(1) |
+| `log(accumulator)` | Log elements via custom accumulator | O(n) | O(1) |
+| `log(prefix, accumulator, suffix)` | Log elements with prefix, custom accumulator, and suffix | O(n) | O(1) |
+| `nonMatch(predicate)` | Whether no elements match the predicate | O(n) | O(1) |
+| `partition(count)` | Partition elements into chunks of specified size | O(n) | O(n) |
+| `partitionBy(classifier)` | Partition elements by a classifier function | O(n) | O(n) |
+| `reduce(accumulator)` | Reduce elements using an accumulator (no initial value) | O(n) | O(1) |
+| `reduce(identity, accumulator)` | Reduce elements with an initial value and accumulator | O(n) | O(1) |
+| `reduce(identity, accumulator, finisher)` | Reduce elements with initial value, accumulator, and finisher | O(n) | O(1) |
+| `semantic()` | Convert the collectable to a semantic object | O(1) | O(1) |
+| `toArray()` | Convert elements to an array | O(n) | O(n) |
+| `toMap(keyExtractor, valueExtractor)` | Convert elements to a Map via key and value extractors | O(n) | O(n) |
+| `toSet()` | Convert elements to a Set | O(n) | O(n) |
+| `write(stream)` | Write elements to a stream (default format) | O(n) | O(1) |
+| `write(stream, accumulator)` | Write elements to a stream via custom accumulator | O(n) | O(1) |
 
 ```typescript
 // Collectable operation examples