@edumalin/platform 3.0.0

package/dist/esm/error/creator/error-creator.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/error/creator/error-from-creator.d.ts

@@ -0,0 +1,3 @@
+import { type TypeCreator } from '@edumalin/platform/typescript';
+import { type ErrorCreator } from './error-creator.js';
+export type ErrorFromCreator<CreatorType extends ErrorCreator<string, TypeCreator<any, any>>> = ReturnType<CreatorType>;

package/dist/esm/error/creator/error-from-creator.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/error/index.d.ts

@@ -0,0 +1,14 @@
+export { catchPlatformError } from './operator/catch-platform-error.js';
+export { createErrorType } from './type/create-error-type.js';
+export { type ErrorFromType } from './type/error-from-type.js';
+export { type ErrorType } from './type/error-type.js';
+export { errorProperties } from './properties/error-properties.js';
+export { type ErrorPropertiesFromErrorDefinitions } from './properties/error-properties-from-error-definitions.js';
+export { type ErrorPropertiesSchema } from './properties/error-properties-schema.js';
+export { isErrorOfType } from './is-error-of-type.js';
+export { isError } from './is-error.js';
+export { isPlatformError } from './is-platform-error.js';
+export { mapPlatformError } from './operator/map-platform-error.js';
+export { type PlatformError } from './platform-error.js';
+export { PlatformErrorInstance } from './platform-error-instance.js';
+export { platformErrorToPlatformErrorInstance } from './platform-error-to-platform-error-instance.js';

package/dist/esm/error/index.js

@@ -0,0 +1,9 @@
+export { catchPlatformError } from './operator/catch-platform-error.js';
+export { createErrorType } from './type/create-error-type.js';
+export { errorProperties } from './properties/error-properties.js';
+export { isErrorOfType } from './is-error-of-type.js';
+export { isError } from './is-error.js';
+export { isPlatformError } from './is-platform-error.js';
+export { mapPlatformError } from './operator/map-platform-error.js';
+export { PlatformErrorInstance } from './platform-error-instance.js';
+export { platformErrorToPlatformErrorInstance } from './platform-error-to-platform-error-instance.js';

package/dist/esm/error/is-error-of-type.d.ts

@@ -0,0 +1,7 @@
+import { type TypeCreator } from '@edumalin/platform/typescript';
+import { type ErrorCreator } from './creator/error-creator.js';
+import { type ErrorFromCreator } from './creator/error-from-creator.js';
+import { type ErrorFromType } from './type/error-from-type.js';
+import { type ErrorType as GenericErrorType } from './type/error-type.js';
+export declare function isErrorOfType<ErrorType extends GenericErrorType>(errorType: ErrorType): (error: unknown) => error is ErrorFromType<ErrorType>;
+export declare function isErrorOfType<ErrorCreatorType extends ErrorCreator<string, TypeCreator<any, any>>>(errorType: ErrorCreatorType): (error: unknown) => error is ErrorFromCreator<ErrorCreatorType>;

package/dist/esm/error/is-error-of-type.js

@@ -0,0 +1,16 @@
+import { isPlatformError } from './is-platform-error.js';
+export function isErrorOfType(errorType) {
+    if ('code' in errorType) {
+        const { code } = errorType;
+        return error => isPlatformError(error) && error.code === code;
+    }
+    else {
+        return error => {
+            if (!isPlatformError(error)) {
+                return false;
+            }
+            const { code } = error;
+            return code in errorType;
+        };
+    }
+}

package/dist/esm/error/is-error.d.ts

@@ -0,0 +1 @@
+export declare function isError(value: unknown): value is Error;

package/dist/esm/error/is-error.js

@@ -0,0 +1,3 @@
+export function isError(value) {
+    return value instanceof Error;
+}

package/dist/esm/error/is-platform-error.d.ts

@@ -0,0 +1,2 @@
+import { type PlatformError } from './platform-error.js';
+export declare function isPlatformError(value: unknown): value is PlatformError;

