semantic-typescript 0.5.0 → 0.5.3

package/dist/collector.d.ts

@@ -1,8 +1,6 @@
-import type { Collectable } from "./collectable";
-import { HashMap } from "./map";
+import { Collectable } from "./semantic";
 import { Optional } from "./optional";
 import type { Semantic } from "./semantic";
-import { HashSet } from "./set";
 import { type BiFunctional, type BiPredicate, type Functional, type Predicate, type Supplier, type TriFunctional, type Generator, type TriPredicate, type Consumer, type BiConsumer, type Comparator } from "./utility";
 export declare class Collector<E, A, R> {
     protected identity: Supplier<A>;
@@ -137,14 +135,7 @@ interface UseToMap {
     <E, K, V>(keyExtractor: BiFunctional<E, bigint, K>, valueExtractor: BiFunctional<E, bigint, V>): Collector<E, Map<K, V>, Map<K, V>>;
 }
 export declare let useToMap: UseToMap;
-interface UseToHashMap {
-    <E, K>(keyExtractor: Functional<E, K>): Collector<E, HashMap<K, E>, HashMap<K, E>>;
-    <E, K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>): Collector<E, HashMap<K, V>, HashMap<K, V>>;
-    <E, K, V>(keyExtractor: BiFunctional<E, bigint, K>, valueExtractor: BiFunctional<E, bigint, V>): Collector<E, HashMap<K, V>, HashMap<K, V>>;
-}
-export declare let useToHashMap: UseToHashMap;
 export declare let useToSet: <E>() => Collector<E, Set<E>, Set<E>>;
