abxbus 2.5.6 → 2.5.9

package/dist/cjs/BaseEvent.d.ts

@@ -57,13 +57,13 @@ type EventPayloadShape<TShape extends z.ZodRawShape> = {
     [K in keyof TShape as K extends BaseEventFieldName ? never : K]: TShape[K];
 };
 type EventPayload<TShape extends z.ZodRawShape> = EventPayloadShape<TShape> extends Record<string, never> ? {} : z.infer<z.ZodObject<EventPayloadShape<TShape>>>;
-type EventFactoryMetadataFieldName = 'class' | 'fromJSON' | 'prototype' | 'event_schema' | 'model_fields' | 'event_type' | 'event_version' | 'event_result_type';
+type EventClassMetadataFieldName = 'fromJSON' | 'prototype' | 'event_schema' | 'model_fields' | 'event_type' | 'event_version' | 'event_result_type';
 type StaticDefaultSchema = z.ZodDefault<z.ZodTypeAny> | z.ZodPrefault<z.ZodTypeAny> | z.ZodCatch<z.ZodTypeAny>;
 type EventModelFields<TShape extends z.ZodRawShape> = {
     readonly [K in keyof TShape]: TShape[K];
 };
 type StaticEventDefaultValues<TShape extends z.ZodRawShape> = {
-    readonly [K in keyof TShape as K extends EventFactoryMetadataFieldName ? never : TShape[K] extends StaticDefaultSchema ? K : never]: z.output<TShape[K]>;
+    readonly [K in keyof TShape as K extends EventClassMetadataFieldName ? never : TShape[K] extends StaticDefaultSchema ? K : never]: z.output<TShape[K]>;
 };
 type StaticEventDefaultValuesFromSchema<TSchema extends AnyEventSchema> = TSchema extends z.ZodObject<infer TShape> ? StaticEventDefaultValues<TShape> : {};
 type EventModelFieldsFromSchema<TSchema extends AnyEventSchema> = TSchema extends z.ZodObject<infer TShape> ? TSchema['shape'] & EventModelFields<TShape> : {};
