lingo3d/lib/systems/utils/createInternalSystem.js

Lingo3D is a React/Vue 3d game development framework that ships with a complete visual editor

import { onBeforeRender } from "../../events/onBeforeRender";
import { onAfterRender } from "../../events/onAfterRender";
import { onRender } from "../../events/onRender";
import { onLoop } from "../../events/onLoop";
import { assertExhaustive } from "@lincode/utils";
import { createEffectSystem } from "./createEffectSystem";
const mapTicker = (ticker) => {
    switch (ticker) {
        case "beforeRender":
            return onBeforeRender;
        case "afterRender":
            return onAfterRender;
        case "render":
            return onRender;
        case "loop":
            return onLoop;
        default:
            assertExhaustive(ticker);
    }
};
const isQueueMicrotastk = (ticker) => ticker === queueMicrotask;
const mapSetupTicker = (ticker) => {
    if (Array.isArray(ticker))
        return (cb) => ticker[0]().then(cb);
    if (isQueueMicrotastk(ticker))
        return ticker;
    return mapTicker(ticker);
};
const placeholderFn = () => { };
export default (name, { data, effect, cleanup, update, updateTicker = "beforeRender", effectTicker = queueMicrotask, beforeTick, afterTick, sort }, userland) => {
    const queued = new Map();
    const [addEffectSystem, deleteEffectSystem] = effect
        ? createEffectSystem(effect, cleanup, mapSetupTicker(effectTicker))
        : [placeholderFn, placeholderFn];
    const executeUpdate = update &&
        (beforeTick || afterTick
            ? sort
                ? () => {
                    beforeTick?.(queued);
                    for (const target of [...queued.keys()].sort(sort))
                        update(target, queued.get(target));
                    afterTick?.(queued);
                }
                : () => {
                    beforeTick?.(queued);
                    for (const [target, data] of queued)
                        update(target, data);
                    afterTick?.(queued);
                }
            : sort
                ? () => {
                    for (const target of [...queued.keys()].sort(sort))
                        update(target, queued.get(target));
                }
                : () => {
                    for (const [target, data] of queued)
                        update(target, data);
                });
    let handle;
    const onUpdate = update && mapTicker(updateTicker);
    const startUpdateLoop = update && (() => (handle = onUpdate(executeUpdate)));
    const executeDelete = (item) => {
        deleteEffectSystem(item);
        const deleted = queued.delete(item);
        deleted &&
            "$deleteSystemSet" in item &&
            item.$deleteSystemSet.delete(deleteSystem);
        return deleted;
    };
    const deleteSystem = update
        ? (item) => executeDelete(item) && queued.size === 0 && handle?.cancel()
        : executeDelete;
    const executeSetup = (item, initData) => {
        const _data = initData ??
            queued.get(item) ??
            (typeof data === "function"
                ? data(item)
                : data
                    ? { ...data }
                    : undefined);
        addEffectSystem(item, _data);
        return _data;
    };
    const executeAdd = (item, initData) => {
        const added = !queued.has(item);
        queued.set(item, executeSetup(item, initData));
        added &&
            "$deleteSystemSet" in item &&
            item.$deleteSystemSet.add(deleteSystem);
        return added;
    };
    const addSystem = update
        ? (item, initData) => executeAdd(item, initData) &&
            queued.size === 1 &&
            startUpdateLoop()
        : executeAdd;
    return {
        add: addSystem,
        delete: deleteSystem
    };
};
//# sourceMappingURL=createInternalSystem.js.map