@edumalin/platform 3.0.0

package/dist/cjs/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/cjs/event/properties/event-to-properties.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventToProperties = eventToProperties;
+function eventToProperties(event) {
+    return event.properties;
+}

package/dist/cjs/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/cjs/event/type/create-event-type.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEventType = createEventType;
+const functional_1 = require("@edumalin/platform/functional");
+const event_creator_entry_to_property_descriptor_map_js_1 = require("./event-creator-entry-to-property-descriptor-map.js");
+const event_properties_schema_entry_to_event_creator_entry_js_1 = require("./event-properties-schema-entry-to-event-creator-entry.js");
+function createEventType(domain, definitions) {
+    const propertyDescriptors = (0, functional_1.objectToEntries)(definitions)
+        .map((0, event_properties_schema_entry_to_event_creator_entry_js_1.eventPropertiesSchemaEntryToEventCreatorEntry)(domain))
+        .reduce(event_creator_entry_to_property_descriptor_map_js_1.eventCreatorEntryToPropertyDescriptorMap, {});
+    return Object.defineProperties({}, propertyDescriptors);
+}

package/dist/cjs/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;

package/dist/cjs/event/type/event-creator-entry-to-property-descriptor-map.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventCreatorEntryToPropertyDescriptorMap = eventCreatorEntryToPropertyDescriptorMap;
+function eventCreatorEntryToPropertyDescriptorMap(propertyDescriptorMap, eventCreatorEntry) {
+    const [eventName, eventCreator] = eventCreatorEntry;
+    return {
+        ...propertyDescriptorMap,
+        [eventName]: {
+            enumerable: false,
+            value: eventCreator,
+            writable: false,
+        },
+    };
+}

package/dist/cjs/event/type/event-creator-entry.d.ts

@@ -0,0 +1,3 @@
+import { type TypeCreator } from '@edumalin/platform/typescript';
+import { type EventCreator } from '../creator/event-creator.js';
+export type EventCreatorEntry = readonly [eventName: string, eventCreator: EventCreator<string, TypeCreator<any, any>>];

package/dist/cjs/event/type/event-creator-entry.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/event/type/event-from-type.d.ts

@@ -0,0 +1,3 @@
+import { type EventFromCreator } from '../creator/event-from-creator.js';
+import { type EventType as GenericEventType } from './event-type.js';
+export type EventFromType<EventType extends GenericEventType, EventName extends keyof EventType & string = keyof EventType & string> = EventFromCreator<EventType[EventName]>;

package/dist/cjs/event/type/event-from-type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/event/type/event-properties-schema-entry-to-event-creator-entry.d.ts

@@ -0,0 +1,4 @@
+import { type Domain } from '@edumalin/platform/domain';
+import { type EventPropertiesSchema } from '../properties/event-properties-schema.js';
+import { type EventCreatorEntry } from './event-creator-entry.js';
+export declare function eventPropertiesSchemaEntryToEventCreatorEntry<DomainType extends Domain>(domain: DomainType): (entry: readonly [name: string, schema: EventPropertiesSchema<unknown>]) => EventCreatorEntry;

package/dist/cjs/event/type/event-properties-schema-entry-to-event-creator-entry.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventPropertiesSchemaEntryToEventCreatorEntry = eventPropertiesSchemaEntryToEventCreatorEntry;
+function eventPropertiesSchemaEntryToEventCreatorEntry(domain) {
+    return ([name]) => {
+        const creator = (properties) => ({
+            domain,
+            name,
+            ...(properties !== undefined ? { properties } : {}),
+        });
+        return [name, creator];
+    };
+}

package/dist/cjs/event/type/event-type-with-events.d.ts

@@ -0,0 +1,2 @@
+import { type EventType as GenericEventType } from './event-type.js';
+export declare function eventTypeWithEvents<EventType extends GenericEventType>(eventType: EventType): <EventNames extends ReadonlyArray<keyof EventType & string>>(...eventNames: EventNames) => Pick<EventType, EventNames[number]>;