package/dist/esm/error/is-platform-error.js

@@ -0,0 +1,10 @@
+export function isPlatformError(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'domain' in value &&
+        typeof value.domain === 'object' &&
+        value.domain !== null &&
+        'name' in value.domain &&
+        'code' in value &&
+        typeof value.code === 'string');
+}

package/dist/esm/error/operator/catch-platform-error.d.ts

@@ -0,0 +1,3 @@
+import { type OperatorFunction } from 'rxjs';
+import { type PlatformError } from '../platform-error.js';
+export declare function catchPlatformError<InputType, OutputType>(selector: (error: PlatformError) => Observable<OutputType>): OperatorFunction<InputType, InputType | OutputType>;

package/dist/esm/error/operator/catch-platform-error.js

@@ -0,0 +1,5 @@
+import { catchErrorIf } from '@edumalin/platform/reactive';
+import { isPlatformError } from '../is-platform-error.js';
+export function catchPlatformError(selector) {
+    return catchErrorIf(isPlatformError, selector);
+}

package/dist/esm/error/operator/map-platform-error.d.ts

@@ -0,0 +1,3 @@
+import { type OperatorFunction } from 'rxjs';
+import { type PlatformError } from '../platform-error.js';
+export declare function mapPlatformError<InputType, OutputType>(project: (error: PlatformError) => OutputType): OperatorFunction<InputType, InputType | OutputType>;

package/dist/esm/error/operator/map-platform-error.js

@@ -0,0 +1,5 @@
+import { of } from 'rxjs';
+import { catchPlatformError } from './catch-platform-error.js';
+export function mapPlatformError(project) {
+    return catchPlatformError(error => of(project(error)));
+}

package/dist/esm/error/platform-error-instance.d.ts

@@ -0,0 +1,9 @@
+import { type Domain } from '@edumalin/platform/domain';
+import { type PlatformError } from './platform-error.js';
+export declare class PlatformErrorInstance<DomainType extends Domain, ErrorCode extends string, ErrorContext> extends Error implements PlatformError<DomainType, ErrorCode, ErrorContext> {
+    readonly name = "PlatformError";
+    readonly code: ErrorCode;
+    readonly context: ErrorContext;
+    readonly domain: DomainType;
+    constructor(domain: DomainType, errorCode: ErrorCode, errorContext: ErrorContext);
+}

package/dist/esm/error/platform-error-instance.js

@@ -0,0 +1,12 @@
+export class PlatformErrorInstance extends Error {
+    name = 'PlatformError';
+    code;
+    context;
+    domain;
+    constructor(domain, errorCode, errorContext) {
+        super(`${domain.name}:error:${errorCode}`);
+        this.code = errorCode;
+        this.context = errorContext;
+        this.domain = domain;
+    }
+}

package/dist/esm/error/platform-error-to-platform-error-instance.d.ts

@@ -0,0 +1,4 @@
+import { type Domain } from '@edumalin/platform/domain';
+import { type PlatformError } from './platform-error.js';
+import { PlatformErrorInstance } from './platform-error-instance.js';
+export declare function platformErrorToPlatformErrorInstance<DomainType extends Domain, ErrorCode extends string, ErrorContext>(platformError: PlatformError<DomainType, ErrorCode, ErrorContext>): PlatformErrorInstance<DomainType, ErrorCode, ErrorContext>;

package/dist/esm/error/platform-error-to-platform-error-instance.js

@@ -0,0 +1,5 @@
+import { PlatformErrorInstance } from './platform-error-instance.js';
+export function platformErrorToPlatformErrorInstance(platformError) {
+    const { code, context, domain } = platformError;
+    return new PlatformErrorInstance(domain, code, context);
+}

package/dist/esm/error/platform-error.d.ts

