evt - npm Package Compare versions

Comparing version 2.2.2 to 2.3.0

lib/Evt.asNonPostable.d.ts

@@ -1,3 +0,3 @@
-import type { ToNonPostableEvt, EvtLike } from "./types";
+import type { ToNonPostableEvt, NonPostableEvtLike } from "./types";
 /** https://docs.evt.land/api/evt/asnonpostable */
-export declare function asNonPostable<E extends EvtLike<any>>(evt: E): ToNonPostableEvt<E>;
+export declare function asNonPostable<E extends NonPostableEvtLike<any>>(evt: E): ToNonPostableEvt<E>;

lib/Evt.asPostable.d.ts

@@ -1,2 +0,2 @@
-import type { EvtLike, ToPostableEvt } from "./types";
+import type { NonPostableEvtLike, ToPostableEvt } from "./types";
 /**
@@ -6,2 +6,2 @@ * https://docs.evt.land/api/evt/aspostable
  * */
-export declare function asPostable<E extends EvtLike<any>>(evt: E): ToPostableEvt<E>;
+export declare function asPostable<E extends NonPostableEvtLike<any>>(evt: E): ToPostableEvt<E>;

lib/Evt.asyncPipe.d.ts

 import type { Evt } from "./Evt";
-import type { StatefulEvt, StatefulReadonlyEvt, NonPostableEvt, UnpackEvt } from "./types";
+import type { StatefulEvt, UnpackEvt, NonPostableEvtLike, StatefulReadonlyEvtLike } from "./types";
 import type { PromiseOrNot } from "tsafe/lab/PromiseOrNot";
-declare type EvtLike<T> = import("./types/helper").EvtLike<T> & {
-    attach(callback: (data: T) => void): void;
-};
 /**
@@ -20,3 +17,2 @@ * NOTE: Workaround until v2.0 where .pipe() will support async operators
  */
-export declare function asyncPipe<E extends EvtLike<any>, U>(evt: E, asyncOp: (data: UnpackEvt<E>) => PromiseOrNot<[U] | null>): E extends StatefulReadonlyEvt<any> ? StatefulEvt<U | undefined> : E extends NonPostableEvt<any> ? Evt<U> : EvtLike<U>;
-export {};
+export declare function asyncPipe<E extends NonPostableEvtLike<any>, U>(evt: E, asyncOp: (data: UnpackEvt<E>) => PromiseOrNot<[U] | null>): E extends StatefulReadonlyEvtLike<any> ? StatefulEvt<U | undefined> : Evt<U>;

lib/Evt.create.d.ts

@@ -1,2 +0,3 @@
-import type { Evt, StatefulEvt } from "./types";
+import type { Evt, StatefulEvt, NonPostableEvtLike, UnpackEvt } from "./types";
+export declare function create<E extends NonPostableEvtLike<any> | undefined = NonPostableEvtLike<void>>(): Evt<UnpackEvt<E>>;
 /**
@@ -6,3 +7,3 @@ * https://docs.evt.land/api/evt/create
  */
-export declare function create<T = void>(): Evt<T>;
+export declare function create<T>(): Evt<T>;
 /**
@@ -13,1 +14,2 @@ * https://docs.evt.land/api/evt/create
 export declare function create<T>(initialState: T): StatefulEvt<T>;
+export declare function create<E extends NonPostableEvtLike<any> | undefined>(initialState: UnpackEvt<E>): StatefulEvt<UnpackEvt<E>>;

lib/Evt.d.ts

@@ -12,3 +12,3 @@ import "minimal-polyfills/Array.prototype.find";
 import { loosenType } from "./Evt.loosenType";
-import type { Handler, EvtLike } from "./types";
+import type { Handler, NonPostableEvtLike } from "./types";
 /** https://docs.evt.land/api/evt */
@@ -24,3 +24,3 @@ export declare type Evt<T> = import("./types/interfaces/Evt").Evt<T>;
  */