package/dist/cjs/event/type/event-type-with-events.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventTypeWithEvents = eventTypeWithEvents;
+const functional_1 = require("@edumalin/platform/functional");
+function eventTypeWithEvents(eventType) {
+    const eventTypeEntries = (0, functional_1.objectToEntries)(eventType);
+    return (...eventNames) => {
+        const set = new Set(eventNames);
+        const filteredEntries = eventTypeEntries.filter(([eventName]) => set.has(eventName));
+        return (0, functional_1.entriesToObject)(filteredEntries);
+    };
+}

package/dist/cjs/event/type/event-type.d.ts

@@ -0,0 +1,7 @@
+import { type Domain } from '@edumalin/platform/domain';
+import { type ReadonlyRecord } from '@edumalin/platform/typescript';
+import { type EventCreator } from '../creator/event-creator.js';
+import { type Event } from '../event.js';
+export type EventType<DomainType extends Domain = Domain, EventPropertiesByEventName extends ReadonlyRecord<string, any> = ReadonlyRecord<string, any>> = {
+    readonly [EventName in keyof EventPropertiesByEventName & string]: EventCreator<EventName, EventPropertiesByEventName[EventName] extends void ? () => Event<DomainType, EventName, EventPropertiesByEventName[EventName]> : (properties: EventPropertiesByEventName[EventName]) => Event<DomainType, EventName, EventPropertiesByEventName[EventName]>>;
+};

package/dist/cjs/event/type/event-type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/functional/call-with.d.ts

@@ -0,0 +1 @@
+export declare function callWith<Parameters extends ReadonlyArray<unknown>>(...parameters: Parameters): <T>(func: (...parameters: Parameters) => T) => T;

package/dist/cjs/functional/call-with.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callWith = callWith;
+function callWith(...parameters) {
+    return (func) => func(...parameters);
+}

package/dist/cjs/functional/entries-to-object.d.ts

@@ -0,0 +1 @@
+export declare function entriesToObject<K extends string, T>(entries: ReadonlyArray<readonly [key: K, value: T]>): Record<K, T>;

package/dist/cjs/functional/entries-to-object.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.entriesToObject = entriesToObject;
+function entriesToObject(entries) {
+    return Object.fromEntries(entries);
+}

package/dist/cjs/functional/identity.d.ts

@@ -0,0 +1 @@
+export declare function identity<T>(value: T): T;

package/dist/cjs/functional/identity.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.identity = identity;
+function identity(value) {
+    return value;
+}

package/dist/cjs/functional/index.d.ts

@@ -0,0 +1,12 @@
+export { callWith } from './call-with.js';
+export { entriesToObject } from './entries-to-object.js';
+export { identity } from './identity.js';
+export { isDefined } from './is-defined.js';
+export { isInstanceOf } from './is-instance-of.js';
+export { isNotNull } from './is-not-null.js';
+export { not } from './not.js';
+export { objectToEntries } from './object-to-entries.js';
+export { objectToKeys } from './object-to-keys.js';
+export { objectToValues } from './object-to-values.js';
+export { objectWithProperties } from './object-with-properties.js';
+export { pipe } from './pipe.js';

