@awesome-flow/ecs 0.12.0 → 0.14.0

package/dist/canvas/index.cjs

@@ -0,0 +1,5 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_canvas = require('../canvas-DlWcWu05.cjs');
+
+exports.FlowEcsCanvas = require_canvas.FlowEcsCanvas;
+exports.FlowEcsState = require_canvas.flow_ecs_state_default;

package/dist/canvas/index.d.cts

@@ -0,0 +1,2 @@
+import { i as _default, n as FlowEcsCanvasProps, r as FlowEcsStateProps, t as FlowEcsCanvas } from "../index-DGjpWDlm.cjs";
+export { FlowEcsCanvas, FlowEcsCanvasProps, _default as FlowEcsState, FlowEcsStateProps };

package/dist/canvas/index.d.mts

@@ -0,0 +1,2 @@
+import { i as _default, n as FlowEcsCanvasProps, r as FlowEcsStateProps, t as FlowEcsCanvas } from "../index-DCOd7jg-.mjs";
+export { FlowEcsCanvas, FlowEcsCanvasProps, _default as FlowEcsState, FlowEcsStateProps };

package/dist/canvas/index.mjs

@@ -0,0 +1,3 @@
+import { n as flow_ecs_state_default, t as FlowEcsCanvas } from "../canvas-C4nDXlkK.mjs";
+
+export { FlowEcsCanvas, flow_ecs_state_default as FlowEcsState };

package/dist/canvas-C4nDXlkK.mjs

