refactor(frontend): fix base template component

ic10emu/src/errors.rs

@@ -62,6 +62,8 @@ pub enum VMError {
     NotParentable(ObjectID),
     #[error("object {0} is not logicable")]
     NotLogicable(ObjectID),
+    #[error("network object {0} is not a network")]
+    NonNetworkNetwork(ObjectID)
 }
 
 #[derive(Error, Debug, Serialize, Deserialize)]

ic10emu/src/interpreter.rs

@@ -245,7 +245,7 @@ mod tests {
         };
 
         println!("Adding IC");
-        let ic = vm.add_object_from_frozen(frozen_ic)?;
+        let ic = vm.add_object_frozen(frozen_ic)?;
         let frozen_circuit_holder = FrozenObject {
             obj_info: ObjectInfo::with_prefab(Prefab::Name(
                 StationpediaPrefab::StructureCircuitHousing.to_string(),
@@ -254,7 +254,7 @@ mod tests {
             template: None,
         };
         println!("Adding circuit holder");
-        let ch = vm.add_object_from_frozen(frozen_circuit_holder)?;
+        let ch = vm.add_object_frozen(frozen_circuit_holder)?;
         println!("socketing ic into circuit holder");
         vm.set_slot_occupant(ch, 0, Some(ic), 1)?;
         Ok((vm, ch, ic))

ic10emu/src/vm.rs

@@ -2,7 +2,7 @@ pub mod instructions;
 pub mod object;
 
 use crate::{
-    errors::{ICError, TemplateError, VMError},
+    errors::{ICError, VMError},
     interpreter::ICState,
     network::{CableConnectionType, CableNetwork, Connection, FrozenCableNetwork},
     vm::object::{
@@ -183,7 +183,7 @@ impl VM {
             let mut net_ref = net.borrow_mut();
             let net_interface = net_ref
                 .as_mut_network()
-                .unwrap_or_else(|| panic!("non network network: {net_id}"));
+                .ok_or(VMError::NonNetworkNetwork(net_id))?;
             for id in trans_net.devices {
                 net_interface.add_data(id);
             }
@@ -200,7 +200,7 @@ impl VM {
     /// current database.
     /// Errors if the object can not be built do to a template error
     /// Returns the built object's ID
-    pub fn add_object_from_frozen(
+    pub fn add_object_frozen(
         self: &Rc<Self>,
         frozen: FrozenObject,
     ) -> Result<ObjectID, VMError> {
@@ -236,7 +236,7 @@ impl VM {
             let mut net_ref = net.borrow_mut();
             let net_interface = net_ref
                 .as_mut_network()
-                .unwrap_or_else(|| panic!("non network network: {net_id}"));
+                .ok_or(VMError::NonNetworkNetwork(net_id))?;
             for id in trans_net.devices {
                 net_interface.add_data(id);
             }
@@ -952,14 +952,14 @@ impl VM {
                             network
                                 .borrow_mut()
                                 .as_mut_network()
-                                .expect("non-network network")
+                                .ok_or(VMError::NonNetworkNetwork(*net))?
                                 .remove_power(id);
                         }
                         _ => {
                             network
                                 .borrow_mut()
                                 .as_mut_network()
-                                .expect("non-network network")
+                                .ok_or(VMError::NonNetworkNetwork(*net))?
                                 .remove_data(id);
                         }
                     }
@@ -982,14 +982,14 @@ impl VM {
                         network
                             .borrow_mut()
                             .as_mut_network()
-                            .expect("non-network network")
+                            .ok_or(VMError::NonNetworkNetwork(target_net))?
                             .add_power(id);
                     }
                     _ => {
                         network
                             .borrow_mut()
                             .as_mut_network()
-                            .expect("non-network network")
+                            .ok_or(VMError::NonNetworkNetwork(target_net))?
                             .add_data(id);
                     }
                 }
@@ -1025,7 +1025,7 @@ impl VM {
             network
                 .borrow_mut()
                 .as_mut_network()
-                .expect("non-network network")
+                .ok_or(VMError::NonNetworkNetwork(network_id))?
                 .remove_all(id);
             Ok(true)
         } else {
@@ -1314,7 +1314,38 @@ impl VM {
             .collect()
     }
 
-    pub fn save_vm_state(self: &Rc<Self>) -> Result<FrozenVM, TemplateError> {
+    pub fn freeze_network(self: &Rc<Self>, id: ObjectID) -> Result<FrozenCableNetwork, VMError> {
+        Ok(self
+            .networks
+            .borrow()
+            .get(&id)
+            .ok_or(VMError::UnknownId(id))?
+            .borrow()
+            .as_network()
+            .ok_or(VMError::NonNetworkNetwork(id))?
+            .into())
+    }
+
+    pub fn freeze_networks(
+        self: &Rc<Self>,
+        ids: impl IntoIterator<Item = ObjectID>,
+    ) -> Result<Vec<FrozenCableNetwork>, VMError> {
+        ids.into_iter()
+            .map(|id| {
+                Ok(self
+                    .networks
+                    .borrow()
+                    .get(&id)
+                    .ok_or(VMError::UnknownId(id))?
+                    .borrow()
+                    .as_network()
+                    .ok_or(VMError::NonNetworkNetwork(id))?
+                    .into())
+            })
+            .collect::<Result<Vec<FrozenCableNetwork>, VMError>>()
+    }
+
+    pub fn save_vm_state(self: &Rc<Self>) -> Result<FrozenVM, VMError> {
         Ok(FrozenVM {
             objects: self
                 .objects
@@ -1337,13 +1368,14 @@ impl VM {
                 .borrow()
                 .values()
                 .map(|network| {
-                    network
+                    let net_id = network.get_id();
+                    Ok(network
                         .borrow()
                         .as_network()
-                        .expect("non-network network")
-                        .into()
+                        .ok_or(VMError::NonNetworkNetwork(net_id))?
+                        .into())
                 })
-                .collect(),
+                .collect::<Result<Vec<FrozenCableNetwork>, VMError>>()?,
             default_network_key: *self.default_network_key.borrow(),
             circuit_holders: self.circuit_holders.borrow().clone(),
             program_holders: self.program_holders.borrow().clone(),
@@ -1412,7 +1444,7 @@ impl VM {
             let mut net_ref = net.borrow_mut();
             let net_interface = net_ref
                 .as_mut_network()
-                .unwrap_or_else(|| panic!("non network network: {net_id}"));
+                .ok_or(VMError::NonNetworkNetwork(net_id))?;
             for id in trans_net.devices {
                 net_interface.add_data(id);
             }

ic10emu_wasm/src/lib.rs

@@ -4,8 +4,12 @@ mod utils;
 
 use ic10emu::{
     errors::{ICError, VMError},
+    network::FrozenCableNetwork,
     vm::{
-        object::{templates::{FrozenObject, FrozenObjectFull}, ObjectID},
+        object::{
+            templates::{FrozenObject, FrozenObjectFull},
+            ObjectID,
+        },
         FrozenVM, VM,
     },
 };
@@ -60,10 +64,50 @@ impl IntoIterator for TemplateDatabase {
 #[tsify(into_wasm_abi, from_wasm_abi)]
 pub struct FrozenObjects(Vec<FrozenObjectFull>);
 
+impl IntoIterator for FrozenObjects {
+    type Item = FrozenObjectFull;
+    type IntoIter = std::vec::IntoIter<FrozenObjectFull>;
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_iter()
+    }
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, Tsify)]
+#[tsify(into_wasm_abi, from_wasm_abi)]
+pub struct FrozenObjectsSparse(Vec<FrozenObject>);
+
+impl IntoIterator for FrozenObjectsSparse {
+    type Item = FrozenObject;
+    type IntoIter = std::vec::IntoIter<FrozenObject>;
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_iter()
+    }
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, Tsify)]
+#[tsify(into_wasm_abi, from_wasm_abi)]
+pub struct FrozenNetworks(Vec<FrozenCableNetwork>);
+
+impl IntoIterator for FrozenNetworks {
+    type Item = FrozenCableNetwork;
+    type IntoIter = std::vec::IntoIter<FrozenCableNetwork>;
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_iter()
+    }
+}
+
 #[derive(Clone, Debug, Serialize, Deserialize, Tsify)]
 #[tsify(into_wasm_abi, from_wasm_abi)]
 pub struct CompileErrors(Vec<ICError>);
 
+impl IntoIterator for CompileErrors {
+    type Item = ICError;
+    type IntoIter = std::vec::IntoIter<ICError>;
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_iter()
+    }
+}
+
 #[wasm_bindgen]
 impl VMRef {
     #[wasm_bindgen(constructor)]
@@ -81,13 +125,26 @@ impl VMRef {
         TemplateDatabase(self.vm.get_template_database())
     }
 
-    #[wasm_bindgen(js_name = "addObjectFromFrozen")]
-    pub fn add_object_from_frozen(&self, frozen: FrozenObject) -> Result<ObjectID, JsError> {
+    #[wasm_bindgen(js_name = "addObjectFrozen")]
+    pub fn add_object_frozen(&self, frozen: FrozenObject) -> Result<ObjectID, JsError> {
         web_sys::console::log_2(
             &"(wasm) adding device".into(),
             &serde_wasm_bindgen::to_value(&frozen).unwrap(),
         );
-        Ok(self.vm.add_object_from_frozen(frozen)?)
+        Ok(self.vm.add_object_frozen(frozen)?)
+    }
+
+    #[wasm_bindgen(js_name = "addObjectsFrozen")]
+    pub fn add_objects_frozen(
+        &self,
+        frozen_objects: FrozenObjectsSparse,
+    ) -> Result<Vec<ObjectID>, JsError> {
+        web_sys::console::log_2(
+            &"(wasm) adding device".into(),
+            &serde_wasm_bindgen::to_value(&frozen_objects).unwrap(),
+        );
+
+        Ok(self.vm.add_objects_frozen(frozen_objects)?)
     }
 
     // #[wasm_bindgen(js_name = "getDevice")]
@@ -105,6 +162,16 @@ impl VMRef {
         Ok(FrozenObjects(self.vm.freeze_objects(ids)?))
     }
 
+    #[wasm_bindgen(js_name = "freezeNetwork")]
+    pub fn freeze_network(&self, id: ObjectID) -> Result<FrozenCableNetwork, JsError> {
+        Ok(self.vm.freeze_network(id)?)
+    }
+
+    #[wasm_bindgen(js_name = "freezeNetworks")]
+    pub fn freeze_networks(&self, ids: Vec<ObjectID>) -> Result<FrozenNetworks, JsError> {
+        Ok(FrozenNetworks(self.vm.freeze_networks(ids)?))
+    }
+
     #[wasm_bindgen(js_name = "setCode")]
     /// Set program code if it's valid
     pub fn set_code(&self, id: ObjectID, code: &str) -> Result<bool, JsError> {
@@ -225,7 +292,7 @@ impl VMRef {
             // TODO: we just assume if the ID is found that the frozen object passed is the same object..
             obj.get_id()
         } else {
-            self.vm.add_object_from_frozen(frozen)?
+            self.vm.add_object_frozen(frozen)?
         };
         Ok(self
             .vm

www/src/ts/virtual_machine/controls.ts

@@ -123,14 +123,14 @@ export class VMICControls extends VMActiveICMixin(BaseElement) {
               ${ics.map(
                 ([id, device], _index) =>
                   html`<sl-option
-                    name=${device.name}
-                    prefabName=${device.prefabName}
+                    name=${device.obj_info.name}
+                    prefabName=${device.obj_info.prefab}
                     value=${id}
                   >
-                    ${device.name
-                      ? html`<span slot="suffix">${device.prefabName}</span>`
+                    ${device.obj_info.name
+                      ? html`<span slot="suffix">${device.obj_info.prefab}</span>`
                       : ""}
-                    Device:${id} ${device.name ?? device.prefabName}
+                    Device:${id} ${device.obj_info.name ?? device.obj_info.prefab}
                   </sl-option>`,
               )}
             </sl-select>
@@ -156,13 +156,16 @@ export class VMICControls extends VMActiveICMixin(BaseElement) {
             <span>Errors</span>
             ${this.errors.map(
               (err) =>
-                html`<div class="hstack">
-                  <span>
-                    Line: ${err.ParseError.line} -
-                    ${err.ParseError.start}:${err.ParseError.end}
-                  </span>
-                  <span class="ms-auto">${err.ParseError.msg}</span>
-                </div>`,
+                typeof err === "object"
+                  && "ParseError" in err
+                  ? html`<div class="hstack">
+                      <span>
+                        Line: ${err.ParseError.line} -
+                        ${"ParseError" in err ? err.ParseError.start : "N/A"}:${err.ParseError.end}
+                      </span>
+                      <span class="ms-auto">${err.ParseError.msg}</span>
+                    </div>`
+                  : html`${JSON.stringify(err)}`,
             )}
           </div>
         </div>

www/src/ts/virtual_machine/device/card.ts

@@ -432,7 +432,7 @@ export class VMDeviceCard extends VMTemplateDBMixin(
     const val = parseIntWithHexOrBinary(input.value);
     if (!isNaN(val)) {
       window.VM.get().then((vm) => {
-        if (!vm.changeDeviceID(this.objectID, val)) {
+        if (!vm.changeObjectID(this.objectID, val)) {
           input.value = this.objectID.toString();
         }
       });