@livon/client 0.27.0-rc.1

package/dist/client.cjs

@@ -0,0 +1,354 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    clientModule: ()=>clientModule,
+    createClient: ()=>createClient,
+    createClientModule: ()=>createClientModule
+});
+const DEFAULT_REQUEST_KEY = 'livon.client.request';
+const setClientRequest = ({ client, registry, requestKey })=>{
+    if ('object' != typeof client || null === client || !('setRequest' in client)) return;
+    const candidate = client;
+    if ('function' != typeof candidate.setRequest) return;
+    candidate.setRequest((event, payload)=>{
+        const request = registry.state.get(requestKey);
+        if (!request) throw new Error('Client request handler is not available.');
+        return request(event, payload);
+    });
+};
+const buildClientEventEnvelope = (envelope)=>{
+    if ('payload' in envelope) return {
+        ...envelope,
+        payload: envelope.payload
+    };
+    return {
+        ...envelope,
+        error: envelope.error
+    };
+};
+const clientModule = (client, options = {})=>{
+    const register = (registry)=>{
+        const requestKey = options.requestKey ?? DEFAULT_REQUEST_KEY;
+        setClientRequest({
+            client,
+            registry,
+            requestKey
+        });
+        registry.onReceive((envelope, _ctx, next)=>{
+            client.emitEvent(buildClientEventEnvelope(envelope));
+            return next();
+        });
+    };
+    return {
+        name: options.name ?? 'client-module',
+        register
+    };
+};
+const isRecord = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
+const isArray = (value)=>Array.isArray(value);
+const capitalize = (value)=>0 === value.length ? value : value.slice(0, 1).toUpperCase() + value.slice(1);
+const camelCaseName = (value)=>{
+    if (!value) return value;
+    return value.replace(/[^a-zA-Z0-9]+(.)/g, (_, group)=>String(group).toUpperCase()).replace(/^./, (char)=>char.toLowerCase());
+};
+const fieldMethodName = (owner, field)=>`$${camelCaseName(owner)}${capitalize(field)}`;
+const fieldEventName = (owner, field)=>`$${owner}.${field}`;
+const walkAst = (node, visit)=>{
+    visit(node);
+    node.children?.forEach((child)=>walkAst(child, visit));
+};
+const collectOperations = (root)=>{
+    const operations = [];
+    walkAst(root, (node)=>{
+        if ('operation' !== node.type || !node.name) return;
+        const input = node.children?.[0];
+        const output = node.children?.[1];
+        operations.push({
+            name: node.name,
+            input,
+            output,
+            event: node.name
+        });
+    });
+    return operations;
+};
+const collectFieldOperations = (root)=>{
+    const registry = new Map();
+    walkAst(root, (node)=>{
+        if ('field' !== node.type) return;
+        const constraints = node.constraints;
+        const owner = 'string' == typeof constraints?.owner ? constraints.owner : void 0;
+        const field = 'string' == typeof constraints?.field ? constraints.field : void 0;
+        if (!owner || !field) return;
+        const children = node.children ?? [];
+        const dependsOn = children[0];
+        const input = 3 === children.length ? children[1] : void 0;
+        const output = 3 === children.length ? children[2] : children[1];
+        if (!dependsOn) return;
+        const spec = {
+            owner,
+            field,
+            input,
+            output,
+            event: fieldEventName(owner, field)
+        };
+        if (!registry.has(owner)) registry.set(owner, new Map());
+        registry.get(owner).set(field, spec);
+    });
+    return registry;
+};
+const hydrateByNode = ({ value, node, registry, request })=>{
+    if (!node) return value;
+    if ('array' === node.type && isArray(value)) {
+        const child = node.children?.[0];
+        value.forEach((item, index)=>{
+            value[index] = hydrateByNode({
+                value: item,
+                node: child,
+                registry,
+                request
+            });
+        });
+        return value;
+    }
+    if ('tuple' === node.type && isArray(value)) {
+        const children = node.children ?? [];
+        value.forEach((item, index)=>{
+            value[index] = hydrateByNode({
+                value: item,
+                node: children[index],
+                registry,
+                request
+            });
+        });
+        return value;
+    }
+    if ('object' === node.type && isRecord(value)) {
+        const typeName = node.name;
+        if (typeName && registry.has(typeName)) attachFieldOperations({
+            target: value,
+            typeName,
+            registry,
+            request
+        });
+        const fields = node.children ?? [];
+        fields.forEach((fieldNode)=>{
+            if ('field' !== fieldNode.type || !fieldNode.name) return;
+            const child = fieldNode.children?.[0];
+            if (!child) return;
+            value[fieldNode.name] = hydrateByNode({
+                value: value[fieldNode.name],
+                node: child,
+                registry,
+                request
+            });
+        });
+        return value;
+    }
+    if ('field' === node.type) {
+        const child = node.children?.[0];
+        return hydrateByNode({
+            value,
+            node: child,
+            registry,
+            request
+        });
+    }
+    return value;
+};
+const attachFieldOperations = ({ target, typeName, registry, request })=>{
+    const operations = registry.get(typeName);
+    if (!operations) return;
+    if (!Object.isExtensible(target)) return;
+    operations.forEach((spec, fieldName)=>{
+        if (fieldName in target) return;
+        Object.defineProperty(target, fieldName, {
+            enumerable: false,
+            configurable: true,
+            value: async (input)=>{
+                const payload = {
+                    dependsOn: target,
+                    input
+                };
+                const result = await request(spec.event, payload);
+                return hydrateByNode({
+                    value: result,
+                    node: spec.output,
+                    registry,
+                    request
+                });
+            }
+        });
+    });
+};
+const normalizeFieldPayload = (payload)=>{
+    if (isRecord(payload) && 'dependsOn' in payload) {
+        const dependsOn = payload.dependsOn;
+        const input = 'input' in payload ? payload.input : void 0;
+        if (void 0 === input) return {
+            dependsOn
+        };
+        return {
+            dependsOn,
+            input
+        };
+    }
+    return {
+        dependsOn: payload
+    };
+};
+const createClientCore = ({ ast })=>{
+    const operations = collectOperations(ast);
+    const fieldRegistry = collectFieldOperations(ast);
+    let request;
+    const client = {};
+    client.setRequest = (next)=>{
+        request = next;
+    };
+    const globalHandlers = new Map();
+    const globalEnabled = new Map();
+    const roomHandlers = new Map();
+    const roomEnabled = new Map();
+    const registerHandlers = (handlers, roomId)=>{
+        const entries = Object.entries(handlers).filter(([, handler])=>'function' == typeof handler);
+        if (0 === entries.length) return;
+        if (!roomId) return void entries.forEach(([event, handler])=>{
+            globalHandlers.set(event, handler);
+            globalEnabled.set(event, true);
+        });
+        const roomMap = roomHandlers.get(roomId) ?? new Map();
+        const enabledMap = roomEnabled.get(roomId) ?? new Map();
+        entries.forEach(([event, handler])=>{
+            roomMap.set(event, handler);
+            enabledMap.set(event, true);
+        });
+        roomHandlers.set(roomId, roomMap);
+        roomEnabled.set(roomId, enabledMap);
+    };
+    const toggleHandler = ({ enabled, event, roomId })=>{
+        if (!roomId) return void globalEnabled.set(event, enabled);
+        const enabledMap = roomEnabled.get(roomId) ?? new Map();
+        enabledMap.set(event, enabled);
+        roomEnabled.set(roomId, enabledMap);
+    };
+    const dispatch = (envelope)=>{
+        const ctx = {
+            eventId: envelope.id,
+            event: envelope.event,
+            status: envelope.status,
+            metadata: envelope.metadata,
+            context: envelope.context,
+            room: 'string' == typeof envelope.metadata?.room ? String(envelope.metadata.room) : void 0
+        };
+        const roomId = ctx.room;
+        if (roomId) {
+            const enabledMap = roomEnabled.get(roomId);
+            const roomMap = roomHandlers.get(roomId);
+            const handler = roomMap?.get(envelope.event);
+            const isEnabled = enabledMap?.get(envelope.event) ?? true;
+            if (handler && isEnabled) handler(envelope.payload, ctx);
+        }
+        const handler = globalHandlers.get(envelope.event);
+        const isEnabled = globalEnabled.get(envelope.event) ?? true;
+        if (handler && isEnabled) handler(envelope.payload, ctx);
+    };
+    operations.forEach((op)=>{
+        client[op.name] = async (input)=>{
+            if (!request) throw new Error('Client request handler is not available.');
+            const result = await request(op.event, input);
+            return hydrateByNode({
+                value: result,
+                node: op.output,
+                registry: fieldRegistry,
+                request
+            });
+        };
+    });
+    fieldRegistry.forEach((fields, owner)=>{
+        fields.forEach((spec, field)=>{
+            const method = fieldMethodName(owner, field);
+            if (method in client) return;
+            client[method] = async (payload, input)=>{
+                const normalized = normalizeFieldPayload(payload);
+                if (!request) throw new Error('Client request handler is not available.');
+                const result = await request(spec.event, {
+                    dependsOn: normalized.dependsOn,
+                    input: input ?? normalized.input
+                });
+                return hydrateByNode({
+                    value: result,
+                    node: spec.output,
+                    registry: fieldRegistry,
+                    request
+                });
+            };
+        });
+    });
+    return Object.assign(client, {
+        __register: registerHandlers,
+        __toggle: (event, enabled, roomId)=>toggleHandler({
+                event,
+                enabled,
+                roomId
+            }),
+        emitEvent: dispatch
+    });
+};
+const createClient = (input)=>{
+    const client = createClientCore({
+        ast: input.ast
+    });
+    const register = (registry)=>{
+        const requestKey = input.requestKey ?? DEFAULT_REQUEST_KEY;
+        setClientRequest({
+            client,
+            registry,
+            requestKey
+        });
+        registry.onReceive((envelope, _ctx, next)=>{
+            client.emitEvent(buildClientEventEnvelope(envelope));
+            return next();
+        });
+    };
+    const moduleBase = {
+        name: input.name ?? 'client',
+        register
+    };
+    const moduleWithClient = Object.assign(moduleBase, client);
+    return moduleWithClient;
+};
+const createClientModule = (input)=>createClient(input);
+exports.clientModule = __webpack_exports__.clientModule;
+exports.createClient = __webpack_exports__.createClient;
+exports.createClientModule = __webpack_exports__.createClientModule;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "clientModule",
+    "createClient",
+    "createClientModule"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/client.d.ts

