Support inverted axis mapping and local icons (#56)

* add reverse axis mapping and test

* clean up

* implement loading local icons as data url

* tried to improve monaco editor size, i don't think it helped

compiler-core/src/comp/comp_coord.rs

@@ -14,6 +14,9 @@ macro_rules! map_coord {
                     Axis::X => $output.0 = n,
                     Axis::Y => $output.1 = n,
                     Axis::Z => $output.2 = n,
+                    Axis::NegX => $output.0 = -n,
+                    Axis::NegY => $output.1 = -n,
+                    Axis::NegZ => $output.2 = -n,
                 }
                 Ok(())
             }

compiler-core/src/comp/mod.rs

@@ -1,8 +1,11 @@
+use std::convert::Infallible;
+
 use celerctypes::DocDiagnostic;
 use serde_json::Value;
 
 use crate::lang::parse_poor;
 use crate::pack::PackerError;
+#[cfg(feature = "wasm")]
 use crate::util::WasmError;
 
 mod comp_coord;
@@ -123,6 +126,12 @@ pub enum CompilerError {
     Wasm(#[from] WasmError),
 }
 
+impl From<Infallible> for CompilerError {
+    fn from(_: Infallible) -> Self {
+        unreachable!()
+    }
+}
+
 impl CompilerError {
     /// Get the more info url for a compiler error
     pub fn get_info_url(&self) -> String {
@@ -164,6 +173,7 @@ impl CompilerError {
             CompilerError::InvalidRouteType => {
                 "https://celer.pistonite.org/docs/route/route-structure#entry-point".to_string()
             }
+            #[cfg(feature = "wasm")]
             CompilerError::Wasm(_) => "".to_string(),
         }
     }
@@ -187,10 +197,11 @@ impl CompilerError {
             | CompilerError::IsPreface(_)
             | CompilerError::InvalidSectionType
             | CompilerError::PackerErrors(_)
-            | CompilerError::Wasm(_)
             | CompilerError::InvalidRouteType => "error",
 
             CompilerError::UnusedProperty(_) | CompilerError::TooManyTagsInCounter => "warn",
+            #[cfg(feature = "wasm")]
+            CompilerError::Wasm(_) => "error",
         };
 
         s.to_string()

compiler-core/src/exec/exec_section.rs

@@ -32,8 +32,7 @@ impl CompSection {
 mod test {
     use celerctypes::{GameCoord, MapIcon, MapLine, MapMarker};
 
-    use crate::comp::{CompMarker, CompMovement};
-    use crate::CompLine;
+    use crate::comp::{CompLine, CompMarker, CompMovement};
 
     use super::*;
 

compiler-core/src/exec/mod.rs

@@ -4,6 +4,8 @@
 //! The [`CompDoc`] will be transformed into a [`ExecDoc`]
 //! for rendering
 
+use std::convert::Infallible;
+
 mod exec_line;
 pub use exec_line::*;
 mod exec_map;
@@ -13,10 +15,12 @@ pub use exec_section::*;
 mod exec_doc;
 pub use exec_doc::*;
 
+#[cfg(feature = "wasm")]
 use crate::util::WasmError;
 
 #[derive(Debug, Clone, thiserror::Error)]
 pub enum ExecError {
+    #[cfg(feature = "wasm")]
     #[error("wasm error: {0}")]
     Wasm(#[from] WasmError),
 }
@@ -31,3 +35,9 @@ impl ExecError {
         x
     }
 }
+
+impl From<Infallible> for ExecError {
+    fn from(_: Infallible) -> Self {
+        unreachable!()
+    }
+}

compiler-core/src/lang/tempstr/hydrate.rs

@@ -11,7 +11,7 @@ impl TempStr {
         S: AsRef<str>,
     {
         let mut s = String::new();
-        async_for!(block in &self.0, {
+        let _ = async_for!(block in &self.0, {
             match block {
                 TempStrBlock::Lit(lit) => s.push_str(lit),
                 TempStrBlock::Var(idx) => {

compiler-core/src/pack/mod.rs

@@ -8,6 +8,7 @@
 //! and a json blob of the route.
 
 use std::collections::BTreeMap;
+use std::convert::Infallible;
 use serde_json::{Map, Value};
 
 use celerctypes::DocDiagnostic;
@@ -32,6 +33,7 @@ pub use resource::*;
 
 use crate::json::Cast;
 use crate::lang::parse_poor;
+#[cfg(feature = "wasm")]
 use crate::util::{WasmError, Path};
 
 #[derive(Debug, Clone, PartialEq, thiserror::Error)]
@@ -133,6 +135,12 @@ impl PackerError {
     }
 }
 
+impl From<Infallible> for PackerError {
+    fn from(_: Infallible) -> Self {
+        unreachable!()
+    }
+}
+
 pub type PackerResult<T> = Result<T, PackerError>;
 
 /// JSON value with an Err variant
@@ -250,3 +258,36 @@ impl PackerValue {
         }
     }
 }
+
+pub enum ImageFormat {
+    PNG,
+    JPEG,
+    GIF,
+    WEBP,
+}
+
+impl ImageFormat {
+    pub fn try_from_path(path: &str) -> Option<Self> {
+        let path = path.to_lowercase();
+        if path.ends_with(".png") {
+            Some(Self::PNG)
+        } else if path.ends_with(".jpg") || path.ends_with(".jpeg") {
+            Some(Self::JPEG)
+        } else if path.ends_with(".gif") {
+            Some(Self::GIF)
+        } else if path.ends_with(".webp") {
+            Some(Self::WEBP)
+        } else {
+            None
+        }
+    }
+
+    pub fn media_type(&self) -> &'static str {
+        match self {
+            Self::PNG => "image/png",
+            Self::JPEG => "image/jpeg",
+            Self::GIF => "image/gif",
+            Self::WEBP => "image/webp",
+        }
+    }
+}

compiler-core/src/pack/pack_coord_map.rs

@@ -350,5 +350,18 @@ mod test {
                 mapping_3d: (Axis::X, Axis::Z, Axis::Z),
             })
         );
+
+        let v = json!({
+            "2d": ["-x", "x"],
+            "3d": ["x", "-z", "-y"],
+        });
+        let result = pack_coord_map(v, 0).await;
+        assert_eq!(
+            result,
+            Ok(MapCoordMap {
+                mapping_2d: (Axis::NegX, Axis::X),
+                mapping_3d: (Axis::X, Axis::NegZ, Axis::NegY),
+            })
+        );
     }
 }

compiler-core/src/pack/pack_preset.rs

@@ -64,7 +64,7 @@ async fn pack_presets_internal(
             })?;
             output.push((full_key, preset));
         }
-    });
+    })?;
 
     Ok(())
 }

