@virtualstate/examples/lib/examples/experiments/generalisation/runtime.js

import { h, isTokenVNodeFn, isVNode, TokenConstructor } from "@virtualstate/fringe";
import { Call, DefaultValue, Identity, isOptions } from "./domain.js";
async function Input(options, input) {
    if ((await import("./runtime.browser.options.js")).isBrowserRuntimeOptions(options)) {
        const { Runtime } = await import("./runtime.browser.js");
        return h(Runtime, { ...options }, input);
    }
    else if ((await import("./runtime.native.options.js")).isNativeRuntimeOptions(options)) {
        const { Runtime } = await import("./runtime.native.js");
        return h(Runtime, { ...options }, input);
    }
    return input;
}
export async function* Runtime(options, input) {
    const space = new WeakMap();
    for await (const children of (h(Input, { ...options }, input)).children) {
        const tokens = children.filter(isTokenVNodeFn);
        if (!tokens.length) {
            yield children;
            continue;
        }
        yield children.concat(await run(tokens));
    }
    async function run(tokens) {
        const commit = await tokens.reduce(async (promise, token) => {
            return promise.then(async (commit) => {
                if (!isOptions(token.options))
                    return promise;
                const identity = token[Identity] ? token[Identity]() : token[TokenConstructor];
                const currentValue = space.get(identity) ??
                    token.options[DefaultValue];
                const nextValue = await token.options[Call](currentValue);
                return commit.concat(() => {
                    space.set(identity, nextValue);
                    if (isVNode(nextValue)) {
                        return nextValue;
                    }
                });
            });
        }, Promise.resolve([]));
        return commit
            .map(fn => fn())
            .filter(Boolean);
    }
}
//# sourceMappingURL=runtime.js.map