@livon/runtime 0.27.0-rc.1

package/README.md

@@ -0,0 +1,8 @@
+# @livon/runtime Redirect
+
+Canonical source moved to Docusaurus:
+
+- `/docs/packages/runtime`
+- File source: `website/docs/packages/runtime.md`
+
+This file is a compatibility redirect only.

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,28 @@
+Third-Party Notices
+
+This package includes third-party software. The following licenses apply:
+
+------------------------------------------------------------------------------
+msgpackr
+------------------------------------------------------------------------------
+License: MIT
+
+Copyright (c) 2020 Kris Zyp
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

@@ -0,0 +1,36 @@
+"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__, {
+    runtime: ()=>external_runtime_cjs_namespaceObject.runtime
+});
+const external_runtime_cjs_namespaceObject = require("./runtime.cjs");
+exports.runtime = __webpack_exports__.runtime;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "runtime"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Public package entrypoint for `@livon/runtime`.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/packages/runtime
+ */
+export { runtime } from './runtime.js';
+export type { RuntimeEventContext, EventStatus, EventError, EventEnvelopeBase, EventEnvelopePayload, EventEnvelopeError, EventEnvelope, EventAck, EmitInputBase, EmitInputPayload, EmitInputError, EmitInput, EmitEvent, EmitReceive, EmitSend, EmitError, RoomSelector, StateGet, StateSet, RuntimeState, RuntimeContext, RuntimeHook, RuntimeModule, RuntimeOnError, RuntimeInput, RuntimeModuleRegister, RuntimeHookRegister, RuntimeOnErrorRegister, RuntimeHookSubscription, RuntimeUnsubscribe, RuntimeRegistry, RuntimeStart, PartialEventEnvelopeBase, PartialEventEnvelopePayload, PartialEventEnvelopeError, PartialEventEnvelopeEmpty, PartialEventEnvelope, } from './types.js';
+export type { RuntimeStart as RuntimeFactory } from './types.js';

package/dist/index.js

@@ -0,0 +1,2 @@
+import { runtime } from "./runtime.js";
+export { runtime };

package/dist/runtime.cjs