compiler-core/src/pack/pack_route.rs

@@ -50,7 +50,7 @@ async fn pack_route_internal(
     let route = match route.try_into_array() {
         Ok(arr) => {
             let mut output = vec![];
-            async_for!(x in arr.into_iter(), {
+            let _ = async_for!(x in arr.into_iter(), {
                 match Use::from(x) {
                     Use::Invalid(path) => {
                         output.push(PackerValue::Err(PackerError::InvalidUse(path)));

compiler-core/src/pack/resource/loader_cache.rs

@@ -3,15 +3,15 @@ use serde_json::Value;
 
 use crate::pack::PackerResult;
 
-use super::ResourceLoader;
+use super::{ResourceLoader, ArcLoader};
 
 /// A loader that caches loaded resources in memory. The cache is global.
-pub struct GlobalCacheLoader<L> where L: ResourceLoader {
-    delegate: L,
+pub struct GlobalCacheLoader {
+    delegate: ArcLoader,
 }
 
-impl<L> GlobalCacheLoader<L> where L: ResourceLoader {
-    pub fn new(delegate: L) -> Self {
+impl GlobalCacheLoader {
+    pub fn new(delegate: ArcLoader) -> Self {
         Self {
             delegate,
         }
@@ -20,7 +20,7 @@ impl<L> GlobalCacheLoader<L> where L: ResourceLoader {
 
 #[cfg_attr(not(feature = "wasm"), async_trait::async_trait)]
 #[cfg_attr(feature = "wasm", async_trait::async_trait(?Send))]
-impl<L> ResourceLoader for GlobalCacheLoader<L> where L: ResourceLoader {
+impl ResourceLoader for GlobalCacheLoader {
 
     async fn load_raw(&self, r: &str) -> PackerResult<Vec<u8>> {
         self.delegate.load_raw(r).await
@@ -44,7 +44,7 @@ impl<L> ResourceLoader for GlobalCacheLoader<L> where L: ResourceLoader {
     // TTL of 5 minutes
     time=300,
 )]
-async fn load_structured_internal(loader: &dyn ResourceLoader, path: &str) -> PackerResult<Value> {
+async fn load_structured_internal(loader: &ArcLoader, path: &str) -> PackerResult<Value> {
     loader.load_structured(path).await
 }
 

compiler-core/src/pack/resource/resource.rs

@@ -8,7 +8,7 @@ use crate::util::Path;
 use super::ResourceLoader;
 
 #[cfg(not(feature = "wasm"))]
-pub type ArcLoader<R> = Arc<dyn ResourceLoader<Ref=R> + Send + Sync>;
+pub type ArcLoader = Arc<dyn ResourceLoader + Send + Sync>;
 #[cfg(not(feature = "wasm"))]
 pub type ArcResolver = Arc<dyn ResourceResolver + Send + Sync>;
 #[cfg(feature = "wasm")]

compiler-core/src/util/async_macro.rs

@@ -6,7 +6,8 @@ macro_rules! async_for {
             tokio::task::yield_now().await;
             $body
         }
-        Ok(())
+        let r: Result<(), std::convert::Infallible> = Ok(());
+        r
     }};
 }
 pub(crate) use async_for;

compiler-core/src/util/async_macro_wasm.rs

@@ -59,7 +59,7 @@ pub async fn set_timeout_yield() -> Result<(), WasmError> {
 macro_rules! async_for {
     ($v:pat in $iter:expr, $body:stmt) => {
         {
-            let mut result = Ok(());
+            let mut result: Result<(), $crate::util::async_macro_wasm::WasmError> = Ok(());
             for $v in $iter {
                 result = $crate::util::async_macro_wasm::set_timeout_yield().await;
                 if result.is_err() {

compiler-types/src/build.rs

@@ -48,8 +48,7 @@ fn main_internal() -> io::Result<()> {
         OUTPUT_FILE,
         output)?;
 
-    // run prettier
-    run_prettier()
+    Ok(())
 }
 
 fn generate_bindings() -> io::Result<()> {
@@ -82,21 +81,3 @@ fn transform_file(file_path: &Path) -> io::Result<String> {
     Ok(transformed)
 }
 
-fn run_prettier() -> io::Result<()> {
-    println!("formatting with prettier");
-    let result = process::Command::new("npm")
-        .args(&["run", "fmt:compiler"])
-        .current_dir("../web-client")
-        .spawn()?
-        .wait_with_output()?;
-
-    if !result.status.success() {
-        eprintln!("prettier finished with error");
-        eprintln!("{}", String::from_utf8_lossy(&result.stderr));
-        return Err(io::Error::new(io::ErrorKind::Other, "prettier failed"));
-    } else {
-        println!("{}", String::from_utf8_lossy(&result.stdout));
-    }
-    Ok(())
-}
-

compiler-types/src/map.rs

@@ -121,6 +121,15 @@ pub enum Axis {
     Y,
     /// Height axis
     Z,
+    /// Negative Horizontal axis
+    #[serde(rename = "-x")]
+    NegX,
+    /// Negative Vertical axis
+    #[serde(rename = "-y")]
+    NegY,
+    /// Negative Height axis
+    #[serde(rename = "-z")]
+    NegZ,
 }
 
 /// Map features for one section

compiler-wasm/Cargo.toml

@@ -17,6 +17,7 @@ js-sys = "0.3.64"
 async-trait = "0.1.73"
 log = { version = "0.4.20", features = ["std"] } 
 web-sys = { version = "0.3.64", features = ["console"] }
+base64 = "0.21.4"
 
 [lib]
 name = "celercwasm"

compiler-wasm/src/api.rs

@@ -20,7 +20,7 @@ thread_local! {
 }
 
 thread_local! {
-    static URL_LOADER: ArcLoader = Arc::new(GlobalCacheLoader::new(UrlLoader));
+    static URL_LOADER: ArcLoader = Arc::new(GlobalCacheLoader::new(Arc::new(UrlLoader)));
 }
 
 thread_local! {

compiler-wasm/src/resource.rs

@@ -1,7 +1,9 @@
 //! Compiler resource resolver and loader implementation for WASM context
 use std::cell::RefCell;
+use base64::Engine;
+use base64::engine::general_purpose;
 
-use celerc::pack::{PackerResult, ResourceLoader, PackerError};
+use celerc::pack::{PackerResult, ResourceLoader, PackerError, ImageFormat};
 use celerc::yield_now;
 use js_sys::{Function, Uint8Array};
 use wasm_bindgen::{JsValue, JsCast};
@@ -10,7 +12,6 @@ use crate::wasm::{into_future, stub_function};
 
 /// Loader for files from web editor
 pub struct FileLoader {
-
     /// Callback function to ask JS to load a file
     ///
     /// Takes in a string as argument.
@@ -46,9 +47,13 @@ impl ResourceLoader for FileLoader {
     }
 
     async fn load_image_url(&self, path: &str) -> PackerResult<String> {
-        Err(PackerError::NotImpl(
-            "FileLoader::load_image_url is not implemented".to_string(),
-        ))
+        let image_format = ImageFormat::try_from_path(path).ok_or_else(|| {
+            PackerError::LoadFile(format!("Cannot determine image format from path: {path}"))
+        })?.media_type();
+        let mut data_url = format!("data:{image_format};base64,");
+        let vec = self.load_raw(path).await?;
+        general_purpose::STANDARD.encode_string(&vec, &mut data_url);
+        Ok(data_url)
     }
 }