semantic-typescript 0.5.3 → 0.7.0

package/dist/factory.d.ts

@@ -1,79 +1,121 @@
+import { AsynchronousSemantic } from "./asynchronous/semantic";
 import { Optional } from "./optional";
-import { Semantic } from "./semantic";
-import type { BiPredicate, Predicate, Supplier, Generator, MaybeInvalid } from "./utility";
+import { SynchronousSemantic } from "./synchronous/semantic";
+import type { BiPredicate, Predicate, Supplier, MaybeInvalid, SynchronousGenerator } from "./utility";
 interface UseAnimationFrame {
-    (period: number): Semantic<number>;
-    (period: number, delay: number): Semantic<number>;
+    (period: number): SynchronousSemantic<number>;
+    (period: number, delay: number): SynchronousSemantic<number>;
 }
 export declare let useAnimationFrame: UseAnimationFrame;
 interface Attribute<T> {
     key: keyof T;
     value: T[keyof T];
 }
-export declare let useAttribute: <T extends object>(target: T) => Semantic<Attribute<T>>;
+export declare let useAttribute: <T extends object>(target: T) => SynchronousSemantic<Attribute<T>>;
 interface UseBlob {
-    (blob: Blob): Semantic<Uint8Array>;
-    (blob: Blob, chunk: bigint): Semantic<Uint8Array>;
+    (blob: Blob): SynchronousSemantic<Uint8Array>;
+    (blob: Blob, chunk: bigint): SynchronousSemantic<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]>;
+    <K extends keyof DocumentEventMap, V extends DocumentEventMap[K]>(key: K): AsynchronousSemantic<V>;
+    <K extends keyof DocumentEventMap, V extends DocumentEventMap[K]>(key: Iterable<K>): AsynchronousSemantic<V>;
 }
 export declare let useDocument: UseDocument;
+interface UseHTMLElementOptions {
+    throttle?: number;
+    debounce?: number;
+}
 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]>;
+    <E extends HTMLElement, K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(element: E, key: K): AsynchronousSemantic<V>;
+    <E extends HTMLElement, K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(element: E, key: K, options: UseHTMLElementOptions): AsynchronousSemantic<V>;
+    <E extends HTMLElement, K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(element: E, keys: Iterable<K>): AsynchronousSemantic<V>;
+    <E extends HTMLElement, K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(element: E, keys: Iterable<K>, options: UseHTMLElementOptions): AsynchronousSemantic<V>;
+    <E extends HTMLElement, K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(elements: Iterable<E>, key: K): AsynchronousSemantic<V>;
+    <E extends HTMLElement, K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(elements: Iterable<E>, key: K, options: UseHTMLElementOptions): AsynchronousSemantic<V>;
+    <E extends HTMLElement, K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(elements: Iterable<E>, keys: Iterable<K>): AsynchronousSemantic<V>;
+    <E extends HTMLElement, K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(elements: Iterable<E>, keys: Iterable<K>, options: UseHTMLElementOptions): AsynchronousSemantic<V>;
+    <K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(selector: string, key: K): AsynchronousSemantic<V>;
+    <K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(selector: string, key: K, options: UseHTMLElementOptions): AsynchronousSemantic<V>;
+    <S extends keyof HTMLElementTagNameMap, K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(selector: S, key: K): AsynchronousSemantic<V>;
+    <S extends keyof HTMLElementTagNameMap, K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(selector: S, key: K, options: UseHTMLElementOptions): AsynchronousSemantic<V>;
+    <K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(selector: string, keys: Iterable<K>): AsynchronousSemantic<V>;
+    <K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(selector: string, keys: Iterable<K>, options: UseHTMLElementOptions): AsynchronousSemantic<V>;
+    <S extends keyof HTMLElementTagNameMap, K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(selector: S, keys: Iterable<K>): AsynchronousSemantic<V>;
+    <S extends keyof HTMLElementTagNameMap, K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(selector: S, keys: Iterable<K>, options: UseHTMLElementOptions): AsynchronousSemantic<V>;
+    <K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(selectors: Iterable<string>, key: K): AsynchronousSemantic<V>;
+    <K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(selectors: Iterable<string>, key: K, options: UseHTMLElementOptions): AsynchronousSemantic<V>;
+    <S extends keyof HTMLElementTagNameMap, K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(selectors: Iterable<S>, key: K): AsynchronousSemantic<V>;
+    <S extends keyof HTMLElementTagNameMap, K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(selectors: Iterable<S>, key: K, options: UseHTMLElementOptions): AsynchronousSemantic<V>;
+    <K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(selectors: Iterable<string>, keys: Iterable<K>): AsynchronousSemantic<V>;
+    <K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(selectors: Iterable<string>, keys: Iterable<K>, options: UseHTMLElementOptions): AsynchronousSemantic<V>;
+    <S extends keyof HTMLElementTagNameMap, K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(selectors: Iterable<S>, keys: Iterable<K>): AsynchronousSemantic<V>;
+    <S extends keyof HTMLElementTagNameMap, K extends keyof HTMLElementEventMap, V extends HTMLElementEventMap[K]>(selectors: Iterable<S>, keys: Iterable<K>, options: UseHTMLElementOptions): AsynchronousSemantic<V>;
 }
 export declare let useHTMLElement: UseHTMLElement;