@@ -0,0 +1,372 @@
+"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__, {
+    runtime: ()=>runtime
+});
+const createHookStore = ()=>({
+        onReceive: [],
+        onSend: [],
+        onError: []
+    });
+const createState = ()=>{
+    const store = new Map();
+    const get = (key)=>store.get(key);
+    const set = (key, value)=>{
+        store.set(key, value);
+    };
+    return {
+        get,
+        set
+    };
+};
+const mergeMetadata = (base, extra)=>{
+    if (!base && !extra) return;
+    return {
+        ...base ?? {},
+        ...extra ?? {}
+    };
+};
+let fallbackEventIdCounter = 0;
+const createEventId = ()=>{
+    const cryptoValue = globalThis.crypto;
+    if (cryptoValue?.randomUUID) return cryptoValue.randomUUID();
+    fallbackEventIdCounter += 1;
+    return `evt_${Date.now().toString(36)}_${fallbackEventIdCounter.toString(36)}`;
+};
+const isContextRecord = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
+const contextRecordFrom = (value)=>{
+    if (!value || !isContextRecord(value)) return;
+    return value;
+};
+const errorFromUnknown = (error)=>{
+    if (error instanceof Error) {
+        const context = isContextRecord(error.context) ? error.context : void 0;
+        return {
+            message: error.message,
+            ...error.name ? {
+                name: error.name
+            } : {},
+            ...error.stack ? {
+                stack: error.stack
+            } : {},
+            ...context ? {
+                context
+            } : {}
+        };
+    }
+    if ('string' == typeof error) return {
+        message: error
+    };
+    if ('object' == typeof error && null !== error) {
+        const value = error;
+        const message = 'string' == typeof value.message ? value.message : 'Unknown error';
+        const name = 'string' == typeof value.name ? value.name : void 0;
+        const stack = 'string' == typeof value.stack ? value.stack : void 0;
+        const context = isContextRecord(value.context) ? value.context : void 0;
+        return {
+            message,
+            ...name ? {
+                name
+            } : {},
+            ...stack ? {
+                stack
+            } : {},
+            ...context ? {
+                context
+            } : {}
+        };
+    }
+    return {
+        message: 'Unknown error'
+    };
+};
+const registerHook = (hooks)=>(hook)=>{
+        hooks.push(hook);
+        const unsub = ()=>{
+            const index = hooks.indexOf(hook);
+            if (index >= 0) hooks.splice(index, 1);
+        };
+        return {
+            unsub
+        };
+    };
+const registerErrorHook = (hooks)=>(hook)=>{
+        hooks.push(hook);
+        const unsub = ()=>{
+            const index = hooks.indexOf(hook);
+            if (index >= 0) hooks.splice(index, 1);
+        };
+        return {
+            unsub
+        };
+    };
+const runtime = (inputOrModule, ...rest)=>{
+    const input = 'modules' in inputOrModule ? inputOrModule : {
+        modules: [
+            inputOrModule,
+            ...rest
+        ]
+    };
+    const modules = input.modules;
+    const state = createState();
+    const hooks = createHookStore();
+    const onReceive = registerHook(hooks.onReceive);
+    const onSend = registerHook(hooks.onSend);
+    const onError = registerErrorHook(hooks.onError);
+    const emitErrorHooks = ({ runtimeError, eventEnvelope, runtimeContext })=>{
+        hooks.onError.forEach((handler)=>{
+            try {
+                handler(runtimeError, eventEnvelope, runtimeContext);
+            } catch  {}
+        });
+    };
+    const mergeContext = (base, update)=>{
+        const left = contextRecordFrom(base);
+        const right = contextRecordFrom(update);
+        if (!left && !right) return;
+        return {
+            ...left ?? {},
+            ...right ?? {}
+        };
+    };
+    const payloadFromEvent = (event)=>event.payload;
+    const errorFromEvent = (event)=>event.error;
+    const mergeEvent = (base, update)=>{
+        if (!update) return base;
+        const nextId = update.id ?? base.id;
+        const nextEvent = update.event ?? base.event;
+        const nextStatus = update.status ?? base.status;
+        const nextMetadata = mergeMetadata(base.metadata, update.metadata);
+        const nextContext = mergeContext(base.context, update.context);
+        const nextPayload = payloadFromEvent(update) ?? payloadFromEvent(base);
+        const nextError = errorFromEvent(update) ?? errorFromEvent(base);
+        if (void 0 === nextPayload && void 0 === nextError) throw new Error('Event envelope must contain payload or error.');
+        const mergedEnvelopeBase = {
+            ...base,
+            id: nextId,
+            event: nextEvent,
+            status: nextStatus,
+            metadata: nextMetadata,
+            context: nextContext
+        };
+        if (void 0 !== nextPayload && void 0 !== nextError) return {
+            ...mergedEnvelopeBase,
+            payload: nextPayload,
+            error: nextError
+        };
+        if (void 0 !== nextPayload) return {
+            ...mergedEnvelopeBase,
+            payload: nextPayload
+        };
+        const definedError = nextError;
+        return {
+            ...mergedEnvelopeBase,
+            error: definedError
+        };
+    };
+    const buildEnvelope = ({ emitInput, fallbackStatus, roomName })=>{
+        const { id: inputId, event, status: inputStatus, metadata: inputMetadata, context, payload, error } = emitInput;
+        const roomMeta = roomName ? {
+            room: roomName
+        } : void 0;
+        const metadata = mergeMetadata(roomMeta, inputMetadata);
+        const id = inputId ?? createEventId();
+        const status = inputStatus ?? fallbackStatus;
+        if (void 0 === payload && void 0 === error) throw new Error('Emit input must contain payload or error.');
+        const envelopeBase = {
+            id,
+            event,
+            status,
+            metadata,
+            context
+        };
+        if (void 0 !== payload && void 0 !== error) return {
+            ...envelopeBase,
+            payload,
+            error
+        };
+        if (void 0 !== payload) return {
+            ...envelopeBase,
+            payload
+        };
+        const definedError = error;
+        return {
+            ...envelopeBase,
+            error: definedError
+        };
+    };
+    const buildFailedEnvelope = ({ runtimeError, eventEnvelope })=>{
+        const normalizedError = errorFromUnknown(runtimeError);
+        const nextContext = mergeContext(eventEnvelope.context, normalizedError.context);
+        return {
+            ...eventEnvelope,
+            error: normalizedError,
+            context: nextContext
+        };
+    };
+    const invokeHook = (input)=>{
+        const hook = input.hookChain[input.hookIndex];
+        if (!hook) return Promise.resolve(input.eventEnvelope);
+        let nextPromise;
+        let nextCalled = false;
+        const next = (update)=>{
+            nextCalled = true;
+            nextPromise = invokeHook({
+                hookChain: input.hookChain,
+                hookIndex: input.hookIndex + 1,
+                eventEnvelope: mergeEvent(input.eventEnvelope, update),
+                runtimeContext: input.runtimeContext
+            });
+            return nextPromise;
+        };
+        const result = hook(input.eventEnvelope, input.runtimeContext, next);
+        if (void 0 === result && nextCalled) return nextPromise ?? Promise.resolve(input.eventEnvelope);
+        return Promise.resolve(result).then((value)=>value ?? nextPromise ?? input.eventEnvelope);
+    };
+    const runReceive = (eventEnvelope, runtimeContext)=>invokeHook({
+            hookChain: hooks.onReceive,
+            hookIndex: 0,
+            eventEnvelope,
+            runtimeContext
+        });
+    const runSend = (eventEnvelope, runtimeContext)=>invokeHook({
+            hookChain: hooks.onSend,
+            hookIndex: 0,
+            eventEnvelope,
+            runtimeContext
+        });
+    const createEmitError = ({ runtimeContext, roomName })=>async (emitInput)=>{
+            const envelope = buildEnvelope({
+                emitInput,
+                fallbackStatus: 'sending',
+                roomName
+            });
+            const fallbackError = envelope.error ?? {
+                message: 'Unknown error'
+            };
+            const failedEnvelope = {
+                ...envelope,
+                error: fallbackError
+            };
+            emitErrorHooks({
+                runtimeError: fallbackError,
+                eventEnvelope: failedEnvelope,
+                runtimeContext
+            });
+            return {
+                ok: true
+            };
+        };
+    const createEmitReceive = ({ runtimeContext, roomName })=>async (emitInput)=>{
+            const envelope = buildEnvelope({
+                emitInput,
+                fallbackStatus: 'receiving',
+                roomName
+            });
+            try {
+                await runReceive(envelope, runtimeContext);
+                return {
+                    ok: true
+                };
+            } catch (error) {
+                const failedEnvelope = buildFailedEnvelope({
+                    runtimeError: error,
+                    eventEnvelope: envelope
+                });
+                emitErrorHooks({
+                    runtimeError: error,
+                    eventEnvelope: failedEnvelope,
+                    runtimeContext
+                });
+                return {
+                    ok: false,
+                    error: failedEnvelope.error.message
+                };
+            }
+        };
+    const createEmitSend = ({ runtimeContext, roomName })=>async (emitInput)=>{
+            const envelope = buildEnvelope({
+                emitInput,
+                fallbackStatus: 'sending',
+                roomName
+            });
+            try {
+                await runSend(envelope, runtimeContext);
+                return {
+                    ok: true
+                };
+            } catch (error) {
+                const failedEnvelope = buildFailedEnvelope({
+                    runtimeError: error,
+                    eventEnvelope: envelope
+                });
+                emitErrorHooks({
+                    runtimeError: error,
+                    eventEnvelope: failedEnvelope,
+                    runtimeContext
+                });
+                return {
+                    ok: false,
+                    error: failedEnvelope.error.message
+                };
+            }
+        };
+    const createEmitEvent = (input)=>async (eventInput)=>createEmitSend(input)(eventInput);
+    const createContext = (roomName)=>{
+        const runtimeContext = {};
+        const createEmitInput = {
+            runtimeContext,
+            roomName
+        };
+        runtimeContext.emitReceive = createEmitReceive(createEmitInput);
+        runtimeContext.emitSend = createEmitSend(createEmitInput);
+        runtimeContext.emitError = createEmitError(createEmitInput);
+        runtimeContext.emitEvent = createEmitEvent(createEmitInput);
+        runtimeContext.room = (nextRoomName)=>createContext(nextRoomName);
+        runtimeContext.state = state;
+        return runtimeContext;
+    };
+    const baseContext = createContext();
+    const registry = {
+        emitReceive: baseContext.emitReceive,
+        emitSend: baseContext.emitSend,
+        emitError: baseContext.emitError,
+        onReceive,
+        onSend,
+        onError,
+        state
+    };
+    modules.forEach((mod)=>{
+        mod.register(registry);
+    });
+};
+exports.runtime = __webpack_exports__.runtime;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "runtime"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/runtime.d.ts

@@ -0,0 +1,13 @@
+import type { RuntimeStart } from './types.js';
+/**
+ * runtime 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/runtime
+ *
+ * @example
+ * const result = runtime(undefined as never);
+ */
+export declare const runtime: RuntimeStart;