@@ -0,0 +1,7 @@
+import { type Domain } from '@edumalin/platform/domain';
+export interface PlatformError<DomainType extends Domain = Domain, ErrorCode extends string = string, ErrorContext = any> extends Error {
+    readonly code: ErrorCode;
+    readonly context: ErrorContext;
+    readonly domain: DomainType;
+    readonly name: 'PlatformError';
+}

package/dist/esm/error/platform-error.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/error/properties/error-properties-from-error-definitions.d.ts

@@ -0,0 +1,5 @@
+import { type ReadonlyRecord, type TypeSchemaType } from '@edumalin/platform/typescript';
+import { type ErrorPropertiesSchema } from './error-properties-schema.js';
+export type ErrorPropertiesFromErrorDefinitions<ErrorDefinitions extends ReadonlyRecord<string, ErrorPropertiesSchema<unknown>>> = {
+    [ErrorCode in keyof ErrorDefinitions & string]: TypeSchemaType<ErrorDefinitions[ErrorCode]>;
+};

package/dist/esm/error/properties/error-properties-from-error-definitions.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/error/properties/error-properties-schema-type-name.d.ts

@@ -0,0 +1 @@
+export declare const errorPropertiesSchemaTypeName = "@edumalin/platform/error:properties";

package/dist/esm/error/properties/error-properties-schema-type-name.js

@@ -0,0 +1 @@
+export const errorPropertiesSchemaTypeName = '@edumalin/platform/error:properties';

package/dist/esm/error/properties/error-properties-schema.d.ts

@@ -0,0 +1,3 @@
+import { type TypeSchema } from '@edumalin/platform/typescript';
+import { type errorPropertiesSchemaTypeName } from './error-properties-schema-type-name.js';
+export type ErrorPropertiesSchema<SchemaType> = TypeSchema<typeof errorPropertiesSchemaTypeName, SchemaType>;

package/dist/esm/error/properties/error-properties-schema.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/error/properties/error-properties.d.ts

@@ -0,0 +1,3 @@
+import { type ErrorPropertiesSchema } from './error-properties-schema.js';
+export declare function errorProperties(): ErrorPropertiesSchema<void>;
+export declare function errorProperties<SchemaType>(): ErrorPropertiesSchema<SchemaType>;

package/dist/esm/error/properties/error-properties.js

@@ -0,0 +1,5 @@
+import { typeSchema } from '@edumalin/platform/typescript';
+import { errorPropertiesSchemaTypeName } from './error-properties-schema-type-name.js';
+export function errorProperties() {
+    return typeSchema(errorPropertiesSchemaTypeName);
+}

package/dist/esm/error/stack/error-stack-to-platform-error-stack.d.ts

@@ -0,0 +1 @@
+export declare function errorStackToPlatformErrorStack(errorStack: string): string;

package/dist/esm/error/stack/error-stack-to-platform-error-stack.js

@@ -0,0 +1,5 @@
+export function errorStackToPlatformErrorStack(errorStack) {
+    const stackLines = errorStack.split('\n');
+    const firstLine = stackLines[0] ?? '';
+    return firstLine + '\n' + stackLines.slice(2).join('\n');
+}

package/dist/esm/error/type/create-error-type.d.ts

@@ -0,0 +1,6 @@
+import { type Domain } from '@edumalin/platform/domain';
+import { type ReadonlyRecord } from '@edumalin/platform/typescript';
+import { type ErrorPropertiesFromErrorDefinitions } from '../properties/error-properties-from-error-definitions.js';
+import { type ErrorPropertiesSchema } from '../properties/error-properties-schema.js';
+import { type ErrorType } from './error-type.js';
+export declare function createErrorType<DomainType extends Domain, ErrorDefinitions extends ReadonlyRecord<string, ErrorPropertiesSchema<any>>>(domain: DomainType, definitions: ErrorDefinitions): ErrorType<DomainType, ErrorPropertiesFromErrorDefinitions<ErrorDefinitions>>;