@@ -0,0 +1,100 @@
+import type { EventStatus, RuntimeEventContext, RuntimeModule } from '@livon/runtime';
+export interface AstNode {
+    type: string;
+    name?: string;
+    doc?: Readonly<Record<string, unknown>>;
+    request?: string;
+    response?: string;
+    dependsOn?: string;
+    constraints?: Readonly<Record<string, unknown>>;
+    children?: readonly AstNode[];
+}
+export interface ClientRequest {
+    (event: string, payload: unknown): Promise<unknown>;
+}
+export interface ClientTransportConnect {
+    (): Promise<void>;
+}
+export interface ClientTransportClose {
+    (): void;
+}
+export interface ClientOptions {
+    ast: AstNode;
+}
+export interface ClientModuleInput {
+    ast: AstNode;
+    name?: string;
+    requestKey?: string;
+}
+export interface ClientModule extends RuntimeModule {
+}
+export interface ClientHandlerContext {
+    eventId: string;
+    event: string;
+    status: EventStatus;
+    room?: string;
+    metadata?: Readonly<Record<string, unknown>>;
+    context?: RuntimeEventContext;
+}
+export interface ClientSubscriptionHandler {
+    (payload: unknown, ctx: ClientHandlerContext): void;
+}
+export interface ClientEventEnvelope {
+    id: string;
+    event: string;
+    status: EventStatus;
+    payload?: unknown;
+    error?: unknown;
+    metadata?: Readonly<Record<string, unknown>>;
+    context?: RuntimeEventContext;
+}
+export interface ClientEventEmitter {
+    emitEvent: (envelope: ClientEventEnvelope) => void;
+}
+export interface ClientRequestSetter {
+    setRequest: (request: ClientRequest) => void;
+}
+export interface ClientModuleOptions {
+    name?: string;
+    requestKey?: string;
+}
+/**
+ * clientModule is part of the public LIVON API.
+ *
+ * @remarks
+ * Parameter and return types are defined in the TypeScript signature.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/packages/client
+ *
+ * @example
+ * const result = clientModule(undefined as never);
+ */
+export declare const clientModule: (client: ClientEventEmitter, options?: ClientModuleOptions) => RuntimeModule;
+/**
+ * createClient is part of the public LIVON API.
+ *
+ * @remarks
+ * Parameter and return types are defined in the TypeScript signature.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/packages/client
+ *
+ * @example
+ * const result = createClient(undefined as never);
+ */
+export declare const createClient: (input: ClientModuleInput) => ClientModule & Record<string, unknown> & {
+    __register: (handlers: Record<string, ClientSubscriptionHandler>, roomId?: string) => void;
+    __toggle: (event: string, enabled: boolean, roomId?: string) => void;
+    emitEvent: (envelope: ClientEventEnvelope) => void;
+};
+/**
+ * createClientModule is part of the public LIVON API.
+ *
+ * @remarks
+ * Parameter and return types are defined in the TypeScript signature.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/packages/client
+ *
+ * @example
+ * const result = createClientModule(undefined as never);
+ */
+export declare const createClientModule: (input: ClientModuleInput) => ClientModule & Record<string, unknown>;