package/dist/cjs/functional/index.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pipe = exports.objectWithProperties = exports.objectToValues = exports.objectToKeys = exports.objectToEntries = exports.not = exports.isNotNull = exports.isInstanceOf = exports.isDefined = exports.identity = exports.entriesToObject = exports.callWith = void 0;
+var call_with_js_1 = require("./call-with.js");
+Object.defineProperty(exports, "callWith", { enumerable: true, get: function () { return call_with_js_1.callWith; } });
+var entries_to_object_js_1 = require("./entries-to-object.js");
+Object.defineProperty(exports, "entriesToObject", { enumerable: true, get: function () { return entries_to_object_js_1.entriesToObject; } });
+var identity_js_1 = require("./identity.js");
+Object.defineProperty(exports, "identity", { enumerable: true, get: function () { return identity_js_1.identity; } });
+var is_defined_js_1 = require("./is-defined.js");
+Object.defineProperty(exports, "isDefined", { enumerable: true, get: function () { return is_defined_js_1.isDefined; } });
+var is_instance_of_js_1 = require("./is-instance-of.js");
+Object.defineProperty(exports, "isInstanceOf", { enumerable: true, get: function () { return is_instance_of_js_1.isInstanceOf; } });
+var is_not_null_js_1 = require("./is-not-null.js");
+Object.defineProperty(exports, "isNotNull", { enumerable: true, get: function () { return is_not_null_js_1.isNotNull; } });
+var not_js_1 = require("./not.js");
+Object.defineProperty(exports, "not", { enumerable: true, get: function () { return not_js_1.not; } });
+var object_to_entries_js_1 = require("./object-to-entries.js");
+Object.defineProperty(exports, "objectToEntries", { enumerable: true, get: function () { return object_to_entries_js_1.objectToEntries; } });
+var object_to_keys_js_1 = require("./object-to-keys.js");
+Object.defineProperty(exports, "objectToKeys", { enumerable: true, get: function () { return object_to_keys_js_1.objectToKeys; } });
+var object_to_values_js_1 = require("./object-to-values.js");
+Object.defineProperty(exports, "objectToValues", { enumerable: true, get: function () { return object_to_values_js_1.objectToValues; } });
+var object_with_properties_js_1 = require("./object-with-properties.js");
+Object.defineProperty(exports, "objectWithProperties", { enumerable: true, get: function () { return object_with_properties_js_1.objectWithProperties; } });
+var pipe_js_1 = require("./pipe.js");
+Object.defineProperty(exports, "pipe", { enumerable: true, get: function () { return pipe_js_1.pipe; } });

package/dist/cjs/functional/is-defined.d.ts

@@ -0,0 +1 @@
+export declare function isDefined<T>(value: T | undefined): value is T;

package/dist/cjs/functional/is-defined.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDefined = isDefined;
+function isDefined(value) {
+    return value !== undefined;
+}

package/dist/cjs/functional/is-instance-of.d.ts

@@ -0,0 +1 @@
+export declare function isInstanceOf<T>(instanceClass: new (...args: ReadonlyArray<any>) => T): (arg: unknown) => arg is T;

package/dist/cjs/functional/is-instance-of.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInstanceOf = isInstanceOf;
+function isInstanceOf(instanceClass) {
+    return (value) => value instanceof instanceClass;
+}

package/dist/cjs/functional/is-not-null.d.ts

@@ -0,0 +1 @@
+export declare function isNotNull<T>(value: T | null): value is T;

package/dist/cjs/functional/is-not-null.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNotNull = isNotNull;
+function isNotNull(value) {
+    return value !== null;
+}

package/dist/cjs/functional/not.d.ts

@@ -0,0 +1 @@
+export declare function not<Parameters extends ReadonlyArray<unknown>>(fn: (...parameters: Parameters) => boolean): (...parameters: Parameters) => boolean;

package/dist/cjs/functional/not.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.not = not;
+function not(fn) {
+    return (...parameters) => !fn(...parameters);
+}

package/dist/cjs/functional/object-to-entries.d.ts

@@ -0,0 +1,2 @@
+import { type ReadonlyRecord } from '@edumalin/platform/typescript';
+export declare function objectToEntries<K extends string, T>(obj: ReadonlyRecord<K, T>): ReadonlyArray<readonly [key: K, value: T]>;

package/dist/cjs/functional/object-to-entries.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectToEntries = objectToEntries;
+function objectToEntries(obj) {
+    return Object.entries(obj);
+}

package/dist/cjs/functional/object-to-keys.d.ts

@@ -0,0 +1,2 @@
+import { type ReadonlyRecord } from '@edumalin/platform/typescript';
+export declare function objectToKeys<K extends string>(obj: ReadonlyRecord<K, unknown>): ReadonlyArray<K>;

package/dist/cjs/functional/object-to-keys.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectToKeys = objectToKeys;
+function objectToKeys(obj) {
+    return Object.keys(obj);
+}

package/dist/cjs/functional/object-to-values.d.ts

@@ -0,0 +1 @@
+export declare function objectToValues<const T extends object>(obj: T): ReadonlyArray<T[keyof T]>;