package/dist/esm/error/type/create-error-type.js

@@ -0,0 +1,9 @@
+import { objectToEntries } from '@edumalin/platform/functional';
+import { errorCreatorEntryToPropertyDescriptorMap } from './error-creator-entry-to-property-descriptor-map.js';
+import { errorPropertiesSchemaEntryToErrorCreatorEntry } from './error-properties-schema-entry-to-error-creator-entry.js';
+export function createErrorType(domain, definitions) {
+    const propertyDescriptors = objectToEntries(definitions)
+        .map(errorPropertiesSchemaEntryToErrorCreatorEntry(domain))
+        .reduce(errorCreatorEntryToPropertyDescriptorMap, {});
+    return Object.defineProperties({}, propertyDescriptors);
+}

package/dist/esm/error/type/error-creator-entry-to-property-descriptor-map.d.ts

@@ -0,0 +1,2 @@
+import { type ErrorCreatorEntry } from './error-creator-entry.js';
+export declare function errorCreatorEntryToPropertyDescriptorMap(propertyDescriptorMap: PropertyDescriptorMap, errorCreatorEntry: ErrorCreatorEntry): PropertyDescriptorMap;

package/dist/esm/error/type/error-creator-entry-to-property-descriptor-map.js

@@ -0,0 +1,11 @@
+export function errorCreatorEntryToPropertyDescriptorMap(propertyDescriptorMap, errorCreatorEntry) {
+    const [errorCode, errorCreator] = errorCreatorEntry;
+    return {
+        ...propertyDescriptorMap,
+        [errorCode]: {
+            enumerable: false,
+            value: errorCreator,
+            writable: false,
+        },
+    };
+}

package/dist/esm/error/type/error-creator-entry.d.ts

@@ -0,0 +1,3 @@
+import { type TypeCreator } from '@edumalin/platform/typescript';
+import { type ErrorCreator } from '../creator/error-creator.js';
+export type ErrorCreatorEntry = readonly [errorCode: string, errorCreator: ErrorCreator<string, TypeCreator<any, any>>];

package/dist/esm/error/type/error-creator-entry.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/error/type/error-from-type.d.ts

@@ -0,0 +1,3 @@
+import { type ErrorFromCreator } from '../creator/error-from-creator.js';
+import { type ErrorType as GenericErrorType } from './error-type.js';
+export type ErrorFromType<ErrorType extends GenericErrorType> = ErrorFromCreator<ErrorType[keyof ErrorType & string]>;

package/dist/esm/error/type/error-from-type.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/error/type/error-properties-schema-entry-to-error-creator-entry.d.ts

@@ -0,0 +1,4 @@
+import { type Domain } from '@edumalin/platform/domain';
+import { type ErrorPropertiesSchema } from '../properties/error-properties-schema.js';
+import { type ErrorCreatorEntry } from './error-creator-entry.js';
+export declare function errorPropertiesSchemaEntryToErrorCreatorEntry(domain: Domain): (entry: readonly [code: string, schema: ErrorPropertiesSchema<unknown>]) => ErrorCreatorEntry;

package/dist/esm/error/type/error-properties-schema-entry-to-error-creator-entry.js

@@ -0,0 +1,13 @@
+import { PlatformErrorInstance } from '../platform-error-instance.js';
+import { errorStackToPlatformErrorStack } from '../stack/error-stack-to-platform-error-stack.js';
+export function errorPropertiesSchemaEntryToErrorCreatorEntry(domain) {
+    return ([code]) => {
+        const creator = ((context) => {
+            const platformError = new PlatformErrorInstance(domain, code, context);
+            platformError.stack = errorStackToPlatformErrorStack(platformError.stack ?? '');
+            return platformError;
+        });
+        Object.defineProperty(creator, 'code', { enumerable: true, value: code, writable: false });
+        return [code, creator];
+    };
+}

package/dist/esm/error/type/error-type.d.ts