@@ -0,0 +1,677 @@
+import { E as useEntityTypeTemplates, F as useBridgeStoreVersion, I as useEcsBridge, M as useEntityList, b as useScopeList, n as ecsNodeTemplates, r as ecsNodeTypes, t as EcsNodeType, y as useSystemsModuleList } from "./node-types-BRcpbaeR.mjs";
+import { c } from "react/compiler-runtime";
+import { FlowAutoLayout, FlowCanvasContext, FlowCanvasDropWrapper, FlowCanvasRenderIntersections, FlowCanvasWrapper, FlowConnectionStatus, FlowEdgesSelection, FlowTemplatesList } from "@awesome-flow/core/canvas";
+import { Portal } from "@mantine/core";
+import { memo, useContext, useEffect, useState } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useFlowStore } from "@awesome-flow/core/hooks";
+import { FlowContext, StoreContext } from "@awesome-flow/core/abstract";
+import { shallow } from "zustand/shallow";
+
+//#region src/flow/flow-ecs-edge-modules.tsx
+function FlowEcsEdgeModules(props) {
+	const $ = c(10);
+	const { nodesToConnect } = props;
+	const onConnect = useFlowStore(_temp$5);
+	const bridge = useEcsBridge();
+	const moduleVersion = useBridgeStoreVersion("modules");
+	let t0;
+	if ($[0] !== bridge || $[1] !== nodesToConnect || $[2] !== onConnect) {
+		t0 = () => {
+			for (const node of nodesToConnect) {
+				if (!node.data.entity) continue;
+				const sourceHandle = node.data.handles.find(_temp2$2);
+				const entity = bridge.entityRepository.get(node.data.entity);
+				const systemModule = bridge.ecsFlowRepository.getSystemModuleNode(entity.myProxy.entityType);
+				const targetHandle = systemModule?.data.handles.find(_temp3$1);
+				if (sourceHandle && targetHandle) onConnect({
+					source: node.id,
+					target: systemModule.id,
+					sourceHandle: sourceHandle.handleId,
+					targetHandle: targetHandle.handleId
+				});
+			}
+		};
+		$[0] = bridge;
+		$[1] = nodesToConnect;
+		$[2] = onConnect;
+		$[3] = t0;
+	} else t0 = $[3];
+	let t1;
+	if ($[4] !== bridge || $[5] !== moduleVersion || $[6] !== nodesToConnect || $[7] !== onConnect) {
+		t1 = [
+			bridge,
+			moduleVersion,
+			nodesToConnect,
+			onConnect
+		];
+		$[4] = bridge;
+		$[5] = moduleVersion;
+		$[6] = nodesToConnect;
+		$[7] = onConnect;
+		$[8] = t1;
+	} else t1 = $[8];
+	useEffect(t0, t1);
+	let t2;
+	if ($[9] === Symbol.for("react.memo_cache_sentinel")) {
+		t2 = /* @__PURE__ */ jsx(Fragment, {});
+		$[9] = t2;
+	} else t2 = $[9];
+	return t2;
+}
+function _temp3$1(h_0) {
+	return h_0.connection === "target";
+}
+function _temp2$2(h) {
+	return h.connection === "source";
+}
+function _temp$5(state) {
+	return state.onConnect;
+}
+
+//#endregion
+//#region src/flow/flow-ecs-edge-proxies.tsx
+function FlowEcsEdgeProxies(props) {
+	const $ = c(10);
+	const { nodesToConnect } = props;
+	const onConnect = useFlowStore(_temp$4);
+	const bridge = useEcsBridge();
+	const proxyVersion = useBridgeStoreVersion("proxies");
+	let t0;
+	if ($[0] !== bridge || $[1] !== nodesToConnect || $[2] !== onConnect) {
+		t0 = () => {
+			for (const node of nodesToConnect) {
+				if (!node.data.entity) continue;
+				const sourceHandle = node.data.handles.find(_temp2$1);
+				const entity = bridge.entityRepository.get(node.data.entity);
+				const proxies = Array.from(bridge.entityProxyRepository.getAll(entity.myProxy).values()).flat();
+				for (const proxy of proxies) {
+					const proxyNode = bridge.ecsFlowRepository.getEntityNode(proxy);
+					if (proxyNode) {
+						const targetHandle = proxyNode.data.handles.find(_temp3);
+						if (sourceHandle && targetHandle) onConnect({
+							source: node.id,
+							target: proxyNode.id,
+							sourceHandle: sourceHandle.handleId,
+							targetHandle: targetHandle.handleId
+						});
+					}
+				}
+			}
+		};
+		$[0] = bridge;
+		$[1] = nodesToConnect;
+		$[2] = onConnect;
+		$[3] = t0;
+	} else t0 = $[3];
+	let t1;
+	if ($[4] !== bridge || $[5] !== nodesToConnect || $[6] !== onConnect || $[7] !== proxyVersion) {
+		t1 = [
+			bridge,
+			nodesToConnect,
+			onConnect,
+			proxyVersion
+		];
+		$[4] = bridge;
+		$[5] = nodesToConnect;
+		$[6] = onConnect;
+		$[7] = proxyVersion;
+		$[8] = t1;
+	} else t1 = $[8];
+	useEffect(t0, t1);
+	let t2;
+	if ($[9] === Symbol.for("react.memo_cache_sentinel")) {
+		t2 = /* @__PURE__ */ jsx(Fragment, {});
+		$[9] = t2;
+	} else t2 = $[9];
+	return t2;
+}
+function _temp3(h_0) {
+	return h_0.connection === "target";
+}
+function _temp2$1(h) {
+	return h.connection === "source";
+}
+function _temp$4(state) {
+	return state.onConnect;
+}
+
+//#endregion
+//#region src/flow/flow-ecs-entities.tsx
+function FlowEcsEntities() {
+	const $ = c(9);
+	const { nodeFactory } = useContext(FlowContext);
+	const addNodes = useFlowStore(_temp$3);
+	const bridge = useEcsBridge();
+	const entities = useEntityList();
+	let t0;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t0 = [];
+		$[0] = t0;
+	} else t0 = $[0];
+	const [entityNodes, setEntityNodes] = useState(t0);
+	let t1;
+	let t2;
+	if ($[1] !== addNodes || $[2] !== bridge || $[3] !== entities || $[4] !== nodeFactory) {
+		t1 = () => {
+			const nodesToAdd = [];
+			const nodesToConnect = [];
+			for (const entity of entities) {
+				let node = bridge.ecsFlowRepository.getEntityNode(entity.myProxy);
+				if (!node) {
+					node = nodeFactory.createNodeFromType("entity-node");
+					node.data.entity = entity.myProxy;
+					node.data.entityType = entity.myProxy.entityType;
+					node.position = {
+						x: 0,
+						y: 0
+					};
+					bridge.ecsFlowRepository.addEntityNode(node);
+					nodesToAdd.push(node);
+				}
+				nodesToConnect.push(node);
+			}
+			setEntityNodes(nodesToConnect);
+			if (nodesToAdd.length) addNodes(nodesToAdd);
+		};
+		t2 = [
+			addNodes,
+			bridge,
+			entities,
+			nodeFactory
+		];
+		$[1] = addNodes;
+		$[2] = bridge;
+		$[3] = entities;
+		$[4] = nodeFactory;
+		$[5] = t1;
+		$[6] = t2;
+	} else {
+		t1 = $[5];
+		t2 = $[6];
+	}
+	useEffect(t1, t2);
+	let t3;
+	if ($[7] !== entityNodes) {
+		t3 = /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(FlowEcsEdgeProxies, { nodesToConnect: entityNodes }), /* @__PURE__ */ jsx(FlowEcsEdgeModules, { nodesToConnect: entityNodes })] });
+		$[7] = entityNodes;
+		$[8] = t3;
+	} else t3 = $[8];
+	return t3;
+}
+function _temp$3(state) {
+	return state.addNodes;
+}
+
+//#endregion
+//#region src/flow/flow-ecs-modules.tsx
+function FlowEcsModules() {
+	const $ = c(7);
+	const { nodeFactory } = useContext(FlowContext);
+	const addNodes = useFlowStore(_temp$2);
+	const bridge = useEcsBridge();
+	const modules = useSystemsModuleList();
+	let t0;
+	let t1;
+	if ($[0] !== addNodes || $[1] !== bridge || $[2] !== modules || $[3] !== nodeFactory) {
+		t0 = () => {
+			const keys = Array.from(modules.keys());
+			const nodesToAdd = [];
+			for (const element of keys) {
+				if (bridge.ecsFlowRepository.getSystemModuleNode(element)) continue;
+				const node = nodeFactory.createNodeFromType("systems-module-node");
+				node.data.entityType = element;
+				node.position = {
+					x: 0,
+					y: 0
+				};
+				bridge.ecsFlowRepository.addSystemModuleNode(node);
+				nodesToAdd.push(node);
+			}
+			if (nodesToAdd.length) addNodes(nodesToAdd);
+		};
+		t1 = [
+			addNodes,
+			bridge,
+			modules,
+			nodeFactory
+		];
+		$[0] = addNodes;
+		$[1] = bridge;
+		$[2] = modules;
+		$[3] = nodeFactory;
+		$[4] = t0;
+		$[5] = t1;
+	} else {
+		t0 = $[4];
+		t1 = $[5];
+	}
+	useEffect(t0, t1);
+	let t2;
+	if ($[6] === Symbol.for("react.memo_cache_sentinel")) {
+		t2 = /* @__PURE__ */ jsx(Fragment, {});
+		$[6] = t2;
+	} else t2 = $[6];
+	return t2;
+}
+function _temp$2(state) {
+	return state.addNodes;
+}
+
+//#endregion
+//#region src/flow/flow-ecs-scopes.tsx
+function FlowEcsScopes() {
+	const $ = c(16);
+	const { nodeFactory } = useContext(FlowContext);
+	const { flowStore } = useContext(StoreContext);
+	const bridge = useEcsBridge();
+	const scopes = useScopeList();
+	const { nodes, setGroups, setNodes } = useFlowStore(_temp$1, shallow);
+	let t0;
+	if ($[0] !== bridge || $[1] !== flowStore || $[2] !== nodeFactory || $[3] !== scopes || $[4] !== setGroups || $[5] !== setNodes) {
+		t0 = () => {
+			if (!scopes.length) return;
+			let changed = false;
+			const nextNodes = [...flowStore.instance.getState().nodes];
+			const groups = {};
+			for (const scope of scopes) {
+				let groupNode = bridge.ecsFlowRepository.getScopeGroupNode(scope.scopeId);
+				if (!groupNode) {
+					groupNode = nodeFactory.createNodeFromType("scope-group-node");
+					groupNode.data.scopeId = scope.scopeId;
+					groupNode.data.title = "Scope";
+					groupNode.position = {
+						x: 0,
+						y: 0
+					};
+					groupNode.className = "react-flow__node-group";
+					bridge.ecsFlowRepository.addScopeGroupNode(groupNode);
+					nextNodes.unshift(groupNode);
+					changed = true;
+				}
+				const childIds = [];
+				for (const entity of scope.entities) {
+					const entityNode = bridge.ecsFlowRepository.getEntityNode(entity.myProxy);
+					if (!entityNode) continue;
+					childIds.push(entityNode.id);
+				}
+				groups[groupNode.id] = childIds;
+			}
+			const scopedNodeIds = new Set(Object.values(groups).flat());
+			const groupIds = new Set(Object.keys(groups));
+			const orderedNodes = nextNodes.map((node) => {
+				if (groupIds.has(node.id)) return node;
+				if (node.type !== "entity-node") return node;
+				const parentId = scopedNodeIds.has(node.id) ? Object.entries(groups).find((t1) => {
+					const [, children] = t1;
+					return children.includes(node.id);
+				})?.[0] : void 0;
+				if (node.parentId !== parentId) {
+					changed = true;
+					return {
+						...node,
+						extent: parentId ? "parent" : void 0,
+						parentId
+					};
+				}
+				return node;
+			}).sort(_temp2);
+			if (changed) setNodes(orderedNodes);
+			setGroups(groups);
+		};
+		$[0] = bridge;
+		$[1] = flowStore;
+		$[2] = nodeFactory;
+		$[3] = scopes;
+		$[4] = setGroups;
+		$[5] = setNodes;
+		$[6] = t0;
+	} else t0 = $[6];
+	let t1;
+	if ($[7] !== bridge || $[8] !== flowStore || $[9] !== nodeFactory || $[10] !== nodes || $[11] !== scopes || $[12] !== setGroups || $[13] !== setNodes) {
+		t1 = [
+			bridge,
+			flowStore,
+			nodeFactory,
+			nodes,
+			scopes,
+			setGroups,
+			setNodes
+		];
+		$[7] = bridge;
+		$[8] = flowStore;
+		$[9] = nodeFactory;
+		$[10] = nodes;
+		$[11] = scopes;
+		$[12] = setGroups;
+		$[13] = setNodes;
+		$[14] = t1;
+	} else t1 = $[14];
+	useEffect(t0, t1);
+	let t2;
+	if ($[15] === Symbol.for("react.memo_cache_sentinel")) {
+		t2 = /* @__PURE__ */ jsx(Fragment, {});
+		$[15] = t2;
+	} else t2 = $[15];
+	return t2;
+}
+function _temp2(a, b) {
+	return Number(!a.data?.isGroup) - Number(!b.data?.isGroup);
+}
+function _temp$1(state) {
+	return {
+		nodes: state.nodes,
+		setGroups: state.setGroups,
+		setNodes: state.setNodes
+	};
+}
+
+//#endregion
+//#region src/flow/flow-ecs-spawn-entities.tsx
+const selector = (state) => ({
+	nodes: state.nodes,
+	updateNodeData: state.updateNodeData
+});
+function FlowEcsSpawnEntities() {
+	const $ = c(6);
+	const bridge = useEcsBridge();
+	const { nodes, updateNodeData } = useFlowStore(selector, shallow);
+	let t0;
+	let t1;
+	if ($[0] !== bridge || $[1] !== nodes || $[2] !== updateNodeData) {
+		t0 = () => {
+			for (const node of nodes) {
+				if (node.type !== "entity-node" || !node.data.spawn || node.data.entity) continue;
+				const update = bridge.enqueueEntitySpawn(node.data.spawn);
+				if (!update) {
+					updateNodeData(node.id, { spawnStatus: "missing-queue" });
+					continue;
+				}
+				const data = {
+					entity: update.entity,
+					entityType: update.entity.entityType,
+					spawnStatus: "queued"
+				};
+				bridge.ecsFlowRepository.addEntityNode({
+					...node,
+					data: {
+						...node.data,
+						...data
+					}
+				});
+				updateNodeData(node.id, data);
+			}
+		};
+		t1 = [
+			bridge,
+			nodes,
+			updateNodeData
+		];
+		$[0] = bridge;
+		$[1] = nodes;
+		$[2] = updateNodeData;
+		$[3] = t0;
+		$[4] = t1;
+	} else {
+		t0 = $[3];
+		t1 = $[4];
+	}
+	useEffect(t0, t1);
+	let t2;
+	if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
+		t2 = /* @__PURE__ */ jsx(Fragment, {});
+		$[5] = t2;
+	} else t2 = $[5];
+	return t2;
+}
+
+//#endregion
+//#region src/flow/flow-ecs-tool-nodes.tsx
+const defaultEcsToolNodes = [
+	"scheduler-node",
+	"event-timeline-node",
+	"telemetry-node",
+	"update-queue-node"
+];
+function FlowEcsToolNodes(t0) {
+	const $ = c(7);
+	const { nodes: t1 } = t0;
+	const nodes = t1 === void 0 ? defaultEcsToolNodes : t1;
+	const { nodeFactory } = useContext(FlowContext);
+	const addNodes = useFlowStore(_temp);
+	const bridge = useEcsBridge();
+	let t2;
+	let t3;
+	if ($[0] !== addNodes || $[1] !== bridge || $[2] !== nodeFactory || $[3] !== nodes) {
+		t2 = () => {
+			const nodesToAdd = [];
+			nodes.forEach((type, index) => {
+				if (bridge.ecsFlowRepository.getToolNode(type)) return;
+				const node = nodeFactory.createNodeFromType(type);
+				node.position = {
+					x: 980,
+					y: index * 220
+				};
+				bridge.ecsFlowRepository.addToolNode(node);
+				nodesToAdd.push(node);
+			});
+			if (nodesToAdd.length) addNodes(nodesToAdd);
+		};
+		t3 = [
+			addNodes,
+			bridge,
+			nodeFactory,
+			nodes
+		];
+		$[0] = addNodes;
+		$[1] = bridge;
+		$[2] = nodeFactory;
+		$[3] = nodes;
+		$[4] = t2;
+		$[5] = t3;
+	} else {
+		t2 = $[4];
+		t3 = $[5];
+	}
+	useEffect(t2, t3);
+	let t4;
+	if ($[6] === Symbol.for("react.memo_cache_sentinel")) {
+		t4 = /* @__PURE__ */ jsx(Fragment, {});
+		$[6] = t4;
+	} else t4 = $[6];
+	return t4;
+}
+function _temp(state) {
+	return state.addNodes;
+}
+
+//#endregion
+//#region src/flow/flow-ecs-state.tsx
+function FlowEcsState(props) {
+	const $ = c(25);
+	const [refreshLayout, setRefreshLayout] = useState(false);
+	const bridge = useEcsBridge();
+	const entityVersion = useBridgeStoreVersion("entities");
+	const moduleVersion = useBridgeStoreVersion("modules");
+	let t0;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t0 = () => {
+			setRefreshLayout(false);
+			const frame = requestAnimationFrame(() => setRefreshLayout(true));
+			return () => cancelAnimationFrame(frame);
+		};
+		$[0] = t0;
+	} else t0 = $[0];
+	let t1;
+	if ($[1] !== bridge.ecsFlowRepository.sizeNodes || $[2] !== entityVersion || $[3] !== moduleVersion) {
+		t1 = [
+			bridge.ecsFlowRepository.sizeNodes,
+			entityVersion,
+			moduleVersion
+		];
+		$[1] = bridge.ecsFlowRepository.sizeNodes;
+		$[2] = entityVersion;
+		$[3] = moduleVersion;
+		$[4] = t1;
+	} else t1 = $[4];
+	useEffect(t0, t1);
+	let t2;
+	if ($[5] !== props.showSystemModules) {
+		t2 = props.showSystemModules && /* @__PURE__ */ jsx(FlowEcsModules, {});
+		$[5] = props.showSystemModules;
+		$[6] = t2;
+	} else t2 = $[6];
+	let t3;
+	if ($[7] !== props.showEntities) {
+		t3 = props.showEntities && /* @__PURE__ */ jsx(FlowEcsEntities, {});
+		$[7] = props.showEntities;
+		$[8] = t3;
+	} else t3 = $[8];
+	let t4;
+	if ($[9] !== props.enableEntitySpawning) {
+		t4 = props.enableEntitySpawning && /* @__PURE__ */ jsx(FlowEcsSpawnEntities, {});
+		$[9] = props.enableEntitySpawning;
+		$[10] = t4;
+	} else t4 = $[10];
+	let t5;
+	if ($[11] !== props.showScopes) {
+		t5 = props.showScopes && /* @__PURE__ */ jsx(FlowEcsScopes, {});
+		$[11] = props.showScopes;
+		$[12] = t5;
+	} else t5 = $[12];
+	let t6;
+	if ($[13] !== props.toolNodes) {
+		t6 = props.toolNodes && /* @__PURE__ */ jsx(FlowEcsToolNodes, { nodes: Array.isArray(props.toolNodes) ? props.toolNodes : void 0 });
+		$[13] = props.toolNodes;
+		$[14] = t6;
+	} else t6 = $[14];
+	let t7;
+	if ($[15] !== props.autoLayout || $[16] !== refreshLayout) {
+		t7 = props.autoLayout && /* @__PURE__ */ jsx(FlowAutoLayout, { refreshLayout });
+		$[15] = props.autoLayout;
+		$[16] = refreshLayout;
+		$[17] = t7;
+	} else t7 = $[17];
+	let t8;
+	if ($[18] !== t2 || $[19] !== t3 || $[20] !== t4 || $[21] !== t5 || $[22] !== t6 || $[23] !== t7) {
+		t8 = /* @__PURE__ */ jsxs(Fragment, { children: [
+			t2,
+			t3,
+			t4,
+			t5,
+			t6,
+			t7
+		] });
+		$[18] = t2;
+		$[19] = t3;
+		$[20] = t4;
+		$[21] = t5;
+		$[22] = t6;
+		$[23] = t7;
+		$[24] = t8;
+	} else t8 = $[24];
+	return t8;
+}
+var flow_ecs_state_default = memo(FlowEcsState);
+
+//#endregion
+//#region src/canvas/flow-ecs-canvas.tsx
+function FlowEcsCanvas(t0) {
+	const $ = c(21);
+	const { autoLayout: t1, enableEntitySpawning: t2, enableDragDrop: t3, showEntities: t4, showEntityTypeTemplates: t5, showScopes: t6, showSystemModules: t7, showTemplates: t8, toolNodes: t9 } = t0;
+	const autoLayout = t1 === void 0 ? true : t1;
+	const enableEntitySpawning = t2 === void 0 ? true : t2;
+	const enableDragDrop = t3 === void 0 ? true : t3;
+	const showEntities = t4 === void 0 ? true : t4;
+	const showEntityTypeTemplates = t5 === void 0 ? true : t5;
+	const showScopes = t6 === void 0 ? true : t6;
+	const showSystemModules = t7 === void 0 ? true : t7;
+	const showTemplates = t8 === void 0 ? false : t8;
+	const toolNodes = t9 === void 0 ? false : t9;
+	const [over, setOver] = useState(false);
+	const entityTypeTemplates = useEntityTypeTemplates(showEntityTypeTemplates);
+	let t10;
+	if ($[0] !== over) {
+		t10 = /* @__PURE__ */ jsx(FlowCanvasRenderIntersections, {
+			canvasHighlighted: over,
+			nodeTypes: ecsNodeTypes
+		});
+		$[0] = over;
+		$[1] = t10;
+	} else t10 = $[1];
+	const canvas = t10;
+	let t11;
+	if ($[2] !== canvas || $[3] !== enableDragDrop) {
+		t11 = enableDragDrop ? /* @__PURE__ */ jsx(FlowCanvasDropWrapper, {
+			setOver,
+			children: canvas
+		}) : /* @__PURE__ */ jsx(FlowCanvasWrapper, { children: canvas });
+		$[2] = canvas;
+		$[3] = enableDragDrop;
+		$[4] = t11;
+	} else t11 = $[4];
+	let t12;
+	let t13;
+	if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
+		t12 = /* @__PURE__ */ jsx(FlowEdgesSelection, {});
+		t13 = /* @__PURE__ */ jsx(FlowConnectionStatus, {});
+		$[5] = t12;
+		$[6] = t13;
+	} else {
+		t12 = $[5];
+		t13 = $[6];
+	}
+	let t14;
+	if ($[7] !== autoLayout || $[8] !== enableEntitySpawning || $[9] !== showEntities || $[10] !== showScopes || $[11] !== showSystemModules || $[12] !== toolNodes) {
+		t14 = /* @__PURE__ */ jsx(flow_ecs_state_default, {
+			autoLayout,
+			enableEntitySpawning,
+			showEntities,
+			showScopes,
+			showSystemModules,
+			toolNodes
+		});
+		$[7] = autoLayout;
+		$[8] = enableEntitySpawning;
+		$[9] = showEntities;
+		$[10] = showScopes;
+		$[11] = showSystemModules;
+		$[12] = toolNodes;
+		$[13] = t14;
+	} else t14 = $[13];
+	let t15;
+	if ($[14] !== entityTypeTemplates || $[15] !== showTemplates) {
+		t15 = showTemplates && /* @__PURE__ */ jsx(Portal, {
+			target: "#portal-navbar",
+			children: /* @__PURE__ */ jsx(FlowTemplatesList, {
+				extraTemplates: entityTypeTemplates,
+				nodeTypes: ecsNodeTypes
+			})
+		});
+		$[14] = entityTypeTemplates;
+		$[15] = showTemplates;
+		$[16] = t15;
+	} else t15 = $[16];
+	let t16;
+	if ($[17] !== t11 || $[18] !== t14 || $[19] !== t15) {
+		t16 = /* @__PURE__ */ jsxs(FlowCanvasContext, {
+			nodeTemplates: ecsNodeTemplates,
+			children: [
+				t11,
+				t12,
+				t13,
+				t14,
+				t15
+			]
+		});
+		$[17] = t11;
+		$[18] = t14;
+		$[19] = t15;
+		$[20] = t16;
+	} else t16 = $[20];
+	return t16;
+}
+
+//#endregion
+export { flow_ecs_state_default as n, FlowEcsCanvas as t };
+//# sourceMappingURL=canvas-C4nDXlkK.mjs.map