lingo3d/lib/visualScripting/Connector.js

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

import { Reactive } from "@lincode/reactivity";
import { extendFunction, forceGetInstance, omitFunction } from "@lincode/utils";
import getStaticProperties from "../display/utils/getStaticProperties";
import { connectorDefaults, connectorSchema } from "../interface/IConnector";
import NullableCallback from "../interface/utils/NullableCallback";
import getReactive from "../utils/getReactive";
import { setRuntimeValue } from "../utils/getRuntimeValue";
import unsafeGetValue from "../utils/unsafeGetValue";
import unsafeSetValue from "../utils/unsafeSetValue";
import GameGraphChild from "./GameGraphChild";
import { uuidMap } from "../collections/idCollections";
import { managerConnectorsMap } from "../collections/managerConnectorsMap";
const connectedMap = new WeakMap();
export const findConnected = (manager, result = new Set()) => {
    if (result.has(manager))
        return result;
    result.add(manager);
    for (const connectedManager of connectedMap.get(manager) ?? [])
        findConnected(connectedManager, result);
    return result;
};
const deleteConnected = (fromManager, toManager, connector) => {
    connectedMap.get(fromManager)?.delete(toManager);
    connectedMap.get(toManager)?.delete(fromManager);
    managerConnectorsMap.get(fromManager)?.delete(connector);
    managerConnectorsMap.get(toManager)?.delete(connector);
};
class Connector extends GameGraphChild {
    static componentName = "connector";
    static defaults = connectorDefaults;
    static schema = connectorSchema;
    constructor() {
        super();
        this.createEffect(() => {
            const { _from, _to, _fromProp, _toProp, _xyz } = this;
            if (!_fromProp || !_toProp || !_from || !_to)
                return;
            const fromManager = uuidMap.get(_from);
            const toManager = uuidMap.get(_to);
            if (!fromManager || !toManager)
                return;
            forceGetInstance(connectedMap, fromManager, Set).add(toManager);
            forceGetInstance(connectedMap, toManager, Set).add(fromManager);
            forceGetInstance(managerConnectorsMap, fromManager, Set).add(this);
            forceGetInstance(managerConnectorsMap, toManager, Set).add(this);
            const { defaults } = getStaticProperties(toManager);
            if (getStaticProperties(fromManager).defaults[_fromProp] instanceof
                NullableCallback) {
                const cb = _xyz
                    ? (val) => setRuntimeValue(toManager, defaults, _toProp, val[_xyz])
                    : (val) => setRuntimeValue(toManager, defaults, _toProp, val);
                const extended = unsafeSetValue(fromManager, _fromProp, extendFunction(unsafeGetValue(fromManager, _fromProp), cb));
                return () => {
                    omitFunction(extended, cb);
                    deleteConnected(fromManager, toManager, this);
                };
            }
            const fromReactive = fromManager.runtimeData && _fromProp in fromManager.runtimeData
                ? getReactive(fromManager.runtimeData, _fromProp)
                : getReactive(fromManager, _fromProp);
            const handle0 = fromReactive.get((val) => setRuntimeValue(toManager, defaults, _toProp, val));
            const handle1 = fromManager.$events.on("runtimeSchema", () => this.refreshState.set({}));
            const handle2 = toManager.$events.on("runtimeSchema", () => this.refreshState.set({}));
            return () => {
                handle0.cancel();
                handle1.cancel();
                handle2.cancel();
                deleteConnected(fromManager, toManager, this);
            };
        }, [this.refreshState.get]);
    }
    refreshState = new Reactive({});
    _to;
    get to() {
        return this._to;
    }
    set to(val) {
        this._to = val;
        this.refreshState.set({});
    }
    _from;
    get from() {
        return this._from;
    }
    set from(val) {
        this._from = val;
        this.refreshState.set({});
    }
    _fromProp;
    get fromProp() {
        return this._fromProp;
    }
    set fromProp(val) {
        this._fromProp = val;
        this.refreshState.set({});
    }
    _toProp;
    get toProp() {
        return this._toProp;
    }
    set toProp(val) {
        this._toProp = val;
        this.refreshState.set({});
    }
    _xyz;
    get xyz() {
        return this._xyz;
    }
    set xyz(val) {
        this._xyz = val;
        this.refreshState.set({});
    }
}
export default Connector;
//# sourceMappingURL=Connector.js.map