-export declare const onAddHandlerByEvt: WeakMap<EvtLike<any>, (handler: Handler<any, any>, handlerTrigger: (opResult: readonly [any]) => PromiseLike<void> | undefined) => void>;
+export declare const onAddHandlerByEvt: WeakMap<NonPostableEvtLike<any>, (handler: Handler<any, any>, handlerTrigger: (opResult: readonly [any]) => PromiseLike<void> | undefined) => void>;
 export declare const Evt: {
@@ -27,0 +27,0 @@ new <T>(): Evt<T>;

lib/Evt.factorize.d.ts

@@ -1,3 +0,3 @@
-import type { FactorizeEvt, EvtLike } from "./types/helper";
+import type { FactorizeEvt, NonPostableEvtLike } from "./types";
 /** https://docs.evt.land/api/evt/factorize */
-export declare function factorize<E extends EvtLike<any>>(evt: E): FactorizeEvt<E>;
+export declare function factorize<E extends NonPostableEvtLike<any>>(evt: E): FactorizeEvt<E>;

lib/Evt.from.d.ts

@@ -1,2 +0,2 @@
-import type { dom, Evt, EvtLike } from "./types";
+import type { dom, Evt, NonPostableEvtLike } from "./types";
 import type { EventTargetLike } from "./types";
@@ -6,3 +6,3 @@ import type { ObserverConstructor } from "./types/Observer";
 declare type CtxLike<Result> = import("./types").CtxLike<Result> & {
-    evtDoneOrAborted: EvtLike<unknown> & {
+    evtDoneOrAborted: NonPostableEvtLike<unknown> & {
         postCount: number;
@@ -9,0 +9,0 @@ attachOnce(callback: () => void): void;

lib/Evt.loosenType.d.ts

@@ -1,5 +0,5 @@
-import type { SwapEvtType, UnpackEvt, EvtLike } from "./types";
+import type { SwapEvtType, UnpackEvt, NonPostableEvtLike } from "./types";
 /**
  * https://docs.evt.land/api/evt/loosenType
  */
-export declare function loosenType<E extends EvtLike<any>, SupersetOfT>(evt: E): UnpackEvt<E> extends SupersetOfT ? SwapEvtType<typeof evt, SupersetOfT> : "NOT A SUPERSET";
+export declare function loosenType<E extends NonPostableEvtLike<any>, SupersetOfT>(evt: E): UnpackEvt<E> extends SupersetOfT ? SwapEvtType<typeof evt, SupersetOfT> : "NOT A SUPERSET";

lib/Evt.merge.d.ts

@@ -1,9 +0,5 @@
-import type { UnpackEvt, Evt, CtxLike } from "./types";
-export declare type EvtLike<T> = import("./types/helper").EvtLike<T> & {
-    attach(ctx: CtxLike<any>, callback: (data: T) => void): void;
-    attach(callback: (data: T) => void): void;
-};
-export declare function mergeImpl<EvtUnion extends EvtLike<any>>(ctx: CtxLike<any> | undefined, evts: readonly EvtUnion[]): Evt<UnpackEvt<EvtUnion>>;
+import type { UnpackEvt, Evt, CtxLike, NonPostableEvtLike } from "./types";
+export declare function mergeImpl<EvtUnion extends NonPostableEvtLike<any>>(ctx: CtxLike<any> | undefined, evts: readonly EvtUnion[]): Evt<UnpackEvt<EvtUnion>>;
 /** https://docs.evt.land/api/evt/merge */
-export declare function merge<EvtUnion extends EvtLike<any>>(ctx: CtxLike<any>, evts: readonly EvtUnion[]): Evt<UnpackEvt<EvtUnion>>;
-export declare function merge<EvtUnion extends EvtLike<any>>(evts: readonly EvtUnion[]): Evt<UnpackEvt<EvtUnion>>;
+export declare function merge<EvtUnion extends NonPostableEvtLike<any>>(ctx: CtxLike<any>, evts: readonly EvtUnion[]): Evt<UnpackEvt<EvtUnion>>;
+export declare function merge<EvtUnion extends NonPostableEvtLike<any>>(evts: readonly EvtUnion[]): Evt<UnpackEvt<EvtUnion>>;

lib/types/Handler.d.ts

 import type { Operator } from "./Operator";
-import type { EvtLike } from "../types/helper";
-import type { CtxLike } from "../types/interfaces";
+import type { CtxLike, NonPostableEvtLike } from "../types/interfaces";
 /** https://docs.evt.land/api/handler */
@@ -45,4 +44,4 @@ export declare type Handler<T, U, CtxProp extends CtxLike<any> | undefined = CtxLike<any> | undefined> = Handler.PropsFromArgs<T, U, CtxProp> & Handler.PropsFromMethodName & Readonly<{
         handler: Handler<T, any, CtxLike<CtxResult>>;
-        evt: EvtLike<T>;
+        evt: NonPostableEvtLike<T>;
     };
 }

lib/types/helper/FactorizeEvt.d.ts

@@ -1,5 +0,5 @@
-import type { EvtLike } from "./EvtLike";
+import type { NonPostableEvtLike } from "../interfaces/NonPostableEvtLike";
 import type { SwapEvtType } from "./SwapEvtType";
 import type { UnpackEvt } from "./UnpackEvt";
 /** https://docs.evt.land/api/helpertypes#swapevttype-less-than-e-t-greater-than */
-export declare type FactorizeEvt<E extends EvtLike<any>> = SwapEvtType<E, UnpackEvt<E>>;
+export declare type FactorizeEvt<E extends NonPostableEvtLike<any>> = SwapEvtType<E, UnpackEvt<E>>;

lib/types/helper/index.d.ts

@@ -1,2 +0,1 @@
-export type { EvtLike } from "./EvtLike";
 export type { UnpackEvt } from "./UnpackEvt";
@@ -8,1 +7,2 @@ export type { FactorizeEvt } from "./FactorizeEvt";
 export type { UnpackCtx } from "./UnpackCtx";
+export type { EvtLikeToEvt } from "./EvtLikeToEvt";

lib/types/helper/SwapEvtType.d.ts

@@ -1,4 +0,3 @@
-import type { StatefulEvt, StatefulReadonlyEvt, Evt, NonPostableEvt } from "../interfaces";
-import type { EvtLike } from "./EvtLike";
+import type { StatefulEvtLike, StatefulEvt, StatefulReadonlyEvtLike, StatefulReadonlyEvt, EvtLike, Evt, NonPostableEvtLike, NonPostableEvt } from "../interfaces";
 /** https://docs.evt.land/api/helpertypes#swapevttype-less-than-e-t-greater-than */
-export declare type SwapEvtType<E extends EvtLike<any>, T> = E extends StatefulEvt<any> ? StatefulEvt<T> : E extends StatefulReadonlyEvt<any> ? StatefulReadonlyEvt<T> : E extends Evt<any> ? Evt<T> : E extends NonPostableEvt<any> ? NonPostableEvt<T> : EvtLike<T>;
+export declare type SwapEvtType<E extends NonPostableEvtLike<any>, T> = E extends StatefulEvtLike<any> ? StatefulEvt<T> : E extends StatefulReadonlyEvtLike<any> ? StatefulReadonlyEvt<T> : E extends EvtLike<any> ? Evt<T> : NonPostableEvt<T>;

lib/types/helper/ToNonPostableEvt.d.ts

@@ -1,8 +0,7 @@
-import type { EvtLike } from "./EvtLike";
-import type { StatefulPostable, NonPostableEvt, StatefulReadonlyEvt } from "../interfaces";
-declare type ToNonPostableEvtBase<E extends EvtLike<any>> = E extends StatefulReadonlyEvt<infer U> ? StatefulReadonlyEvt<U> : E extends NonPostableEvt<infer U> ? NonPostableEvt<U> : Omit<E, Exclude<keyof StatefulPostable<any>, "state">>;
+import type { StatefulReadonlyEvtLike, NonPostableEvtLike, NonPostableEvt, StatefulReadonlyEvt } from "../interfaces";
+declare type ToNonPostableEvtBase<E extends NonPostableEvt<any>> = E extends StatefulReadonlyEvtLike<infer U> ? StatefulReadonlyEvt<U> : E extends NonPostableEvtLike<infer U> ? NonPostableEvt<U> : never;
 declare type ToNonPostableEvtRecord<R extends {
     [key: string]: any;
 }> = {
-    [P in keyof R]: R[P] extends EvtLike<any> ? ToNonPostableEvtBase<R[P]> : R[P];
+    [P in keyof R]: R[P] extends NonPostableEvt<any> ? ToNonPostableEvtBase<R[P]> : R[P];
 };
@@ -12,3 +11,3 @@ /** https://docs.evt.land/api/helpertypes#tononpostableevt-less-than-e-greater-than */
     [key: string]: any;
-} | EvtLike<any>)> = E extends EvtLike<any> ? ToNonPostableEvtBase<E> : ToNonPostableEvtRecord<E>;
+} | NonPostableEvt<any>)> = E extends NonPostableEvt<any> ? ToNonPostableEvtBase<E> : ToNonPostableEvtRecord<E>;
 export {};