@@ -99,7 +99,7 @@ type ShortcutZodModelFields<TShape> = {
     [K in keyof ShortcutModelFields<TShape>]: ShortcutModelFields<TShape>[K] extends z.ZodTypeAny ? ShortcutModelFields<TShape>[K] : never;
 };
 type ShortcutStaticDefaultValues<TShape, TModelFields extends z.ZodRawShape> = StaticEventDefaultValues<TModelFields> & {
-    readonly [K in keyof TShape as K extends EventFactoryMetadataFieldName ? never : TShape[K] extends z.ZodTypeAny ? never : K]: TShape[K];
+    readonly [K in keyof TShape as K extends EventClassMetadataFieldName ? never : TShape[K] extends z.ZodTypeAny ? never : K]: TShape[K];
 };
 export type EventResultInclude<TEvent extends BaseEvent> = (result: EventResult<TEvent>['result'], event_result: EventResult<TEvent>) => boolean;
 export type EventResultOptions<TEvent extends BaseEvent> = {
@@ -121,35 +121,15 @@ type EventResultUpdateOptions<TEvent extends BaseEvent> = {
     result?: EventResultType<TEvent> | BaseEvent | undefined;
     error?: unknown;
 };
-export type EventFactoryClass<TShape extends z.ZodRawShape, TResult = unknown> = (new (...args: OptionalFactoryArgs<EventInit<TShape>>) => EventWithResultSchema<TResult> & EventPayload<TShape>) & StaticEventDefaultValues<TShape> & {
-    event_schema: EventSchema<TShape>;
-    model_fields: EventModelFields<TShape>;
-};
-export type EventFactory<TShape extends z.ZodRawShape, TResult = unknown, TStaticFields = StaticEventDefaultValues<TShape>> = TStaticFields & {
-    (...args: OptionalFactoryArgs<EventInit<TShape>>): EventWithResultSchema<TResult> & EventPayload<TShape>;
-    new (...args: OptionalFactoryArgs<EventInit<TShape>>): EventWithResultSchema<TResult> & EventPayload<TShape>;
-    event_schema: EventSchema<TShape>;
-    model_fields: EventModelFields<TShape>;
-    class: EventFactoryClass<TShape, TResult>;
-    event_type: string;
-    event_version: string;
-    event_result_type: ResultTypeSchemaFromShape<TShape>;
-    fromJSON: (data: unknown) => EventWithResultSchema<TResult> & EventPayload<TShape>;
-};
-export type SchemaEventFactoryClass<TSchema extends AnyEventSchema, TResult = unknown> = (new (...args: OptionalFactoryArgs<EventInitFromSchema<TSchema>>) => EventWithResultSchema<TResult> & EventPayloadFromSchema<TSchema>) & StaticEventDefaultValuesFromSchema<TSchema> & {
-    event_schema: TSchema;
-    model_fields: EventModelFieldsFromSchema<TSchema>;
-};
-export type SchemaEventFactory<TSchema extends AnyEventSchema, TResult = unknown> = StaticEventDefaultValuesFromSchema<TSchema> & {
-    (...args: OptionalFactoryArgs<EventInitFromSchema<TSchema>>): EventWithResultSchema<TResult> & EventPayloadFromSchema<TSchema>;
-    new (...args: OptionalFactoryArgs<EventInitFromSchema<TSchema>>): EventWithResultSchema<TResult> & EventPayloadFromSchema<TSchema>;
+export type EventClass<TEvent extends BaseEvent = BaseEvent, TInit = never, TSchema extends z.ZodTypeAny = AnyEventSchema, TModelFields extends z.ZodRawShape = z.ZodRawShape, TResultSchema extends z.ZodTypeAny | undefined = z.ZodTypeAny | undefined, TStaticFields = {}> = TStaticFields & {
+    (...args: OptionalFactoryArgs<TInit>): TEvent;
+    new (...args: OptionalFactoryArgs<TInit>): TEvent;
     event_schema: TSchema;
-    model_fields: EventModelFieldsFromSchema<TSchema>;
-    class: SchemaEventFactoryClass<TSchema, TResult>;
+    model_fields: TModelFields;
     event_type: string;
     event_version: string;
-    event_result_type: ResultTypeSchemaFromEventSchema<TSchema>;
-    fromJSON: (data: unknown) => EventWithResultSchema<TResult> & EventPayloadFromSchema<TSchema>;
+    event_result_type: TResultSchema;
+    fromJSON: (data: unknown) => TEvent;
 };
 export declare class BaseEvent {
     event_id: string;
@@ -189,9 +169,9 @@ export declare class BaseEvent {
     _lock_for_event_handler: AsyncLock | null;
     constructor(data?: BaseEventInit<Record<string, unknown>>);
     toString(): string;
-    static extend<TSchema extends z.ZodObject<z.ZodRawShape>>(event_type: string, event_schema: TSchema): SchemaEventFactory<TSchema, ResultSchemaFromEventSchema<TSchema>>;
-    static extend<const TShape extends Record<string, unknown>>(event_type: string, shape?: TShape): EventFactory<ShortcutZodModelFields<TShape>, ResultSchemaFromShape<ShortcutZodModelFields<TShape>>, ShortcutStaticDefaultValues<TShape, ShortcutZodModelFields<TShape>>>;
-    static extend<TShape extends z.ZodRawShape>(event_type: string, shape?: TShape): EventFactory<TShape, ResultSchemaFromShape<TShape>>;
+    static extend<TSchema extends z.ZodObject<z.ZodRawShape>>(event_type: string, event_schema: TSchema): EventClass<EventWithResultSchema<ResultSchemaFromEventSchema<TSchema>> & EventPayloadFromSchema<TSchema>, EventInitFromSchema<TSchema>, TSchema, EventModelFieldsFromSchema<TSchema>, ResultTypeSchemaFromEventSchema<TSchema>, StaticEventDefaultValuesFromSchema<TSchema>>;
+    static extend<const TShape extends Record<string, unknown>>(event_type: string, shape?: TShape): EventClass<EventWithResultSchema<ResultSchemaFromShape<ShortcutZodModelFields<TShape>>> & EventPayload<ShortcutZodModelFields<TShape>>, EventInit<ShortcutZodModelFields<TShape>>, EventSchema<ShortcutZodModelFields<TShape>>, EventModelFields<ShortcutZodModelFields<TShape>>, ResultTypeSchemaFromShape<ShortcutZodModelFields<TShape>>, ShortcutStaticDefaultValues<TShape, ShortcutZodModelFields<TShape>>>;
+    static extend<TShape extends z.ZodRawShape>(event_type: string, shape?: TShape): EventClass<EventWithResultSchema<ResultSchemaFromShape<TShape>> & EventPayload<TShape>, EventInit<TShape>, EventSchema<TShape>, EventModelFields<TShape>, ResultTypeSchemaFromShape<TShape>, StaticEventDefaultValues<TShape>>;
     static fromJSON<T extends typeof BaseEvent>(this: T, data: unknown): InstanceType<T>;
     static toJSONArray(events: Iterable<BaseEvent>): BaseEventJSON[];
     static fromJSONArray(data: unknown): BaseEvent[];

package/dist/cjs/BaseEvent.js

@@ -441,7 +441,7 @@ class BaseEvent {
     const static_field_defaults = built.static_field_defaults;
     const event_result_type = built.event_result_type;
     const event_version = built.event_version;
-    class ExtendedEvent extends BaseEvent {
+    const EventClass = class extends BaseEvent {
       static event_schema = full_schema;
       static model_fields = full_schema.shape;
       static _event_parse_schema = event_parse_schema;
@@ -451,22 +451,25 @@ class BaseEvent {
       constructor(data) {
         super(data);
       }
-    }
-    function EventFactory(data) {
-      return new ExtendedEvent(data);
-    }
-    EventFactory.event_schema = full_schema;
-    EventFactory.model_fields = EventFactory.event_schema.shape;
-    EventFactory.event_type = event_type;
-    EventFactory.event_version = event_version ?? BaseEvent.event_version;
-    EventFactory.event_result_type = event_result_type;
-    EventFactory.class = ExtendedEvent;
-    EventFactory.fromJSON = (data) => ExtendedEvent.fromJSON(data);
-    EventFactory.prototype = ExtendedEvent.prototype;
-    defineStaticEventFields(ExtendedEvent, static_field_defaults);
-    defineStaticEventFields(EventFactory, static_field_defaults);
-    EVENT_TYPE_REGISTRY.set(event_type, ExtendedEvent);
-    return EventFactory;
+    };
+    Object.defineProperty(EventClass, "name", { value: event_type, configurable: true });
+    defineStaticEventFields(EventClass, static_field_defaults);
+    let CallableEventClass;
+    CallableEventClass = new Proxy(EventClass, {
+      apply(target, _this_arg, args) {
+        return Reflect.construct(target, args, target);
+      },
+      construct(target, args, new_target) {
+        return Reflect.construct(target, args, new_target === CallableEventClass ? target : new_target);
+      }
+    });
+    Object.defineProperty(EventClass.prototype, "constructor", {
+      value: CallableEventClass,
+      writable: true,
+      configurable: true
+    });
+    EVENT_TYPE_REGISTRY.set(event_type, CallableEventClass);
+    return CallableEventClass;
   }
   static fromJSON(data) {
     if (!data || typeof data !== "object") {