@@ -0,0 +1,7 @@
+import { type Domain } from '@edumalin/platform/domain';
+import { type ReadonlyRecord } from '@edumalin/platform/typescript';
+import { type ErrorCreator } from '../creator/error-creator.js';
+import { type PlatformError } from '../platform-error.js';
+export type ErrorType<DomainType extends Domain = Domain, ErrorContextByErrorCode extends ReadonlyRecord<string, any> = ReadonlyRecord<string, any>> = {
+    readonly [ErrorCode in keyof ErrorContextByErrorCode & string]: ErrorCreator<ErrorCode, ErrorContextByErrorCode[ErrorCode] extends void ? () => PlatformError<DomainType, ErrorCode, ErrorContextByErrorCode[ErrorCode]> : (parameters: ErrorContextByErrorCode[ErrorCode]) => PlatformError<DomainType, ErrorCode, ErrorContextByErrorCode[ErrorCode]>>;
+};

package/dist/esm/error/type/error-type.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/event/creator/event-creator.d.ts

@@ -0,0 +1,4 @@
+import { type TypeCreator } from '@edumalin/platform/typescript';
+export type EventCreator<EventName extends string, TypeCreatorType extends TypeCreator<any, any>> = {
+    readonly name: EventName;
+} & TypeCreatorType;

package/dist/esm/event/creator/event-creator.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/event/creator/event-from-creator.d.ts

@@ -0,0 +1,3 @@
+import { type TypeCreator } from '@edumalin/platform/typescript';
+import { type EventCreator } from './event-creator.js';
+export type EventFromCreator<CreatorType extends EventCreator<string, TypeCreator<any, any>>> = ReturnType<CreatorType>;

package/dist/esm/event/creator/event-from-creator.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/event/event-name.d.ts

@@ -0,0 +1,3 @@
+import { type Event } from './event.js';
+import { type EventType as GenericEventType } from './type/event-type.js';
+export type EventName<EventType extends GenericEventType | Event> = EventType extends GenericEventType ? keyof EventType : EventType['name'];

package/dist/esm/event/event-name.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/event/event.d.ts

@@ -0,0 +1,6 @@
+import { type Domain } from '@edumalin/platform/domain';
+export interface Event<DomainType extends Domain = Domain, EventName extends string = string, EventProperties = unknown> {
+    readonly domain: DomainType;
+    readonly name: EventName;
+    readonly properties: EventProperties;
+}

package/dist/esm/event/event.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/event/handler/event-handler.d.ts

@@ -0,0 +1,4 @@
+import { type Event } from '../event.js';
+export interface EventHandler<EventType extends Event = Event> {
+    (event: EventType): Observable<void>;
+}

package/dist/esm/event/handler/event-handler.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/event/index.d.ts

@@ -0,0 +1,22 @@
+export { createEventType } from './type/create-event-type.js';
+export { type Event } from './event.js';
+export { type EventCreator } from './creator/event-creator.js';
+export { type EventFromCreator } from './creator/event-from-creator.js';
+export { type EventFromType } from './type/event-from-type.js';
+export { type EventHandler } from './handler/event-handler.js';
+export { type EventMatcher } from './matcher/event-matcher.js';
+export { type EventMatcherCase } from './matcher/event-matcher-case.js';
+export { type EventsMatcher } from './matcher/events-matcher.js';
+export { type EventsMatcherCase } from './matcher/events-matcher-case.js';
+export { type EventName } from './event-name.js';
+export { eventProperties } from './properties/event-properties.js';
+export { type EventPropertiesFromEventDefinitions } from './properties/event-properties-from-event-definitions.js';
+export { type EventPropertiesSchema } from './properties/event-properties-schema.js';
+export { eventToEventName } from './properties/event-to-event-name.js';
+export { eventToEventProperties } from './properties/event-to-event-properties.js';
+export { type EventType } from './type/event-type.js';
+export { eventTypeWithEvents } from './type/event-type-with-events.js';
+export { isEvent } from './is-event.js';
+export { isEventOfType } from './is-event-of-type.js';
+export { matchEvent } from './matcher/match-event.js';
+export { matchEvents } from './matcher/match-events.js';