package/dist/cjs/functional/object-to-values.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectToValues = objectToValues;
+function objectToValues(obj) {
+    return Object.values(obj);
+}

package/dist/cjs/functional/object-with-properties.d.ts

@@ -0,0 +1,2 @@
+import { type ReadonlyRecord } from '@edumalin/platform/typescript';
+export declare function objectWithProperties<Properties extends ReadonlyRecord<string, unknown>>(properties: Properties, propertyDescriptor?: Omit<PropertyDescriptor, 'value'> | (<K extends keyof Properties>(propertyKey: K, value: Properties[K]) => Omit<PropertyDescriptor, 'value'>)): <T>(object: T) => T & Properties;

package/dist/cjs/functional/object-with-properties.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectWithProperties = objectWithProperties;
+const object_to_entries_js_1 = require("./object-to-entries.js");
+function objectWithProperties(properties, propertyDescriptor) {
+    if (propertyDescriptor === undefined) {
+        return object => ({
+            ...object,
+            ...properties,
+        });
+    }
+    const propertyEntries = (0, object_to_entries_js_1.objectToEntries)(properties);
+    const propertyDescriptors = propertyEntries.reduce(toPropertyDescriptors(propertyDescriptor), {});
+    return (object) => Object.defineProperties(object, propertyDescriptors);
+}
+function toPropertyDescriptors(propertyDescriptor) {
+    const toPropertyDescriptor = typeof propertyDescriptor === 'function'
+        ? (propertyKey, value) => ({ ...propertyDescriptor(propertyKey, value), value })
+        : (_, value) => ({ ...propertyDescriptor, value });
+    return (acc, [propertyKey, value]) => ({
+        ...acc,
+        [propertyKey]: toPropertyDescriptor(propertyKey, value),
+    });
+}

package/dist/cjs/functional/pipe.d.ts

@@ -0,0 +1,13 @@
+import { type UnaryFunction } from '@edumalin/platform/typescript';
+import { identity } from './identity.js';
+export declare function pipe(): typeof identity;
+export declare function pipe<T, A>(f0: UnaryFunction<T, A>): UnaryFunction<T, A>;
+export declare function pipe<T, A, B>(f0: UnaryFunction<T, A>, f1: UnaryFunction<A, B>): UnaryFunction<T, B>;
+export declare function pipe<T, A, B, C>(f0: UnaryFunction<T, A>, f1: UnaryFunction<A, B>, f2: UnaryFunction<B, C>): UnaryFunction<T, C>;
+export declare function pipe<T, A, B, C, D>(f0: UnaryFunction<T, A>, f1: UnaryFunction<A, B>, f2: UnaryFunction<B, C>, f3: UnaryFunction<C, D>): UnaryFunction<T, D>;
+export declare function pipe<T, A, B, C, D, E>(f0: UnaryFunction<T, A>, f1: UnaryFunction<A, B>, f2: UnaryFunction<B, C>, f3: UnaryFunction<C, D>, f4: UnaryFunction<D, E>): UnaryFunction<T, E>;
+export declare function pipe<T, A, B, C, D, E, F>(f0: UnaryFunction<T, A>, f1: UnaryFunction<A, B>, f2: UnaryFunction<B, C>, f3: UnaryFunction<C, D>, f4: UnaryFunction<D, E>, f5: UnaryFunction<E, F>): UnaryFunction<T, F>;
+export declare function pipe<T, A, B, C, D, E, F, G>(f0: UnaryFunction<T, A>, f1: UnaryFunction<A, B>, f2: UnaryFunction<B, C>, f3: UnaryFunction<C, D>, f4: UnaryFunction<D, E>, f5: UnaryFunction<E, F>, f6: UnaryFunction<F, G>): UnaryFunction<T, G>;
+export declare function pipe<T, A, B, C, D, E, F, G, H>(f0: UnaryFunction<T, A>, f1: UnaryFunction<A, B>, f2: UnaryFunction<B, C>, f3: UnaryFunction<C, D>, f4: UnaryFunction<D, E>, f5: UnaryFunction<E, F>, f6: UnaryFunction<F, G>, f7: UnaryFunction<G, H>): UnaryFunction<T, H>;
+export declare function pipe<T, A, B, C, D, E, F, G, H, I>(f0: UnaryFunction<T, A>, f1: UnaryFunction<A, B>, f2: UnaryFunction<B, C>, f3: UnaryFunction<C, D>, f4: UnaryFunction<D, E>, f5: UnaryFunction<E, F>, f6: UnaryFunction<F, G>, f7: UnaryFunction<G, H>, f8: UnaryFunction<H, I>): UnaryFunction<T, I>;
+export declare function pipe<T, A, B, C, D, E, F, G, H, I>(f0: UnaryFunction<T, A>, f1: UnaryFunction<A, B>, f2: UnaryFunction<B, C>, f3: UnaryFunction<C, D>, f4: UnaryFunction<D, E>, f5: UnaryFunction<E, F>, f6: UnaryFunction<F, G>, f7: UnaryFunction<G, H>, f8: UnaryFunction<H, I>, ...fns: ReadonlyArray<UnaryFunction<unknown, unknown>>): UnaryFunction<T, unknown>;

