semantic-typescript 0.2.7 → 0.2.9

package/dist/hook.d.ts

@@ -1,2 +1,4 @@
+import { type BiConsumer, 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;

package/dist/hook.js

@@ -1,4 +1,5 @@
-import { isFunction, isNumber, isPrimitive } from "./guard";
+import { isFunction, isIterable, isNumber, isObject, isPrimitive } from "./guard";
+import { validate } from "./utility";
 export let useCompare = (t1, t2) => {
     if (t1 === t2 || Object.is(t1, t2)) {
         return 0;
@@ -62,3 +63,37 @@ export let useRandom = (index) => {
     }
     throw new TypeError("Invalid input type");
 };
+export let useTraverse = (t, callback) => {
+    if (isObject(t)) {
+        let seen = new WeakSet();
+        let traverse = (target) => {
+            if (!seen.has(target)) {
+                seen.add(target);
+                let properties = Reflect.ownKeys(target);
+                for (let property of properties) {
+                    let value = target[property];
+                    if (validate(value)) {
+                        if (isObject(value)) {
+                            if (isIterable(value)) {
+                                for (let item of value) {
+                                    if (validate(item)) {
+                                        if (isObject(item)) {
+                                            traverse(item);
+                                        }
+                                        else {
+                                            callback(property, item);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        else {
+                            callback(property, value);
+                        }
+                    }
+                }
+            }
+        };
+        traverse(t);
+    }
+};

package/dist/optional.d.ts

@@ -1,3 +1,4 @@
+import type { Semantic } from "./semantic";
 import { type Consumer, type Functional, type MaybeInvalid, type Predicate, type Runnable } from "./utility";
 export declare class Optional<T> {
     protected value: MaybeInvalid<T>;
@@ -11,6 +12,7 @@ export declare class Optional<T> {
     isEmpty(): boolean;
     isPresent(): boolean;
     map<R>(mapper: Functional<T, R>): Optional<R>;
+    semantic(): Semantic<T>;
     static empty<T>(): Optional<T>;
     static of<T>(value: MaybeInvalid<T>): Optional<T>;
     static ofNullable<T>(value?: MaybeInvalid<T>): Optional<T>;

package/dist/optional.js

@@ -1,3 +1,4 @@
+import { empty, generate } from "./factory";
 import { isFunction } from "./guard";
 import { OptionalSymbol } from "./symbol";
 import { invalidate, validate } from "./utility";
@@ -46,6 +47,16 @@ export class Optional {
         }
         return new Optional(null);
     }
+    semantic() {
+        if (this.isPresent()) {
+            return generate(() => {
+                return this.value;
+            }, () => {
+                return this.isEmpty();
+            });
+        }
+        return empty();
+    }
     static empty() {
         return new Optional(null);
     }

package/dist/utility.d.ts

@@ -6,6 +6,12 @@ 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 type AsyncFunction = (...args: any[]) => Promise<unknown>;
+export type DeepPropertyKey<T extends object> = {
+    [K in keyof T]: T[K] extends object ? DeepPropertyKey<T[K]> : K;
+};
+export type DeepPropertyValue<T extends object> = {
+    [K in keyof T]: T[K] extends object ? DeepPropertyValue<T[K]> : T[K];
+};
 export interface Runnable {
     (): void;
 }

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