package/dist/esm/event/index.js

@@ -0,0 +1,9 @@
+export { createEventType } from './type/create-event-type.js';
+export { eventProperties } from './properties/event-properties.js';
+export { eventToEventName } from './properties/event-to-event-name.js';
+export { eventToEventProperties } from './properties/event-to-event-properties.js';
+export { eventTypeWithEvents } from './type/event-type-with-events.js';
+export { isEvent } from './is-event.js';
+export { isEventOfType } from './is-event-of-type.js';
+export { matchEvent } from './matcher/match-event.js';
+export { matchEvents } from './matcher/match-events.js';

package/dist/esm/event/is-event-of-type.d.ts

@@ -0,0 +1,9 @@
+import { type TypeCreator } from '@edumalin/platform/typescript';
+import { type EventCreator } from './creator/event-creator.js';
+import { type EventFromCreator } from './creator/event-from-creator.js';
+import { type Event } from './event.js';
+import { type EventFromType } from './type/event-from-type.js';
+import { type EventType as GenericEventType } from './type/event-type.js';
+export declare function isEventOfType<EventType extends GenericEventType>(eventType: EventType): (event: Event) => event is EventFromType<EventType>;
+export declare function isEventOfType<EventCreatorType extends EventCreator<string, TypeCreator<any, any>>>(eventType: EventCreatorType): (event: Event) => event is ReturnType<EventCreatorType>;
+export declare function isEventOfType<EventType extends GenericEventType, EventName extends keyof EventType>(eventType: EventType, eventName: EventName): (event: Event) => event is EventFromCreator<EventType[EventName]>;

package/dist/esm/event/is-event-of-type.js

@@ -0,0 +1,3 @@
+export function isEventOfType(eventType, eventName) {
+    return (event) => event.name in eventType && (eventName === undefined || event.name === eventName);
+}

package/dist/esm/event/is-event.d.ts

@@ -0,0 +1,2 @@
+import { type Event } from './event.js';
+export declare function isEvent(value: unknown): value is Event;

package/dist/esm/event/is-event.js

@@ -0,0 +1,10 @@
+import { isDomain } from '@edumalin/platform/domain';
+export function isEvent(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'domain' in value &&
+        isDomain(value.domain) &&
+        'name' in value &&
+        typeof value.name === 'string' &&
+        'properties' in value);
+}

package/dist/esm/event/matcher/event-matcher-case.d.ts

@@ -0,0 +1,4 @@
+import { type Event } from '../event.js';
+export interface EventMatcherCase<EventType extends Event, ResultType> {
+    (eventProperties: EventType['properties'], event: EventType): ResultType;
+}

package/dist/esm/event/matcher/event-matcher-case.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/event/matcher/event-matcher.d.ts

@@ -0,0 +1,7 @@
+import { type Event } from '../event.js';
+import { type EventMatcherCase } from './event-matcher-case.js';
+export type EventMatcher<EventType extends Event, ResultType = void> = {
+    [EventName in EventType['name']]: EventMatcherCase<Extract<EventType, {
+        name: EventName;
+    }>, ResultType>;
+};

package/dist/esm/event/matcher/event-matcher.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/event/matcher/events-matcher-case.d.ts

@@ -0,0 +1,4 @@
+import { type Event } from '../event.js';
+export interface EventsMatcherCase<EventType extends Event, ResultType> {
+    (eventProperties: ReadonlyArray<EventType['properties']>, events: ReadonlyArray<EventType>): ResultType;
+}

package/dist/esm/event/matcher/events-matcher-case.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/event/matcher/events-matcher.d.ts