-export declare let useToHashSet: <E>() => Collector<E, HashSet<E>, HashSet<E>>;
 interface UseWrite {
     <E, S = string>(stream: WritableStream<S>): Collector<E, Promise<WritableStream<S>>, Promise<WritableStream<S>>>;
     <E, S = string>(stream: WritableStream<S>, accumulator: BiFunctional<WritableStream<S>, E, WritableStream<S>>): Collector<E, Promise<WritableStream<S>>, Promise<WritableStream<S>>>;

package/dist/collector.js

@@ -1,8 +1,7 @@
+import { Collectable } from "./semantic";
 import { isBigInt, isBoolean, isCollectable, isFunction, isIterable, isNumber, isObject, isSemantic, isString } from "./guard";
 import { useCompare, useToBigInt, useToNumber } from "./hook";
-import { HashMap } from "./map";
 import { Optional } from "./optional";
-import { HashSet } from "./set";
 import { CollectableSymbol } from "./symbol";
 import { validate, invalidate } from "./utility";
 export class Collector {
@@ -451,30 +450,12 @@ export let useToMap = (keyExtractor, valueExtractor = (element) => element) => {
     }
     throw new TypeError("Key extractor and value extractor must be functions.");
 };
-;
-export let useToHashMap = (keyExtractor, valueExtractor = (element) => element) => {
-    if (isFunction(keyExtractor) && isFunction(valueExtractor)) {
-        return Collector.full(() => new HashMap(), (map, element, index) => {
-            let key = keyExtractor(element, index);
-            let value = valueExtractor(element, index);
-            map.set(key, value);
-            return map;
-        }, (map) => map);
-    }
-    throw new TypeError("Key extractor and value extractor must be functions.");
-};
 export let useToSet = () => {
     return Collector.full(() => new Set(), (set, element) => {
         set.add(element);
         return set;
     }, (set) => set);
 };
-export let useToHashSet = () => {
-    return Collector.full(() => new HashSet(), (set, element) => {
-        set.add(element);
-        return set;
-    }, (set) => set);
-};
 ;
 export let useWrite = (argument1, argument2) => {
     if (isObject(argument1)) {

package/dist/factory.d.ts

@@ -1,37 +1,81 @@
+import { Optional } from "./optional";
 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>>;
+import type { BiPredicate, Predicate, Supplier, Generator, MaybeInvalid } from "./utility";
+interface UseAnimationFrame {
+    (period: number): Semantic<number>;
+    (period: number, delay: number): Semantic<number>;
+}
+export declare let useAnimationFrame: UseAnimationFrame;
 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>;
-type KeyOfEventMap<T extends Window | Document | HTMLElement> = T extends Window ? keyof WindowEventMap : (T extends Document ? keyof DocumentEventMap : (T extends HTMLElement ? keyof HTMLElementEventMap : never));
-type ValueOfEventMap<T extends Window | Document | HTMLElement, K extends KeyOfEventMap<T>> = T extends Window ? (K extends keyof WindowEventMap ? WindowEventMap[K] : never) : (T extends Document ? (K extends keyof DocumentEventMap ? DocumentEventMap[K] : never) : (T extends HTMLElement ? (K extends keyof HTMLElementEventMap ? HTMLElementEventMap[K] : never) : never));
-interface EventFunction {
-    <E extends Window, K extends KeyOfEventMap<E>, V = ValueOfEventMap<E, K>>(target: E, key: K): Semantic<V>;
-    <E extends Window, K extends KeyOfEventMap<E>, V = ValueOfEventMap<E, K>>(target: E, key: Iterable<K>): Semantic<V>;
-    <E extends Document, K extends KeyOfEventMap<E>, V = ValueOfEventMap<E, K>>(target: E, key: K): Semantic<V>;
-    <E extends Document, K extends KeyOfEventMap<E>, V = ValueOfEventMap<E, K>>(target: E, key: Iterable<K>): Semantic<V>;
-    <E extends Document, K extends KeyOfEventMap<E>, V = ValueOfEventMap<E, K>>(target: E, key: Iterable<K>): Semantic<V>;
-    <E extends HTMLElement, K extends KeyOfEventMap<E>, V = ValueOfEventMap<E, K>>(target: E, key: K): Semantic<V>;
-    <E extends HTMLElement, K extends KeyOfEventMap<E>, V = ValueOfEventMap<E, K>>(target: E, key: Iterable<K>): Semantic<V>;
-    <E extends HTMLElement, K extends KeyOfEventMap<E>, V = ValueOfEventMap<E, K>>(target: Iterable<E>, key: K): Semantic<V>;
-    <E extends HTMLElement, K extends KeyOfEventMap<E>, V = ValueOfEventMap<E, K>>(target: Iterable<E>, key: Iterable<K>): Semantic<V>;
-}
-export declare let event: EventFunction;
-export declare let fill: (<E>(element: E, count: bigint) => Semantic<E>) & (<E>(supplier: Supplier<E>, count: bigint) => Semantic<E>);
-export interface From {
+export declare let useAttribute: <T extends object>(target: T) => Semantic<Attribute<T>>;
+interface UseBlob {
+    (blob: Blob): Semantic<Uint8Array>;
+    (blob: Blob, chunk: bigint): Semantic<Uint8Array>;
+}
+export declare let useBlob: UseBlob;
+interface UseDocument {
+    <K extends keyof DocumentEventMap>(key: K): Semantic<DocumentEventMap[K extends keyof DocumentEventMap ? K : never]>;
+    <K extends keyof DocumentEventMap>(key: Iterable<K>): Semantic<DocumentEventMap[K extends keyof DocumentEventMap ? K : never]>;
+}
+export declare let useDocument: UseDocument;
+interface UseHTMLElement {
+    <E extends HTMLElement, K extends keyof HTMLElementEventMap>(element: E, key: K): Semantic<HTMLElementEventMap[K extends keyof HTMLElementEventMap ? K : never]>;
+    <E extends HTMLElement, K extends keyof HTMLElementEventMap>(element: E, keys: Iterable<K>): Semantic<HTMLElementEventMap[K extends keyof HTMLElementEventMap ? K : never]>;
+    <E extends HTMLElement, K extends keyof HTMLElementEventMap>(elements: Iterable<E>, key: K): Semantic<HTMLElementEventMap[K extends keyof HTMLElementEventMap ? K : never]>;
+    <E extends HTMLElement, K extends keyof HTMLElementEventMap>(elements: Iterable<E>, keys: Iterable<K>): Semantic<HTMLElementEventMap[K extends keyof HTMLElementEventMap ? K : never]>;
+    <S extends keyof HTMLElementTagNameMap, K extends keyof HTMLElementEventMap>(selector: S, key: K): Semantic<HTMLElementEventMap[K extends keyof HTMLElementEventMap ? K : never]>;
+    <S extends keyof HTMLElementTagNameMap, K extends keyof HTMLElementEventMap>(selector: S, keys: Iterable<K>): Semantic<HTMLElementEventMap[K extends keyof HTMLElementEventMap ? K : never]>;
+    <S extends keyof HTMLElementTagNameMap, K extends keyof HTMLElementEventMap>(selectors: Iterable<S>, key: K): Semantic<HTMLElementEventMap[K extends keyof HTMLElementEventMap ? K : never]>;
+    <S extends keyof HTMLElementTagNameMap, K extends keyof HTMLElementEventMap>(selectors: Iterable<S>, keys: Iterable<K>): Semantic<HTMLElementEventMap[K extends keyof HTMLElementEventMap ? K : never]>;
+}
+export declare let useHTMLElement: UseHTMLElement;
+export declare let useEmpty: <E>() => Semantic<E>;
+interface UseFill {
+    <E>(element: E, count: bigint): Semantic<E>;
+    <E>(supplier: Supplier<E>, count: bigint): Semantic<E>;
+}
+export declare let useFill: UseFill;
+export interface UseFrom {
     <E>(iterable: Iterable<E>): Semantic<E>;
     <E>(iterable: AsyncIterable<E>): Semantic<E>;
 }
-export declare let from: From;
-export declare let generate: (<E>(supplier: Supplier<E>, interrupt: Predicate<E>) => Semantic<E>) & (<E>(supplier: Supplier<E>, interrupt: BiPredicate<E, bigint>) => Semantic<E>);
-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 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 declare let useFrom: UseFrom;
+interface UseGenerate {
+    <E>(supplier: Supplier<E>, interrupt: Predicate<E>): Semantic<E>;
+    <E>(supplier: Supplier<E>, interrupt: BiPredicate<E, bigint>): Semantic<E>;
+}
+export declare let useGenerate: UseGenerate;
+interface UseInterval {
+    (period: number): Semantic<number>;
+    (period: number, delay: number): Semantic<number>;
+}
+export declare let useInterval: UseInterval;
+export declare let useIterate: <E>(generator: Generator<E>) => Semantic<E>;
+export declare let usePromise: (<T>(promise: Promise<T>) => Semantic<T>);
+interface UseOf {
+    <E>(target: E): Semantic<E>;
+    <E>(target: Iterable<E>): Semantic<E>;
+}
+export declare let useOf: UseOf;
+interface UseRange {
+    <N extends number | bigint>(start: N, end: N): Semantic<N extends number ? number : (N extends bigint ? bigint : never)>;
+    <N extends number | bigint>(start: N, end: N, step: N): Semantic<N extends number ? number : (N extends bigint ? bigint : never)>;
+}
+export declare let useRange: UseRange;
+interface UseWebSocket {
+    (websocket: WebSocket): Semantic<WebSocketEventMap[keyof WebSocketEventMap]>;
+    <K extends keyof WebSocketEventMap>(websocket: WebSocket, key: K): Semantic<WebSocketEventMap[K extends keyof WebSocketEventMap ? K : never]>;
+    <K extends keyof WebSocketEventMap>(websocket: WebSocket, keys: Iterable<K>): Semantic<WebSocketEventMap[K extends keyof WebSocketEventMap ? K : never]>;
+}
+export declare let useWebSocket: UseWebSocket;
+interface UseWindow {
+    <K extends keyof WindowEventMap>(key: K): Semantic<WindowEventMap[K extends keyof WindowEventMap ? K : never]>;
+    <K extends keyof WindowEventMap>(key: Iterable<K>): Semantic<WindowEventMap[K extends keyof WindowEventMap ? K : never]>;
+}
+export declare let useWindow: UseWindow;
+export declare let useNullable: <T>(target: MaybeInvalid<T>) => Optional<T>;
+export declare let useNonNull: <T>(target: T) => Optional<T>;
 export {};