package/dist/cjs/functional/pipe.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pipe = pipe;
+const identity_js_1 = require("./identity.js");
+function pipe(...functions) {
+    if (functions.length === 0) {
+        return identity_js_1.identity;
+    }
+    return parameter => functions.reduce((previous, f) => f(previous), parameter);
+}

package/dist/cjs/geometry/index.d.ts

@@ -0,0 +1,3 @@
+export { type Point } from './point.js';
+export { type Polygon } from './polygon.js';
+export { type Position } from './position.js';

package/dist/cjs/geometry/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/geometry/point.d.ts

@@ -0,0 +1,5 @@
+import { type Position } from './position';
+export interface Point {
+    readonly coordinates: Position;
+    readonly type: 'Point';
+}

package/dist/cjs/geometry/point.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/geometry/polygon.d.ts

@@ -0,0 +1,5 @@
+import { type Position } from './position.js';
+export interface Polygon {
+    readonly coordinates: ReadonlyArray<ReadonlyArray<Position>>;
+    readonly type: 'Polygon';
+}

package/dist/cjs/geometry/polygon.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/geometry/position.d.ts

@@ -0,0 +1 @@
+export type Position = readonly [x: number, y: number, z?: number];

package/dist/cjs/geometry/position.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/http/client/create-http-client.d.ts

@@ -0,0 +1,3 @@
+import { type HttpClient } from './http-client.js';
+import { type HttpClientOptions } from './http-client-options.js';
+export declare function createHttpClient(clientOptions?: HttpClientOptions): HttpClient;

package/dist/cjs/http/client/create-http-client.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHttpClient = createHttpClient;
+const http_headers_to_fetch_headers_js_1 = require("./header/http-headers-to-fetch-headers.js");
+const response_to_http_client_response_js_1 = require("./response/response-to-http-client-response.js");
+function createHttpClient(clientOptions) {
+    const { defaultOptions, driver = fetch } = clientOptions ?? {};
+    return ({ headers, method, options, url }) => {
+        return new Observable(subscriber => {
+            const abortController = new AbortController();
+            const { signal } = abortController;
+            const httpRequest = new Request(url, {
+                ...defaultOptions,
+                ...options,
+                ...(method ? { method } : {}),
+                ...(headers ? { headers: headers.reduce(http_headers_to_fetch_headers_js_1.httpHeadersToFetchHeaders, new Headers()) } : {}),
+                signal,
+            });
+            let emitted = false;
+            function responseHandler(response) {
+                emitted = true;
+                subscriber.next(response);
+                subscriber.complete();
+            }
+            function errorHandler(error) {
+                emitted = true;
+                subscriber.error(error);
+            }
+            driver(httpRequest).then(response_to_http_client_response_js_1.responseToHttpClientResponse).then(responseHandler).catch(errorHandler);
+            subscriber.add(() => {
+                if (!emitted) {
+                    abortController.abort();
+                }
+            });
+        });
+    };
+}