@@ -0,0 +1,7 @@
+import { type Event } from '../event.js';
+import { type EventsMatcherCase } from './events-matcher-case.js';
+export type EventsMatcher<EventType extends Event, ResultType = void> = {
+    [EventName in EventType['name']]: EventsMatcherCase<Extract<EventType, {
+        name: EventName;
+    }>, ResultType>;
+};

package/dist/esm/event/matcher/events-matcher.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/event/matcher/match-event.d.ts

@@ -0,0 +1,3 @@
+import { type Event } from '../event.js';
+import { type EventMatcher } from './event-matcher.js';
+export declare function matchEvent<EventType extends Event, ResultType>(event: EventType, matcher: EventMatcher<EventType, ResultType>): ResultType;

package/dist/esm/event/matcher/match-event.js

@@ -0,0 +1,5 @@
+export function matchEvent(event, matcher) {
+    const { name, properties } = event;
+    const handler = matcher[name];
+    return handler(properties, event);
+}

package/dist/esm/event/matcher/match-events.d.ts

@@ -0,0 +1,5 @@
+import { type ReadonlyRecord } from '@edumalin/platform/typescript';
+import { type Event } from '../event.js';
+import { type EventsMatcher } from './events-matcher.js';
+import { type EventName } from '../event-name.js';
+export declare function matchEvents<EventType extends Event, ResultType>(events: ReadonlyArray<EventType>, matcher: EventsMatcher<EventType, ResultType>): ReadonlyRecord<EventName<EventType>, ResultType>;

package/dist/esm/event/matcher/match-events.js

@@ -0,0 +1,18 @@
+import { arrayToDeduplicatedArray } from '@edumalin/platform/collection';
+import { entriesToObject, objectToEntries } from '@edumalin/platform/functional';
+import { eventToEventName } from '../properties/event-to-event-name.js';
+import { eventToEventProperties } from '../properties/event-to-event-properties.js';
+export function matchEvents(events, matcher) {
+    const toUniqueEventNames = arrayToDeduplicatedArray({ valueSelector: eventToEventName });
+    const eventNames = toUniqueEventNames(events);
+    const eventsByName = events.reduce((acc, event) => {
+        acc[event.name].push(event);
+        return acc;
+    }, entriesToObject(eventNames.map(eventName => [eventName, []])));
+    return entriesToObject(objectToEntries(eventsByName).map(([eventName, events]) => {
+        const handler = matcher[eventName];
+        const eventProperties = events.map(eventToEventProperties);
+        const result = handler(eventProperties, events);
+        return [eventName, result];
+    }));
+}

package/dist/esm/event/properties/event-properties-from-event-definitions.d.ts

@@ -0,0 +1,5 @@
+import { type ReadonlyRecord, type TypeSchemaType } from '@edumalin/platform/typescript';
+import { type EventPropertiesSchema } from './event-properties-schema.js';
+export type EventPropertiesFromEventDefinitions<EventDefinitions extends ReadonlyRecord<string, EventPropertiesSchema<any>>> = {
+    [EventName in keyof EventDefinitions & string]: TypeSchemaType<EventDefinitions[EventName]>;
+};

package/dist/esm/event/properties/event-properties-from-event-definitions.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/event/properties/event-properties-schema-type-name.d.ts

@@ -0,0 +1 @@
+export declare const eventPropertiesSchemaTypeName = "@edumalin/platform/event:properties";

package/dist/esm/event/properties/event-properties-schema-type-name.js

@@ -0,0 +1 @@
+export const eventPropertiesSchemaTypeName = '@edumalin/platform/event:properties';

package/dist/esm/event/properties/event-properties-schema.d.ts

@@ -0,0 +1,3 @@
+import { type TypeSchema } from '@edumalin/platform/typescript';
+import { type eventPropertiesSchemaTypeName } from './event-properties-schema-type-name.js';
+export type EventPropertiesSchema<SchemaType> = TypeSchema<typeof eventPropertiesSchemaTypeName, SchemaType>;

