update NodePin and component pin handling to use multiplicity directly

Author: Rn86222

src/pages/edit/Editor/renderer/NodePin.tsx

@@ -29,6 +29,7 @@ export default function CCComponentEditorRendererNodePin({
 	const componentEditorState = useComponentEditorStore()();
 	const nodePin = nullthrows(store.nodePins.get(nodePinId));
 	const node = nullthrows(store.nodes.get(nodePin.nodeId));
+	const nodePins = store.nodePins.getManyByNodeId(node.id);
 	const componentPin = nullthrows(
 		store.componentPins.get(nodePin.componentPinId),
 	);
@@ -152,7 +153,10 @@ export default function CCComponentEditorRendererNodePin({
 			implementationComponentPin.type === "input"
 		) {
 			nodePinValue = nullthrows(
-				componentEditorState.getInputValue(implementationComponentPin.id),
+				componentEditorState.getInputValue(
+					implementationComponentPin.id,
+					nodePins,
+				),
 			);
 		} else {
 			nodePinValue = nullthrows(

src/pages/edit/Editor/store/slices/core/index.ts

@@ -5,7 +5,7 @@ import simulateComponent from "../../../../../../store/componentEvaluator";
 import type { CCComponentPinId } from "../../../../../../store/componentPin";
 import type { CCConnectionId } from "../../../../../../store/connection";
 import type { CCNodeId } from "../../../../../../store/node";
-import type { CCNodePinId } from "../../../../../../store/nodePin";
+import type { CCNodePin, CCNodePinId } from "../../../../../../store/nodePin";
 import type { ComponentEditorSliceCreator } from "../../types";
 import type { EditorStoreCoreSlice } from "./types";
 
@@ -46,12 +46,13 @@ export const createComponentEditorStoreCoreSlice: ComponentEditorSliceCreator<
 				},
 				/** @private */
 				inputValues: new Map(),
-				getInputValue(componentPinId: CCComponentPinId) {
+				getInputValue(componentPinId: CCComponentPinId, nodePins: CCNodePin[]) {
 					const value = get().inputValues.get(componentPinId);
 					if (!value) {
 						const multiplexability =
 							store.componentPins.getComponentPinMultiplexability(
 								componentPinId,
+								nodePins,
 							);
 						if (multiplexability === "undecidable") {
 							throw new Error("Cannot determine multiplexability");
@@ -174,8 +175,17 @@ export const createComponentEditorStoreCoreSlice: ComponentEditorSliceCreator<
 					const inputValues = new Map<CCComponentPinId, SimulationValue>();
 					const pins = store.componentPins.getManyByComponentId(componentId);
 					for (const pin of pins) {
+						invariant(pin.implementation);
 						if (pin.type === "input") {
-							inputValues.set(pin.id, editorState.getInputValue(pin.id));
+							const nodePin = store.nodePins.get(pin.implementation);
+							invariant(nodePin);
+							const node = store.nodes.get(nodePin.nodeId);
+							invariant(node);
+							const nodePins = store.nodePins.getManyByNodeId(node.id);
+							inputValues.set(
+								pin.id,
+								editorState.getInputValue(pin.id, nodePins),
+							);
 						}
 					}
 					simulationCachedFrames.push(

src/pages/edit/Editor/store/slices/core/types.ts

@@ -3,7 +3,7 @@ import type { Vector2 } from "../../../../../../common/vector2";
 import type { CCComponentPinId } from "../../../../../../store/componentPin";
 import type { CCConnectionId } from "../../../../../../store/connection";
 import type { CCNodeId } from "../../../../../../store/node";
-import type { CCNodePinId } from "../../../../../../store/nodePin";
+import type { CCNodePin, CCNodePinId } from "../../../../../../store/nodePin";
 
 export type EditorMode = EditorModeEdit | EditorModePlay;
 export type EditorModeEdit = "edit";
@@ -30,7 +30,10 @@ export type EditorStoreCoreSlice = {
 		target: NodePinPropertyEditorTarget | null,
 	): void;
 	inputValues: Map<InputValueKey, SimulationValue>;
-	getInputValue(componentPinId: CCComponentPinId): SimulationValue;
+	getInputValue(
+		componentPinId: CCComponentPinId,
+		nodePins: CCNodePin[],
+	): SimulationValue;
 	setInputValue(componentPinId: CCComponentPinId, value: SimulationValue): void;
 	setEditorMode(mode: EditorMode): void;
 	resetTimeStep(): void;

src/store/componentEvaluator.ts

@@ -34,7 +34,7 @@ function createInput(
 					);
 					const bitWidth = multiplexability.isMultiplexable
 						? 1
-						: multiplexability.getMultiplicity(nodePins);
+						: multiplexability.multiplicity;
 					return Array<boolean>(bitWidth).fill(false);
 				});
 		input[key] = values;
@@ -58,7 +58,7 @@ function createOutputShape(
 		if (multiplexability.isMultiplexable) {
 			return 1;
 		}
-		return multiplexability.getMultiplicity(nodePins);
+		return multiplexability.multiplicity;
 	});
 	const outputShape = multiplicity.map((multiplicity) => ({ multiplicity }));
 	return outputShape;

src/store/componentPin.ts

@@ -49,7 +49,7 @@ export type CCPinMultiplexability =
 	| { isMultiplexable: true }
 	| {
 			isMultiplexable: false;
-			getMultiplicity: (nodePins: CCNodePin[]) => number;
+			multiplicity: number;
 	  };
 // | { isMultiplexable: false; multiplicity: number };
 
@@ -243,6 +243,7 @@ export class CCComponentPinStore extends EventEmitter<CCComponentPinStoreEvents>
 	 */
 	getComponentPinMultiplexability(
 		pinId: CCComponentPinId,
+		nodePins: CCNodePin[],
 	): CCComponentPinMultiplexability {
 		const pin = this.#pins.get(pinId);
 		invariant(pin);
@@ -268,52 +269,46 @@ export class CCComponentPinStore extends EventEmitter<CCComponentPinStoreEvents>
 				return "undecidable";
 			}
 			case nullthrows(aggregate.outputPin.id): {
-				const getMultiplicity = (nodePins: CCNodePin[]): number => {
-					const multiplicity = nodePins
-						.filter((pin) => {
-							const componentPin = this.#store.componentPins.get(
-								pin.componentPinId,
-							);
-							invariant(componentPin);
-							return componentPin.type === "input";
-						})
-						.reduce((acc, pin) => {
-							invariant(pin.userSpecifiedBitWidth);
-							return acc + pin.userSpecifiedBitWidth;
-						}, 0);
-					return multiplicity;
-				};
+				const multiplicity = nodePins
+					.filter((pin) => {
+						const componentPin = this.#store.componentPins.get(
+							pin.componentPinId,
+						);
+						invariant(componentPin);
+						return componentPin.type === "input";
+					})
+					.reduce((acc, pin) => {
+						invariant(pin.userSpecifiedBitWidth);
+						return acc + pin.userSpecifiedBitWidth;
+					}, 0);
 				return {
 					isMultiplexable: false,
-					getMultiplicity,
+					multiplicity,
 				};
 			}
 			case nullthrows(decompose.outputPin.id): {
 				return "undecidable";
 			}
 			case nullthrows(decompose.inputPin.In.id): {
-				const getMultiplicity = (nodePins: CCNodePin[]): number => {
-					const multiplicity = nodePins
-						.filter((pin) => {
-							const componentPin = this.#store.componentPins.get(
-								pin.componentPinId,
-							);
-							invariant(componentPin);
-							return componentPin.type === "output";
-						})
-						.reduce((acc, pin) => {
-							invariant(pin.userSpecifiedBitWidth);
-							return acc + pin.userSpecifiedBitWidth;
-						}, 0);
-					return multiplicity;
-				};
+				const multiplicity = nodePins
+					.filter((pin) => {
+						const componentPin = this.#store.componentPins.get(
+							pin.componentPinId,
+						);
+						invariant(componentPin);
+						return componentPin.type === "output";
+					})
+					.reduce((acc, pin) => {
+						invariant(pin.userSpecifiedBitWidth);
+						return acc + pin.userSpecifiedBitWidth;
+					}, 0);
 				return {
 					isMultiplexable: false,
-					getMultiplicity,
+					multiplicity,
 				};
 			}
 			case nullthrows(broadcast.inputPin.In.id): {
-				return { isMultiplexable: false, getMultiplicity: () => 1 };
+				return { isMultiplexable: false, multiplicity: 1 };
 			}
 			case nullthrows(broadcast.outputPin.id): {
 				return "undecidable";

src/store/nodePin.ts

@@ -188,15 +188,18 @@ export class CCNodePinStore extends EventEmitter<CCNodePinStoreEvents> {
 			const node = nullthrows(this.#store.nodes.get(nodeId));
 			const nodePins = this.getManyByNodeId(node.id);
 			const givenPinMultiplexability =
-				this.#store.componentPins.getComponentPinMultiplexability(pinId);
+				this.#store.componentPins.getComponentPinMultiplexability(
+					pinId,
+					nodePins,
+				);
 			if (givenPinMultiplexability === "undecidable") {
 				invariant(
 					userSpecifiedBitWidth,
 					"Multiplexability of undecidable pin must be contained in multiplexabilityEnv",
 				);
 				return {
 					isMultiplexable: false,
-					getMultiplicity: () => userSpecifiedBitWidth,
+					multiplicity: userSpecifiedBitWidth,
 				};
 			}
 			if (!givenPinMultiplexability.isMultiplexable) {
@@ -206,6 +209,7 @@ export class CCNodePinStore extends EventEmitter<CCNodePinStoreEvents> {
 				const pinMultiplexability =
 					this.#store.componentPins.getComponentPinMultiplexability(
 						nodePin.componentPinId,
+						nodePins,
 					);
 				if (pinMultiplexability === "undecidable") {
 					throw new Error("unreachable");