package/dist/cjs/http/client/graphql/create-graphql-client.d.ts

@@ -0,0 +1,3 @@
+import { type GraphqlClient } from './graphql-client.js';
+import { type GraphqlClientOptions } from './graphql-client-options.js';
+export declare function createGraphqlClient(clientOptions: GraphqlClientOptions): GraphqlClient;

package/dist/cjs/http/client/graphql/create-graphql-client.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGraphqlClient = createGraphqlClient;
+const client_1 = require("@edumalin/platform/http/client");
+const rxjs_1 = require("rxjs");
+const graphql_client_error_js_1 = require("./graphql-client.error.js");
+const graphql_query_to_graphql_request_js_1 = require("./graphql-query-to-graphql-request.js");
+function createGraphqlClient(clientOptions) {
+    const { additionalHttpHeaders = [], endpointUrl: url, httpClient } = clientOptions;
+    const headers = [
+        ['accept', 'application/json'],
+        ['content-type', 'application/json'],
+        ...additionalHttpHeaders,
+    ];
+    const method = 'POST';
+    return (query, queryParameters) => {
+        const payload = (0, graphql_query_to_graphql_request_js_1.graphqlQueryToGraphqlRequest)(query, queryParameters);
+        const body = JSON.stringify(payload);
+        const toJson = (0, client_1.httpClientResponseToJson)();
+        return httpClient({ headers, method, options: { body }, url }).pipe((0, rxjs_1.mergeMap)(httpClientResponse => toJson(httpClientResponse).pipe((0, rxjs_1.map)(({ data, errors }) => {
+            const { status } = httpClientResponse;
+            if (errors !== undefined) {
+                throw graphql_client_error_js_1.graphqlClientError.invalidGraphqlQuery({ errors, status });
+            }
+            if (data === null) {
+                throw graphql_client_error_js_1.graphqlClientError.unknownGraphqlFailure({ status });
+            }
+            return data;
+        }))));
+    };
+}

package/dist/cjs/http/client/graphql/graphql-client-options.d.ts

@@ -0,0 +1,8 @@
+import { type HttpHeader, type HttpMethod } from '@edumalin/platform/http';
+import { type HttpClient } from '@edumalin/platform/http/client';
+export interface GraphqlClientOptions {
+    readonly additionalHttpHeaders?: ReadonlyArray<HttpHeader>;
+    readonly endpointUrl: URL;
+    readonly method?: HttpMethod;
+    readonly httpClient: HttpClient;
+}

package/dist/cjs/http/client/graphql/graphql-client-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/http/client/graphql/graphql-client.d.ts

@@ -0,0 +1,4 @@
+import { type ReadonlyRecord } from '@edumalin/platform/typescript';
+export interface GraphqlClient {
+    <T>(query: string, queryParameters?: ReadonlyRecord<string, unknown>): Observable<T>;
+}

package/dist/cjs/http/client/graphql/graphql-client.error.d.ts

@@ -0,0 +1,11 @@
+import { type HttpStatus } from '@edumalin/platform/http';
+import { type GraphqlError } from './graphql-error.js';
+export declare const graphqlClientError: import("@edumalin/platform/error").ErrorType<import("../../../domain/domain.js").Domain<"@edumalin/platform">, import("@edumalin/platform/error").ErrorPropertiesFromErrorDefinitions<{
+    invalidGraphqlQuery: import("@edumalin/platform/error").ErrorPropertiesSchema<{
+        errors: ReadonlyArray<GraphqlError>;
+        status: HttpStatus;
+    }>;
+    unknownGraphqlFailure: import("@edumalin/platform/error").ErrorPropertiesSchema<{
+        status: HttpStatus;
+    }>;
+}>>;

package/dist/cjs/http/client/graphql/graphql-client.error.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graphqlClientError = void 0;
+const platform_1 = require("@edumalin/platform");
+const error_1 = require("@edumalin/platform/error");
+exports.graphqlClientError = (0, error_1.createErrorType)(platform_1.platformDomain, {
+    invalidGraphqlQuery: (0, error_1.errorProperties)(),
+    unknownGraphqlFailure: (0, error_1.errorProperties)(),
+});

