zodbus 1.0.0 → 1.0.1

package/dist/bus.d.ts

@@ -0,0 +1,27 @@
+import type { PublishKey, Schema, SubscriptionKey, SubscriptionListenerPayloads, SubscriptionListeners } from "./types";
+type BusOptions<T extends Schema> = {
+    schema: T;
+    validate?: boolean;
+};
+interface Bus<T extends Schema> {
+    publish: <K extends PublishKey<T>>(event: K, data: SubscriptionListenerPayloads<T>[K]) => void;
+    subscribe: <K extends SubscriptionKey<T>>(event: K, listener: SubscriptionListeners<T>[K]) => {
+        event: K;
+        listener: SubscriptionListeners<T>[K];
+        unsubscribe: () => void;
+    };
+    subscribeOnce: <K extends SubscriptionKey<T>>(event: K, listener: SubscriptionListeners<T>[K]) => {
+        event: K;
+        listener: SubscriptionListeners<T>[K];
+        unsubscribe: () => void;
+    };
+    unsubscribe: <K extends SubscriptionKey<T>>(event: K, listener?: SubscriptionListeners<T>[K]) => void;
+    getEventNames: () => string[];
+    getListeners: <K extends SubscriptionKey<T>>(event?: K) => ((data: unknown, eventName: string) => void)[];
+    waitFor: <K extends SubscriptionKey<T>>(event: K, options?: {
+        timeout?: number;
+        filter?: (data: SubscriptionListenerPayloads<T>[K]) => boolean;
+    }) => Promise<SubscriptionListenerPayloads<T>[K]>;
+}
+declare function create<T extends Schema>({ schema, validate }: BusOptions<T>): Bus<T>;
+export { create };

package/dist/constants.d.ts

@@ -0,0 +1 @@
+export declare const errorPrefix = "[zodbus] ";

package/dist/errors.d.ts

@@ -0,0 +1,6 @@
+export declare class ValidationError extends Error {
+    constructor(message: string);
+}
+export declare class RuntimeError extends Error {
+    constructor(message: string);
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from "./bus";

package/dist/types.d.ts

@@ -0,0 +1,32 @@
+import { ZodType } from "zod";
+export type IsZodType<T> = T extends ZodType ? true : false;
+export type IsSchema<T> = T extends Schema ? true : false;
+export type Listener<K extends string = string, V = unknown> = (data: V, event: K) => void;
+export interface Schema {
+    [key: string]: ZodType | Schema;
+}
+export type HasWildcard<T extends string> = T extends `*` | `*.${string}` | `${string}.*.${string}` | `${string}.*` ? true : false;
+export type InferSubscriptionListener<T, K extends string, P extends string = ""> = K extends `${infer Left}.${infer Right}` ? HasWildcard<Left & string> extends true ? Listener : Left extends keyof T ? T[Left] extends Schema ? InferSubscriptionListener<T[Left], Right, `${P}${Left}.`> : never : never : K extends keyof T ? T[K] extends ZodType<infer O, any, any> ? Listener<`${P}${K}`, O> : never : HasWildcard<K & string> extends true ? Listener : never;
+export type InferSubscriptionListenerPayload<T, K extends string, P extends string = ""> = K extends `${infer Left}.${infer Right}` ? HasWildcard<Left & string> extends true ? unknown : Left extends keyof T ? T[Left] extends Schema ? InferSubscriptionListenerPayload<T[Left], Right, `${P}${Left}.`> : never : never : K extends keyof T ? T[K] extends ZodType<infer O, any, any> ? O : never : HasWildcard<K & string> extends true ? unknown : never;
+export type ZodTypePath<T, K extends keyof T = keyof T> = K extends string ? IsZodType<T[K]> extends true ? K : never : never;
+export type NamespacePath<T, K extends keyof T = keyof T> = K extends string ? IsSchema<T[K]> extends true ? `${K}.${SchemaPath<T[K], keyof T[K]>}` : never : never;
+export type SchemaPath<T, K extends keyof T = keyof T> = ZodTypePath<T, K> | NamespacePath<T, K>;
+export type WildcardPath<T extends string> = T extends `${infer L}.${infer R}` ? `${L}.${WildcardPath<R>}` | `${L}.*` | `*.${WildcardPath<R>}` : T | "*";
+export type ExcludeDirectlyNestedKeys<T extends string> = T extends `${infer L}.${infer R}` ? L | ExcludeDirectlyNestedKeys<R> : never;
+export type Subscription<T extends Schema> = {
+    [K in Exclude<WildcardPath<SchemaPath<T>>, ExcludeDirectlyNestedKeys<SchemaPath<T>>>]: {
+        listener: InferSubscriptionListener<T, K>;
+        payload: InferSubscriptionListenerPayload<T, K>;
+    };
+};
+export type Subscriptions<T extends Schema> = {
+    [K in keyof Subscription<T>]: Subscription<T>[K];
+};
+export type SubscriptionListeners<T extends Schema> = {
+    [K in keyof Subscriptions<T>]: Subscriptions<T>[K]["listener"];
+};
+export type SubscriptionListenerPayloads<T extends Schema> = {
+    [K in keyof Subscriptions<T>]: Subscriptions<T>[K]["payload"];
+};
+export type SubscriptionKey<T extends Schema> = Extract<keyof SubscriptionListeners<T>, string>;
+export type PublishKey<T extends Schema> = Extract<SubscriptionKey<T>, SchemaPath<T>>;

package/dist/utils/schema.d.ts

@@ -0,0 +1,6 @@
+import { ZodType } from "zod";
+import { Schema } from "../types";
+export declare const hasWildcard: (path: string) => boolean;
+export declare const getPublishPaths: (schema: Schema | ZodType, prefix?: string) => string[];
+export declare const getSubscribePaths: (schema: Schema | ZodType, prefix?: string) => string[];
+export declare const getSubPubPathMap: (schema: Schema | ZodType) => Record<string, string[]>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zodbus",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "repository": "https://github.com/3rd/zodbus",
   "description": "Type-safe event bus built around Zod.",
   "keywords": [
@@ -26,8 +26,7 @@
     }
   },
   "scripts": {
-    "build": "npm run clean && node src/scripts/build.mjs",
-    "postbuild": "tsc -p tsconfig.build.json",
+    "build": "npm run clean && node src/scripts/build.mjs && tsc -p tsconfig.build.json",
     "test": "jest",
     "tsc": "tsc",
     "benchmark": "cd benchmark && npm run benchmark",