package/dist/esm/event/properties/event-properties-schema.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/event/properties/event-properties.d.ts

@@ -0,0 +1,3 @@
+import { type EventPropertiesSchema } from './event-properties-schema.js';
+export declare function eventProperties(): EventPropertiesSchema<void>;
+export declare function eventProperties<SchemaType>(): EventPropertiesSchema<SchemaType>;

package/dist/esm/event/properties/event-properties.js

@@ -0,0 +1,5 @@
+import { typeSchema } from '@edumalin/platform/typescript';
+import { eventPropertiesSchemaTypeName } from './event-properties-schema-type-name.js';
+export function eventProperties() {
+    return typeSchema(eventPropertiesSchemaTypeName);
+}

package/dist/esm/event/properties/event-to-event-name.d.ts

@@ -0,0 +1,2 @@
+import { type Event } from '../event.js';
+export declare function eventToEventName<EventType extends Event>(event: EventType): EventType['name'];

package/dist/esm/event/properties/event-to-event-name.js

@@ -0,0 +1,3 @@
+export function eventToEventName(event) {
+    return event.name;
+}

package/dist/esm/event/properties/event-to-event-properties.d.ts

@@ -0,0 +1,2 @@
+import { type Event } from '../event.js';
+export declare function eventToEventProperties<EventType extends Event>(event: EventType): EventType['properties'];

package/dist/esm/event/properties/event-to-event-properties.js

@@ -0,0 +1,3 @@
+export function eventToEventProperties(event) {
+    return event.properties;
+}

package/dist/esm/event/properties/event-to-properties.d.ts

@@ -0,0 +1,2 @@
+import { type Event } from '../event.js';
+export declare function eventToProperties<EventType extends Event>(event: EventType): EventType['properties'];

package/dist/esm/event/properties/event-to-properties.js

@@ -0,0 +1,3 @@
+export function eventToProperties(event) {
+    return event.properties;
+}

package/dist/esm/event/type/create-event-type.d.ts

@@ -0,0 +1,6 @@
+import { type Domain } from '@edumalin/platform/domain';
+import { type ReadonlyRecord } from '@edumalin/platform/typescript';
+import { type EventPropertiesFromEventDefinitions } from '../properties/event-properties-from-event-definitions.js';
+import { type EventPropertiesSchema } from '../properties/event-properties-schema.js';
+import { type EventType } from './event-type.js';
+export declare function createEventType<DomainType extends Domain, EventDefinitions extends ReadonlyRecord<string, EventPropertiesSchema<any>>>(domain: DomainType, definitions: EventDefinitions): EventType<DomainType, EventPropertiesFromEventDefinitions<EventDefinitions>>;

package/dist/esm/event/type/create-event-type.js

@@ -0,0 +1,9 @@
+import { objectToEntries } from '@edumalin/platform/functional';
+import { eventCreatorEntryToPropertyDescriptorMap } from './event-creator-entry-to-property-descriptor-map.js';
+import { eventPropertiesSchemaEntryToEventCreatorEntry } from './event-properties-schema-entry-to-event-creator-entry.js';
+export function createEventType(domain, definitions) {
+    const propertyDescriptors = objectToEntries(definitions)
+        .map(eventPropertiesSchemaEntryToEventCreatorEntry(domain))
+        .reduce(eventCreatorEntryToPropertyDescriptorMap, {});
+    return Object.defineProperties({}, propertyDescriptors);
+}

package/dist/esm/event/type/event-creator-entry-to-property-descriptor-map.d.ts

@@ -0,0 +1,2 @@
+import { type EventCreatorEntry } from './event-creator-entry.js';
+export declare function eventCreatorEntryToPropertyDescriptorMap(propertyDescriptorMap: PropertyDescriptorMap, eventCreatorEntry: EventCreatorEntry): PropertyDescriptorMap;