lib/types/helper/ToPostableEvt.d.ts

@@ -1,10 +0,7 @@
-import type { EvtLike } from "./EvtLike";
-import type { StatefulPostable, Postable, NonPostableEvt, StatefulReadonlyEvt, StatefulEvt, Evt } from "../interfaces";
-declare type ToPostableEvtBase<E extends EvtLike<any>> = E extends StatefulReadonlyEvt<infer U> ? StatefulEvt<U> : E extends NonPostableEvt<infer U> ? Evt<U> : E extends {
-    state: infer U;
-} ? E & StatefulPostable<U> : E & Postable<E>;
+import type { NonPostableEvtLike, StatefulReadonlyEvtLike, StatefulEvt, Evt } from "../interfaces";
+declare type ToPostableEvtBase<E extends NonPostableEvtLike<any>> = E extends StatefulReadonlyEvtLike<infer U> ? StatefulEvt<U> : E extends NonPostableEvtLike<infer U> ? Evt<U> : never;
 declare type ToPostableEvtRecord<R extends {
     [key: string]: any;
 }> = {
-    [P in keyof R]: R[P] extends EvtLike<any> ? ToPostableEvtBase<R[P]> : R[P];
+    [P in keyof R]: R[P] extends NonPostableEvtLike<any> ? ToPostableEvtBase<R[P]> : R[P];
 };
@@ -14,3 +11,3 @@ /** https://docs.evt.land/api/helpertypes#topostableevt-less-than-e-greater-than */
     [key: string]: any;
-} | EvtLike<any>)> = E extends EvtLike<any> ? ToPostableEvtBase<E> : ToPostableEvtRecord<E>;
+} | NonPostableEvtLike<any>)> = E extends NonPostableEvtLike<any> ? ToPostableEvtBase<E> : ToPostableEvtRecord<E>;
 export {};

lib/types/helper/UnpackEvt.d.ts

