semantic-typescript 0.7.0 → 0.8.0

package/dist/asynchronous/semantic.d.ts

@@ -24,10 +24,14 @@ export declare class AsynchronousSemantic<E> {
     flatMap<R>(mapper: BiFunctional<E, bigint, AsynchronousSemantic<R>>): AsynchronousSemantic<R>;
     limit(count: number): AsynchronousSemantic<E>;
     limit(count: bigint): AsynchronousSemantic<E>;
+    map(mapper: Functional<E, E>): AsynchronousSemantic<E>;
+    map(mapper: BiFunctional<E, bigint, E>): AsynchronousSemantic<E>;
     map<R>(mapper: Functional<E, R>): AsynchronousSemantic<R>;
     map<R>(mapper: BiFunctional<E, bigint, R>): AsynchronousSemantic<R>;
     peek(consumer: Consumer<E>): AsynchronousSemantic<E>;
     peek(consumer: BiConsumer<E, bigint>): AsynchronousSemantic<E>;
+    pipe(conversion: Functional<AsynchronousGenerator<E>, AsynchronousSemantic<E>>): AsynchronousSemantic<E>;
+    pipe<R>(conversion: Functional<AsynchronousGenerator<E>, AsynchronousSemantic<R>>): AsynchronousSemantic<R>;
     redirect(redirector: BiFunctional<E, bigint, bigint>): AsynchronousSemantic<E>;
     reverse(): AsynchronousSemantic<E>;
     shuffle(): AsynchronousSemantic<E>;

package/dist/asynchronous/semantic.js

@@ -285,6 +285,9 @@ export class AsynchronousSemantic {
         }
         throw new TypeError("Invalid arguments.");
     }
+    pipe(conversion) {
+        return conversion(this.source());
+    }
     redirect(redirector) {
         if (isFunction(redirector)) {
             return new AsynchronousSemantic(async (accept, interrupt) => {

package/dist/factory.d.ts

@@ -1,12 +1,6 @@
 import { AsynchronousSemantic } from "./asynchronous/semantic";
-import { Optional } from "./optional";
 import { SynchronousSemantic } from "./synchronous/semantic";
-import type { BiPredicate, Predicate, Supplier, MaybeInvalid, SynchronousGenerator } from "./utility";
-interface UseAnimationFrame {
-    (period: number): SynchronousSemantic<number>;
-    (period: number, delay: number): SynchronousSemantic<number>;
-}
-export declare let useAnimationFrame: UseAnimationFrame;
+import type { BiPredicate, Predicate, Supplier, Consumer } from "./utility";
 interface Attribute<T> {
     key: keyof T;
     value: T[keyof T];
@@ -17,42 +11,6 @@ interface UseBlob {
     (blob: Blob, chunk: bigint): SynchronousSemantic<Uint8Array>;
 }
 export declare let useBlob: UseBlob;
-interface UseDocument {
-    <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, 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>() => SynchronousSemantic<E>;
 interface UseFill {
     <E>(element: E, count: bigint): SynchronousSemantic<E>;
@@ -74,8 +32,28 @@ interface UseInterval {
     (period: number, delay: number): SynchronousSemantic<number>;
 }
 export declare let useInterval: UseInterval;
-export declare let useIterate: <E>(generator: SynchronousGenerator<E>) => SynchronousSemantic<E>;
-export declare let usePromise: (<T>(promise: Promise<T>) => SynchronousSemantic<T>);
+interface UseIterate {
+    <E>(iterable: Iterable<E>): SynchronousSemantic<E>;
+    <E>(iterable: AsyncIterable<E>): AsynchronousSemantic<E>;
+}
+export declare let useIterate: UseIterate;
+interface UsePromise {
+    <T>(promise: Promise<T>): AsynchronousSemantic<T>;
+}
+export declare let usePromise: UsePromise;
+export type KeyOfEventMap<EventMap> = keyof EventMap;
+export type EventOfEventMap<EventMap, K extends KeyOfEventMap<EventMap> = KeyOfEventMap<EventMap>> = EventMap[K];
+export interface Subscriber<T, EventMap> {
+    mount(target: T): void;
+    subscribe<K extends KeyOfEventMap<EventMap>>(key: K, accept: Consumer<EventOfEventMap<EventMap, K>>): void;
+    unsubscribe<K extends KeyOfEventMap<EventMap>>(key: K, accept: Consumer<EventOfEventMap<EventMap, K>>): void;
+    unmount(): void;
+}
+interface UseSubscription {
+    <T, EventMap, K extends KeyOfEventMap<EventMap> = KeyOfEventMap<EventMap>>(target: T, subscriber: Supplier<Subscriber<T, EventMap>>, subscription: K): AsynchronousSemantic<EventOfEventMap<EventMap, K>>;
+    <T, EventMap, K extends KeyOfEventMap<EventMap> = KeyOfEventMap<EventMap>>(target: T, subscriber: Supplier<Subscriber<T, EventMap>>, subscription: Iterable<K>): AsynchronousSemantic<EventOfEventMap<EventMap, K>>;
+}
+export declare let useSubscription: UseSubscription;
 interface UseOf {
     <E>(target: E): SynchronousSemantic<E>;
     <E>(target: Iterable<E>): SynchronousSemantic<E>;
@@ -88,36 +66,11 @@ interface UseRange {
 export declare let useRange: UseRange;
 interface UseText {
     (text: string): SynchronousSemantic<string>;
+    (text: string, delimeter: 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): 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, 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>;
-export declare let useNonNull: <T>(target: T) => Optional<T>;
 export {};