package/dist/cjs/http/client/graphql/graphql-client.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/http/client/graphql/graphql-error-location.d.ts

@@ -0,0 +1,4 @@
+export interface GraphqlErrorLocation {
+    readonly column: number;
+    readonly line: number;
+}

package/dist/cjs/http/client/graphql/graphql-error-location.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/http/client/graphql/graphql-error.d.ts

@@ -0,0 +1,7 @@
+import { type GraphqlErrorLocation } from './graphql-error-location.js';
+export interface GraphqlError {
+    readonly extensions: unknown;
+    readonly locations: ReadonlyArray<GraphqlErrorLocation>;
+    readonly message: string;
+    readonly path: ReadonlyArray<string>;
+}

package/dist/cjs/http/client/graphql/graphql-error.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/http/client/graphql/graphql-query-to-graphql-request.d.ts

@@ -0,0 +1,3 @@
+import { type ReadonlyRecord } from '@edumalin/platform/typescript';
+import { type GraphqlRequest } from './graphql-request.js';
+export declare function graphqlQueryToGraphqlRequest(query: string, queryParameters?: ReadonlyRecord<string, unknown>): GraphqlRequest;

package/dist/cjs/http/client/graphql/graphql-query-to-graphql-request.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graphqlQueryToGraphqlRequest = graphqlQueryToGraphqlRequest;
+function graphqlQueryToGraphqlRequest(query, queryParameters) {
+    return {
+        query,
+        ...(queryParameters ? { variables: queryParameters } : {}),
+    };
+}

package/dist/cjs/http/client/graphql/graphql-request.d.ts

@@ -0,0 +1,5 @@
+import { type ReadonlyRecord } from '@edumalin/platform/typescript';
+export interface GraphqlRequest {
+    readonly query: string;
+    readonly variables?: ReadonlyRecord<string, unknown>;
+}

package/dist/cjs/http/client/graphql/graphql-request.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/http/client/graphql/graphql-response.d.ts

@@ -0,0 +1,5 @@
+import { type GraphqlError } from './graphql-error.js';
+export interface GraphqlResponse<T> {
+    readonly data: T | null;
+    readonly errors?: ReadonlyArray<GraphqlError>;
+}

package/dist/cjs/http/client/graphql/graphql-response.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/http/client/graphql/index.d.ts

@@ -0,0 +1,6 @@
+export { createGraphqlClient } from './create-graphql-client.js';
+export { type GraphqlClient } from './graphql-client.js';
+export { graphqlClientError } from './graphql-client.error.js';
+export { type GraphqlClientOptions } from './graphql-client-options.js';
+export { type GraphqlError } from './graphql-error.js';
+export { type GraphqlErrorLocation } from './graphql-error-location.js';

package/dist/cjs/http/client/graphql/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graphqlClientError = exports.createGraphqlClient = void 0;
+var create_graphql_client_js_1 = require("./create-graphql-client.js");
+Object.defineProperty(exports, "createGraphqlClient", { enumerable: true, get: function () { return create_graphql_client_js_1.createGraphqlClient; } });
+var graphql_client_error_js_1 = require("./graphql-client.error.js");
+Object.defineProperty(exports, "graphqlClientError", { enumerable: true, get: function () { return graphql_client_error_js_1.graphqlClientError; } });

package/dist/cjs/http/client/header/fetch-header-to-http-header.d.ts

@@ -0,0 +1,2 @@
+import { type HttpHeader } from '@edumalin/platform/http';
+export declare function fetchHeaderToHttpHeader(fetchHeader: readonly [headerName: string, headerValue: string]): HttpHeader;

package/dist/cjs/http/client/header/fetch-header-to-http-header.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchHeaderToHttpHeader = fetchHeaderToHttpHeader;
+const http_1 = require("@edumalin/platform/http");
+function fetchHeaderToHttpHeader(fetchHeader) {
+    const [headerName, headerValue] = fetchHeader;
+    (0, http_1.validateHttpHeaderName)(headerName);
+    return [headerName, headerValue];
+}