@@ -1,15 +0,15 @@
-import type { EvtLike } from "./EvtLike";
-declare type UnpackEvtBase<T extends EvtLike<any>> = T extends EvtLike<infer U> ? U : never;
+import type { NonPostableEvtLike } from "../interfaces/NonPostableEvtLike";
+declare type UnpackEvtBase<T extends NonPostableEvtLike<any>> = T extends NonPostableEvtLike<infer U> ? U : never;
 declare type UnpackEvtRecord<T extends {
     [key: string]: any;
 }> = {
-    [P in keyof T]: T[P] extends EvtLike<any> ? UnpackEvtBase<T[P]> : T[P];
+    [P in keyof T]: T[P] extends NonPostableEvtLike<any> ? UnpackEvtBase<T[P]> : T[P];
 };
 declare type UnpackNonNullableEvt<T extends ({
     [key: string]: any;
-} | EvtLike<any>)> = T extends EvtLike<any> ? UnpackEvtBase<T> : UnpackEvtRecord<T>;
+} | NonPostableEvtLike<any>)> = T extends NonPostableEvtLike<any> ? UnpackEvtBase<T> : UnpackEvtRecord<T>;
 /** https://docs.evt.land/api/helpertypes#unpackevt-less-than-e-greater-than */
 export declare type UnpackEvt<T extends ({
     [key: string]: any;
-} | EvtLike<any> | undefined | null)> = UnpackNonNullableEvt<NonNullable<T>>;
+} | NonPostableEvtLike<any> | undefined | null)> = UnpackNonNullableEvt<NonNullable<T>>;
 export {};

lib/types/interfaces/Ctx.d.ts

 import type { CtxLike } from "./CtxLike";
 import type { Handler } from "../Handler";
-import type { EvtLike } from "../helper";
+import type { NonPostableEvtLike } from "./NonPostableEvtLike";
 import type { Evt } from "./Evt";
@@ -74,3 +74,3 @@ export declare type DoneOrAborted<Result> = DoneOrAborted.Done<Result> | DoneOrAborted.Aborted<Result>;
      * */
-    zz__addHandler<T>(handler: Handler<T, any, CtxLike<Result>>, evt: EvtLike<T>): void;
+    zz__addHandler<T>(handler: Handler<T, any, CtxLike<Result>>, evt: NonPostableEvtLike<T>): void;
     /**
@@ -77,0 +77,0 @@ * Exposed to enable safe interoperability between EVT versions.

lib/types/interfaces/CtxLike.d.ts

@@ -1,2 +0,2 @@
-import type { EvtLike } from "../helper";
+import type { NonPostableEvtLike } from "./NonPostableEvtLike";
 import type { Handler } from "../Handler";
@@ -10,3 +10,3 @@ /**
     abort(error: Error): void;
-    zz__addHandler<T>(handler: Handler<T, any, CtxLike<Result>>, evt: EvtLike<T>): void;
+    zz__addHandler<T>(handler: Handler<T, any, CtxLike<Result>>, evt: NonPostableEvtLike<T>): void;
     zz__removeHandler<T>(handler: Handler<T, any, CtxLike<Result>>): void;
@@ -13,0 +13,0 @@ }

lib/types/interfaces/index.d.ts

@@ -9,1 +9,5 @@ export type { Ctx, DoneOrAborted } from "./Ctx";
 export type { StatefulPostable } from "./StatefulPostable";
+export type { EvtLike } from "./EvtLike";
+export type { NonPostableEvtLike } from "./NonPostableEvtLike";
+export type { StatefulReadonlyEvtLike } from "./StatefulReadonlyEvtLike";
+export type { StatefulEvtLike } from "./StatefulEvtLike";

package.json

 {
     "name": "evt",
-    "version": "2.2.2",
+    "version": "2.3.0",
     "description": "Type safe replacement for node's EventEmitter",
@@ -46,3 +46,3 @@ "repository": {
         "src/lib/types/Operator.ts",
-        "src/lib/types/helper/EvtLike.ts",
+        "src/lib/types/helper/EvtLikeToEvt.ts",
         "src/lib/types/helper/FactorizeEvt.ts",
@@ -59,7 +59,11 @@ "src/lib/types/helper/SwapEvtType.ts",
         "src/lib/types/interfaces/Evt.ts",
+        "src/lib/types/interfaces/EvtLike.ts",
         "src/lib/types/interfaces/NonPostableEvt.ts",
+        "src/lib/types/interfaces/NonPostableEvtLike.ts",
         "src/lib/types/interfaces/Postable.ts",
         "src/lib/types/interfaces/StatefulEvt.ts",
+        "src/lib/types/interfaces/StatefulEvtLike.ts",
         "src/lib/types/interfaces/StatefulPostable.ts",
         "src/lib/types/interfaces/StatefulReadonlyEvt.ts",
+        "src/lib/types/interfaces/StatefulReadonlyEvtLike.ts",
         "src/lib/types/interfaces/index.ts",
@@ -190,5 +194,5 @@ "src/lib/types/lib.dom.ts",
         "lib/types/Operator.js.map",
-        "lib/types/helper/EvtLike.d.ts",
-        "lib/types/helper/EvtLike.js",
-        "lib/types/helper/EvtLike.js.map",
+        "lib/types/helper/EvtLikeToEvt.d.ts",
+        "lib/types/helper/EvtLikeToEvt.js",
+        "lib/types/helper/EvtLikeToEvt.js.map",
         "lib/types/helper/FactorizeEvt.d.ts",
@@ -227,5 +231,11 @@ "lib/types/helper/FactorizeEvt.js",
         "lib/types/interfaces/Evt.js.map",
+        "lib/types/interfaces/EvtLike.d.ts",
+        "lib/types/interfaces/EvtLike.js",
+        "lib/types/interfaces/EvtLike.js.map",
         "lib/types/interfaces/NonPostableEvt.d.ts",
         "lib/types/interfaces/NonPostableEvt.js",
         "lib/types/interfaces/NonPostableEvt.js.map",
+        "lib/types/interfaces/NonPostableEvtLike.d.ts",
+        "lib/types/interfaces/NonPostableEvtLike.js",
+        "lib/types/interfaces/NonPostableEvtLike.js.map",
         "lib/types/interfaces/Postable.d.ts",
@@ -237,2 +247,5 @@ "lib/types/interfaces/Postable.js",
         "lib/types/interfaces/StatefulEvt.js.map",
+        "lib/types/interfaces/StatefulEvtLike.d.ts",
+        "lib/types/interfaces/StatefulEvtLike.js",
+        "lib/types/interfaces/StatefulEvtLike.js.map",
         "lib/types/interfaces/StatefulPostable.d.ts",
@@ -244,2 +257,5 @@ "lib/types/interfaces/StatefulPostable.js",
         "lib/types/interfaces/StatefulReadonlyEvt.js.map",
+        "lib/types/interfaces/StatefulReadonlyEvtLike.d.ts",
+        "lib/types/interfaces/StatefulReadonlyEvtLike.js",
+        "lib/types/interfaces/StatefulReadonlyEvtLike.js.map",
         "lib/types/interfaces/index.d.ts",
@@ -246,0 +262,0 @@ "lib/types/interfaces/index.js",

src/lib/Ctx.ts

@@ -11,3 +11,3 @@ import { Polyfill as Set } from "minimal-polyfills/Set";
     Handler, 
-    EvtLike,
+    NonPostableEvtLike,
     Evt,
@@ -117,3 +117,3 @@ CtxLike,
         Handler<any, any, Ctx<Result>>,
-        EvtLike<any>
+        NonPostableEvtLike<any>
     >();
@@ -130,3 +130,3 @@
         handler: Handler<T, any, CtxLike<Result>>,
-        evt: EvtLike<T>
+        evt: NonPostableEvtLike<T>
     ) {
@@ -133,0 +133,0 @@ assert(handler.ctx === this);

src/lib/Evt.asNonPostable.ts

 
-import type { ToNonPostableEvt, EvtLike } from "./types";
+import type { ToNonPostableEvt, NonPostableEvtLike } from "./types";
 
 /** https://docs.evt.land/api/evt/asnonpostable */