-export declare let useEmpty: <E>() => Semantic<E>;
+export declare let useEmpty: <E>() => SynchronousSemantic<E>;
 interface UseFill {
-    <E>(element: E, count: bigint): Semantic<E>;
-    <E>(supplier: Supplier<E>, count: bigint): Semantic<E>;
+    <E>(element: E, count: bigint): SynchronousSemantic<E>;
+    <E>(supplier: Supplier<E>, count: bigint): SynchronousSemantic<E>;
 }
 export declare let useFill: UseFill;
 export interface UseFrom {
-    <E>(iterable: Iterable<E>): Semantic<E>;
-    <E>(iterable: AsyncIterable<E>): Semantic<E>;
+    <E>(iterable: Iterable<E>): SynchronousSemantic<E>;
+    <E>(iterable: AsyncIterable<E>): SynchronousSemantic<E>;
 }
 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>;
+    <E>(supplier: Supplier<E>, interrupt: Predicate<E>): SynchronousSemantic<E>;
+    <E>(supplier: Supplier<E>, interrupt: BiPredicate<E, bigint>): SynchronousSemantic<E>;
 }
 export declare let useGenerate: UseGenerate;
 interface UseInterval {
-    (period: number): Semantic<number>;
-    (period: number, delay: number): Semantic<number>;
+    (period: number): SynchronousSemantic<number>;
+    (period: number, delay: number): SynchronousSemantic<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>);
+export declare let useIterate: <E>(generator: SynchronousGenerator<E>) => SynchronousSemantic<E>;
+export declare let usePromise: (<T>(promise: Promise<T>) => SynchronousSemantic<T>);
 interface UseOf {
-    <E>(target: E): Semantic<E>;
-    <E>(target: Iterable<E>): Semantic<E>;
+    <E>(target: E): SynchronousSemantic<E>;
+    <E>(target: Iterable<E>): SynchronousSemantic<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)>;
+    <N extends number | bigint>(start: N, end: N): SynchronousSemantic<N extends number ? number : (N extends bigint ? bigint : never)>;
+    <N extends number | bigint>(start: N, end: N, step: N): SynchronousSemantic<N extends number ? number : (N extends bigint ? bigint : never)>;
 }
 export declare let useRange: UseRange;
+interface UseText {
+    (text: string): SynchronousSemantic<string>;
+    (text: string, start: number): SynchronousSemantic<string>;
+    (text: string, start: number, end: number): SynchronousSemantic<string>;
+    (text: string, start: bigint): SynchronousSemantic<string>;
+    (text: string, start: bigint, end: bigint): SynchronousSemantic<string>;
+}
+export declare let useText: UseText;
+interface UseWebSocketOptions {
+    throttle?: number;
+    debounce?: number;
+}
 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]>;
+    (websocket: WebSocket): AsynchronousSemantic<WebSocketEventMap[keyof WebSocketEventMap]>;
+    (websocket: WebSocket, options: UseWebSocketOptions): AsynchronousSemantic<WebSocketEventMap[keyof WebSocketEventMap]>;
+    <K extends keyof WebSocketEventMap, V extends WebSocketEventMap[K]>(websocket: WebSocket, key: K): AsynchronousSemantic<V>;
+    <K extends keyof WebSocketEventMap, V extends WebSocketEventMap[K]>(websocket: WebSocket, key: K, options: UseWebSocketOptions): AsynchronousSemantic<V>;
+    <K extends keyof WebSocketEventMap, V extends WebSocketEventMap[K]>(websocket: WebSocket, keys: Iterable<K>): AsynchronousSemantic<V>;
+    <K extends keyof WebSocketEventMap, V extends WebSocketEventMap[K]>(websocket: WebSocket, keys: Iterable<K>, options: UseWebSocketOptions): AsynchronousSemantic<V>;
 }
 export declare let useWebSocket: UseWebSocket;
+interface UseWindowOptions {
+    throttle?: number;
+    debounce?: number;
+}
 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]>;
+    <K extends keyof WindowEventMap, V extends WindowEventMap[K]>(key: K): AsynchronousSemantic<V>;
+    <K extends keyof WindowEventMap, V extends WindowEventMap[K]>(key: K, options: UseWindowOptions): AsynchronousSemantic<V>;
+    <K extends keyof WindowEventMap, V extends WindowEventMap[K]>(keys: Iterable<K>): AsynchronousSemantic<V>;
+    <K extends keyof WindowEventMap, V extends WindowEventMap[K]>(keys: Iterable<K>, options: UseWindowOptions): AsynchronousSemantic<V>;
 }
 export declare let useWindow: UseWindow;
 export declare let useNullable: <T>(target: MaybeInvalid<T>) => Optional<T>;