-export function asNonPostable<E extends EvtLike<any>>(evt: E): ToNonPostableEvt<E>{
+export function asNonPostable<E extends NonPostableEvtLike<any>>(evt: E): ToNonPostableEvt<E>{
     return evt as any;
 }

src/lib/Evt.asPostable.ts

@@ -1,2 +0,2 @@
-import type { EvtLike, ToPostableEvt} from "./types";
+import type { NonPostableEvtLike, ToPostableEvt } from "./types";
 
@@ -7,5 +7,5 @@ /**
  * */
-export function asPostable<E extends EvtLike<any>>(evt: E): ToPostableEvt<E>{
+export function asPostable<E extends NonPostableEvtLike<any>>(evt: E): ToPostableEvt<E>{
     return evt as any;
 }
 

src/lib/Evt.asyncPipe.ts

 
 import type { Evt } from "./Evt";
-import type { StatefulEvt, StatefulReadonlyEvt, NonPostableEvt, UnpackEvt } from "./types";
-import type { PromiseOrNot } from "tsafe/lab/PromiseOrNot";
+import type { StatefulEvt, UnpackEvt, NonPostableEvtLike, StatefulReadonlyEvtLike } from "./types";
+import type { PromiseOrNot } from "tsafe/lab/PromiseOrNot";
 import { importProxy } from "./importProxy";
 
-type EvtLike<T> = import("./types/helper").EvtLike<T> & {
-    attach(callback: (data: T) => void): void;
-};
 
@@ -25,9 +22,7 @@
  */
-export function asyncPipe<E extends EvtLike<any>, U>(
+export function asyncPipe<E extends NonPostableEvtLike<any>, U>(
     evt: E,
     asyncOp: (data: UnpackEvt<E>) => PromiseOrNot<[U] | null>
 ): 
-    E extends StatefulReadonlyEvt<any> ? StatefulEvt<U | undefined> :
-    E extends NonPostableEvt<any> ? Evt<U> :
-    EvtLike<U>
+    E extends StatefulReadonlyEvtLike<any> ? StatefulEvt<U | undefined> : Evt<U> 
 {
@@ -34,0 +29,0 @@

src/lib/Evt.create.ts

 
 import { importProxy } from "./importProxy";
-import type { Evt, StatefulEvt } from "./types";
+import type { Evt, StatefulEvt, NonPostableEvtLike, UnpackEvt } from "./types";
 
+export function create<E extends NonPostableEvtLike<any> | undefined = NonPostableEvtLike<void>>(): Evt<UnpackEvt<E>>;
 /** 
@@ -9,3 +10,3 @@ * https://docs.evt.land/api/evt/create
  */
-export function create<T = void>(): Evt<T>;
+export function create<T>(): Evt<T>;
 /** 
@@ -15,3 +16,4 @@ * https://docs.evt.land/api/evt/create
  */
-export function create<T>(initialState: T): StatefulEvt<T>;
+export function create<T>(initialState: T ): StatefulEvt<T>;
+export function create<E extends NonPostableEvtLike<any> | undefined>(initialState: UnpackEvt<E> ): StatefulEvt<UnpackEvt<E>>;
 export function create(...args: [] | [any] ): Evt<any> | StatefulEvt<any> {
@@ -18,0 +20,0 @@ return args.length === 0 ?

src/lib/Evt.factorize.ts

@@ -1,5 +0,5 @@
-import type { FactorizeEvt, EvtLike } from "./types/helper";
+import type { FactorizeEvt, NonPostableEvtLike } from "./types";
 
 /** https://docs.evt.land/api/evt/factorize */
-export function factorize<E extends EvtLike<any>>(
+export function factorize<E extends NonPostableEvtLike<any>>(
     evt: E
@@ -6,0 +6,0 @@ ): FactorizeEvt<E> {

src/lib/Evt.from.ts

@@ -6,3 +6,3 @@ import { id } from "tsafe/id";
 import { importProxy } from "./importProxy";
-import type { dom, Evt, EvtLike } from "./types";
+import type { dom, Evt, NonPostableEvtLike } from "./types";
 import type { EventTargetLike } from "./types";
@@ -15,3 +15,3 @@ import * as nsEventTargetLike from "./types/EventTargetLike";
 type CtxLike<Result> = import("./types").CtxLike<Result> & {
-    evtDoneOrAborted: EvtLike<unknown> & { postCount: number; attachOnce(callback: () => void): void; };
+    evtDoneOrAborted: NonPostableEvtLike<unknown> & { postCount: number; attachOnce(callback: () => void): void; };
 };
@@ -18,0 +18,0 @@

src/lib/Evt.loosenType.ts

@@ -1,2 +0,2 @@
-import type { SwapEvtType, UnpackEvt, EvtLike} from "./types";
+import type { SwapEvtType, UnpackEvt, NonPostableEvtLike} from "./types";
 
@@ -6,3 +6,3 @@ /**
  */
-export function loosenType<E extends EvtLike<any>, SupersetOfT>(
+export function loosenType<E extends NonPostableEvtLike<any>, SupersetOfT>(
     evt: E
@@ -9,0 +9,0 @@ ): UnpackEvt<E> extends SupersetOfT ?

src/lib/Evt.merge.ts

 
 import { importProxy } from "./importProxy";
-import type { UnpackEvt, Evt, CtxLike } from "./types";
+import type { UnpackEvt, Evt, CtxLike, NonPostableEvtLike } from "./types";
 
-
-export type EvtLike<T> = import("./types/helper").EvtLike<T> & {
-    attach(ctx: CtxLike<any>, callback: (data: T) => void): void;
-    attach(callback: (data: T) => void): void;
-};
-
-export function mergeImpl<EvtUnion extends EvtLike<any>>(
+export function mergeImpl<EvtUnion extends NonPostableEvtLike<any>>(
     ctx: CtxLike<any> | undefined,
@@ -39,10 +33,10 @@ evts: readonly EvtUnion[]
 /** https://docs.evt.land/api/evt/merge */
-export function merge<EvtUnion extends EvtLike<any>>(
+export function merge<EvtUnion extends NonPostableEvtLike<any>>(
     ctx: CtxLike<any>,
     evts: readonly EvtUnion[]
 ): Evt<UnpackEvt<EvtUnion>>;
-export function merge<EvtUnion extends EvtLike<any>>(
+export function merge<EvtUnion extends NonPostableEvtLike<any>>(
     evts: readonly EvtUnion[]
 ): Evt<UnpackEvt<EvtUnion>>;
-export function merge<EvtUnion extends EvtLike<any>>(
+export function merge<EvtUnion extends NonPostableEvtLike<any>>(
     p1: CtxLike<any> | readonly EvtUnion[],
@@ -49,0 +43,0 @@ p2?: readonly EvtUnion[]

src/lib/Evt.ts

@@ -25,3 +25,3 @@ import "minimal-polyfills/Array.prototype.find";
 import * as nsCtxLike from "./types/interfaces/CtxLike";
-import type { Handler, Operator, NonPostableEvt, StatefulEvt, EvtLike, CtxLike } from "./types";
+import type { Handler, Operator, NonPostableEvt, StatefulEvt, NonPostableEvtLike, CtxLike } from "./types";
 import { convertOperatorToStatelessFλ } from "./util/convertOperatorToStatelessFLambda";
@@ -1024,3 +1024,3 @@ import type { AsyncIterableEvt } from "./types/AsyncIterableEvt";
 export const onAddHandlerByEvt = new WeakMap<
-    EvtLike<any>,
+    NonPostableEvtLike<any>,
     (
@@ -1027,0 +1027,0 @@ handler: Handler<any, any>,

src/lib/types/Handler.ts

 import type { Operator } from "./Operator";
-import type { EvtLike } from "../types/helper";
-import type { CtxLike } from "../types/interfaces";
+import type { CtxLike, NonPostableEvtLike } from "../types/interfaces";
 
@@ -57,5 +56,5 @@ /** https://docs.evt.land/api/handler */
         handler: Handler<T, any, CtxLike<CtxResult>>;
-        evt: EvtLike<T>;
+        evt: NonPostableEvtLike<T>;
     };
 
 }

src/lib/types/helper/FactorizeEvt.ts

 
-import type { EvtLike } from "./EvtLike";
+import type { NonPostableEvtLike } from "../interfaces/NonPostableEvtLike";
 import type { SwapEvtType } from "./SwapEvtType";
@@ -7,3 +7,3 @@ import type { UnpackEvt } from "./UnpackEvt";
 /** https://docs.evt.land/api/helpertypes#swapevttype-less-than-e-t-greater-than */
-export type FactorizeEvt<E extends EvtLike<any>> = SwapEvtType<E, UnpackEvt<E>>;
+export type FactorizeEvt<E extends NonPostableEvtLike<any>> = SwapEvtType<E, UnpackEvt<E>>;
 

src/lib/types/helper/index.ts

@@ -1,2 +0,1 @@
-export type { EvtLike } from "./EvtLike";
 export type { UnpackEvt } from "./UnpackEvt";
@@ -8,2 +7,3 @@ export type { FactorizeEvt } from "./FactorizeEvt";
 export type { UnpackCtx } from "./UnpackCtx";
+export type { EvtLikeToEvt } from "./EvtLikeToEvt";
 

src/lib/types/helper/SwapEvtType.ts

@@ -1,12 +0,14 @@
-import type { StatefulEvt, StatefulReadonlyEvt, Evt, NonPostableEvt } from "../interfaces";
-import type { EvtLike } from "./EvtLike";
+import type {
+    StatefulEvtLike, StatefulEvt,
+    StatefulReadonlyEvtLike, StatefulReadonlyEvt,
+    EvtLike, Evt,
+    NonPostableEvtLike, NonPostableEvt
+} from "../interfaces";
 
-
 /** https://docs.evt.land/api/helpertypes#swapevttype-less-than-e-t-greater-than */
-export type SwapEvtType<E extends EvtLike<any>, T> =
-        E extends StatefulEvt<any> ? StatefulEvt<T> :
-        E extends StatefulReadonlyEvt<any> ? StatefulReadonlyEvt<T> :
-        E extends Evt<any> ? Evt<T> :
-        E extends NonPostableEvt<any> ? NonPostableEvt<T> :
-        EvtLike<T>
+export type SwapEvtType<E extends NonPostableEvtLike<any>, T> =
+    E extends StatefulEvtLike<any> ? StatefulEvt<T> :
+    E extends StatefulReadonlyEvtLike<any> ? StatefulReadonlyEvt<T> :
+    E extends EvtLike<any> ? Evt<T> :
+    NonPostableEvt<T>
     ;

src/lib/types/helper/ToNonPostableEvt.ts

 
-import type { EvtLike } from "./EvtLike";
-import type { StatefulPostable, NonPostableEvt, StatefulReadonlyEvt } from "../interfaces";
+import type {  StatefulReadonlyEvtLike, NonPostableEvtLike, NonPostableEvt, StatefulReadonlyEvt } from "../interfaces";
 
-type ToNonPostableEvtBase<E extends EvtLike<any>> =
-    E extends StatefulReadonlyEvt<infer U> ? StatefulReadonlyEvt<U> :
-    E extends NonPostableEvt<infer U> ? NonPostableEvt<U> :
-    Omit<E, Exclude<keyof StatefulPostable<any>, "state">>
+type ToNonPostableEvtBase<E extends NonPostableEvt<any>> =
+    E extends StatefulReadonlyEvtLike<infer U> ? StatefulReadonlyEvt<U> :
+    E extends NonPostableEvtLike<infer U> ? NonPostableEvt<U> : never
     ;
 
 type ToNonPostableEvtRecord<R extends { [key: string]: any; }> = {
-    [P in keyof R]: R[P] extends EvtLike<any> ? ToNonPostableEvtBase<R[P]> : R[P];
+    [P in keyof R]: R[P] extends NonPostableEvt<any> ? ToNonPostableEvtBase<R[P]> : R[P];
 };
 
 /** https://docs.evt.land/api/helpertypes#tononpostableevt-less-than-e-greater-than */
-export type ToNonPostableEvt<E extends ({ [key: string]: any; } | EvtLike<any>)> =
-    E extends EvtLike<any> ? ToNonPostableEvtBase<E> :
+export type ToNonPostableEvt<E extends ({ [key: string]: any; } | NonPostableEvt<any>)> =
+    E extends NonPostableEvt<any> ? ToNonPostableEvtBase<E> :
     ToNonPostableEvtRecord<E>
@@ -19,0 +17,0 @@ ;

src/lib/types/helper/ToPostableEvt.ts

 
-import type { EvtLike } from "./EvtLike";
 import type { 
-    StatefulPostable,
-    Postable, 
-    NonPostableEvt, 
-    StatefulReadonlyEvt, 
+    NonPostableEvtLike, 
+    StatefulReadonlyEvtLike, 
     StatefulEvt, 
-    Evt
+    Evt,
 } from "../interfaces";
 
 
-type ToPostableEvtBase<E extends EvtLike<any>> =
-        E extends StatefulReadonlyEvt<infer U> ? StatefulEvt<U> :
-        E extends NonPostableEvt<infer U> ? Evt<U> :
-        E extends { state: infer U } ? E & StatefulPostable<U> :
-        E & Postable<E>
+type ToPostableEvtBase<E extends NonPostableEvtLike<any>> =
+        E extends StatefulReadonlyEvtLike<infer U> ? StatefulEvt<U> :
+        E extends NonPostableEvtLike<infer U> ? Evt<U> : never
     ;
 
 type ToPostableEvtRecord<R extends { [key: string]: any; }> = {
-    [P in keyof R]: R[P] extends EvtLike<any> ? ToPostableEvtBase<R[P]> : R[P];
+    [P in keyof R]: R[P] extends NonPostableEvtLike<any> ? ToPostableEvtBase<R[P]> : R[P];
 };
 
 /** https://docs.evt.land/api/helpertypes#topostableevt-less-than-e-greater-than */
-export type ToPostableEvt<E extends ({ [key: string]: any; } | EvtLike<any>)> =
-    E extends EvtLike<any> ? ToPostableEvtBase<E> :
+export type ToPostableEvt<E extends ({ [key: string]: any; } | NonPostableEvtLike<any>)> =
+    E extends NonPostableEvtLike<any> ? ToPostableEvtBase<E> :
     ToPostableEvtRecord<E>
     ;
 

src/lib/types/helper/UnpackEvt.ts

 
-import type { EvtLike } from "./EvtLike";
+import type { NonPostableEvtLike } from "../interfaces/NonPostableEvtLike";
 
-type UnpackEvtBase<T extends EvtLike<any>> = T extends EvtLike<infer U> ? U : never;
+type UnpackEvtBase<T extends NonPostableEvtLike<any>> = T extends NonPostableEvtLike<infer U> ? U : never;
 
 type UnpackEvtRecord<T extends { [key: string]: any; }> = {
-    [P in keyof T]: T[P] extends EvtLike<any> ? UnpackEvtBase<T[P]> : T[P];
+    [P in keyof T]: T[P] extends NonPostableEvtLike<any> ? UnpackEvtBase<T[P]> : T[P];
 };
 
-type UnpackNonNullableEvt<T extends ({ [key: string]: any; } | EvtLike<any>)> =
-    T extends EvtLike<any> ? UnpackEvtBase<T> :
+type UnpackNonNullableEvt<T extends ({ [key: string]: any; } | NonPostableEvtLike<any>)> =
+    T extends NonPostableEvtLike<any> ? UnpackEvtBase<T> :
     UnpackEvtRecord<T>
@@ -16,3 +16,4 @@ ;
 /** https://docs.evt.land/api/helpertypes#unpackevt-less-than-e-greater-than */
-export type UnpackEvt<T extends ({ [key: string]: any; } | EvtLike<any> | undefined | null)> =
+export type UnpackEvt<T extends ({ [key: string]: any; } | NonPostableEvtLike<any> | undefined | null)> =
     UnpackNonNullableEvt<NonNullable<T>>
+

src/lib/types/interfaces/Ctx.ts

 import type { CtxLike } from "./CtxLike";
 import type { Handler } from "../Handler";
-import type { EvtLike } from "../helper";
+import type { NonPostableEvtLike } from "./NonPostableEvtLike";
 import type { Evt } from "./Evt";
@@ -93,3 +93,3 @@
         handler: Handler<T, any, CtxLike<Result>>,
-        evt: EvtLike<T>
+        evt: NonPostableEvtLike<T>
     ): void;
@@ -96,0 +96,0 @@

src/lib/types/interfaces/CtxLike.ts

 
 import { typeGuard } from "tsafe/typeGuard";
-import type { EvtLike  } from "../helper";
+import type { NonPostableEvtLike } from "./NonPostableEvtLike";
 import type { Handler } from "../Handler";
@@ -13,3 +13,3 @@
     abort(error: Error): void;
-    zz__addHandler<T>(handler: Handler<T, any, CtxLike<Result>>, evt: EvtLike<T>): void;
+    zz__addHandler<T>(handler: Handler<T, any, CtxLike<Result>>, evt: NonPostableEvtLike<T>): void;
     zz__removeHandler<T>(handler: Handler<T, any, CtxLike<Result>>): void;
@@ -16,0 +16,0 @@ }

src/lib/types/interfaces/index.ts

@@ -9,1 +9,5 @@ export type { Ctx, DoneOrAborted }  from "./Ctx";
 export type { StatefulPostable } from "./StatefulPostable";
+export type { EvtLike } from "./EvtLike";
+export type { NonPostableEvtLike } from "./NonPostableEvtLike";
+export type { StatefulReadonlyEvtLike } from "./StatefulReadonlyEvtLike";
+export type { StatefulEvtLike } from "./StatefulEvtLike";

No alert changes

Improved metrics

Total package byte prevSize

2021252

increased by0.22%

Number of package files

372

increased by4.49%

Lines of code

41375

increased by0.07%

No dependency changes