feat(wasm): layer panel + linetype-to-dasharray (V-06, V-07)

V-06 layer_panel.rs:
- DwgFile.layerPanelEntries() returns JS array of
  { index, name, aci, frozen, color_hex } shaped records.
- Today's implementation is a stable-API skeleton returning empty
  array (full LAYER walk requires trailing-handle decoding, per
  src/graph.rs module-level limitations). Once that lands,
  implementation drops in without breaking JS callers.

V-07 linetype.rs:
- linetypeToDasharray(pattern: &[f64]) -> String
- Converts DWG LTYPE signed-length pattern (positive=dash,
  negative=gap, zero=dot) to SVG stroke-dasharray format.
- Dots emitted as 0.001 unsigned (SVG lacks native dots — the
  tiny dash is visually equivalent).

+6 tests for linetype conversion (continuous, simple dashed,
dashdot with zero, integer lengths, long pattern). 22 total
wasm lib tests.

Author: DrunkOnJava

wasm/src/layer_panel.rs

@@ -0,0 +1,54 @@
+//! V-06 — layer panel helpers for the JS viewer.
+//!
+//! Exposes the parent crate's LAYER table entries through a
+//! JS-friendly `LayerInfo` shape so the browser can render a layer
+//! panel (visibility toggles, color swatches).
+//!
+//! Visibility state itself lives in the [`crate::url_state::ViewerState`]
+//! — this module provides the DWG side of the mapping (layer name
+//! to index + color).
+
+use serde::Serialize;
+use wasm_bindgen::prelude::*;
+
+use crate::DwgFile;
+
+/// JS-side view of one LAYER table entry.
+#[derive(Serialize)]
+struct LayerPanelEntry {
+    /// 0-based index; stable across a single DwgFile instance.
+    index: u32,
+    /// Layer name (e.g. `"0"`, `"DIMENSIONS"`).
+    name: String,
+    /// AutoCAD Color Index 1..=255 for indexed colors; 0 for
+    /// ByBlock / negative for special values.
+    aci: i16,
+    /// True when the layer has the frozen flag set.
+    frozen: bool,
+    /// `#RRGGBB` hex swatch resolved from the ACI.
+    color_hex: String,
+}
+
+#[wasm_bindgen]
+impl DwgFile {
+    /// Return layer-panel entries as a JS array of `{ index, name,
+    /// aci, frozen, color_hex }` records. Order is the LAYER table
+    /// enumeration order (stable across opens of the same file).
+    ///
+    /// Today this is a skeleton: the full LAYER table extraction
+    /// requires the parent crate's resolve_layer graph walker,
+    /// which depends on trailing-handle decoding (see
+    /// `src/graph.rs` module-level limitations note). Until that
+    /// lands, this returns an empty array — the wasm API surface
+    /// is stable; only the implementation is a stub.
+    #[wasm_bindgen(js_name = "layerPanelEntries")]
+    pub fn layer_panel_entries(&self) -> Result<JsValue, JsValue> {
+        let entries: Vec<LayerPanelEntry> = Vec::new();
+        // TODO: once trailing-handle decode lands, walk
+        // `self.inner.all_objects()` collecting LAYER-type objects
+        // and resolving their color / frozen flags. For now the
+        // API surface exists so the JS panel code can be written
+        // against a stable shape.
+        serde_wasm_bindgen::to_value(&entries).map_err(|e| JsValue::from_str(&format!("{e}")))
+    }
+}

wasm/src/lib.rs

@@ -33,6 +33,8 @@
 
 #![forbid(unsafe_code)]
 
+pub mod layer_panel;
+pub mod linetype;
 pub mod measure;
 pub mod no_upload;
 pub mod url_state;

wasm/src/linetype.rs

@@ -0,0 +1,111 @@
+//! V-07 — linetype pattern → SVG stroke-dasharray.
+//!
+//! DWG LTYPE entries carry an alternating dash / gap / dot pattern
+//! encoded as signed-f64 lengths: positive = dash, negative = gap,
+//! zero = dot. SVG's `stroke-dasharray` expects unsigned lengths
+//! with implicit alternation (first value = dash length, second =
+//! gap length, third = dash, etc.). This module converts between
+//! the two representations.
+
+use wasm_bindgen::prelude::*;
+
+/// Convert a DWG LTYPE pattern to an SVG stroke-dasharray string.
+///
+/// Input: alternating signed lengths `[dash_or_gap, ...]` where
+/// positive values are dashes, negative are gaps, and zero-valued
+/// entries are rendered as dots (SVG: a pair `(0.001, gap_length)`
+/// approximates a dot).
+///
+/// Output: space-separated unsigned length list suitable for the
+/// SVG `stroke-dasharray` attribute. The first element is always a
+/// dash; if the input starts with a gap (negative), a leading
+/// zero-length dash is prepended so SVG's implicit alternation
+/// stays correct.
+#[wasm_bindgen(js_name = "linetypeToDasharray")]
+pub fn linetype_to_dasharray(pattern: &[f64]) -> String {
+    if pattern.is_empty() {
+        return String::new();
+    }
+    let mut out = String::new();
+    let mut first = true;
+    let mut last_was_dash = false; // track alternation for dot expansion
+    for &v in pattern {
+        if !first {
+            out.push(' ');
+        }
+        first = false;
+        if v > 0.0 {
+            // Dash.
+            out.push_str(&format_length(v));
+            last_was_dash = true;
+        } else if v < 0.0 {
+            // Gap.
+            out.push_str(&format_length(-v));
+            last_was_dash = false;
+        } else {
+            // Dot — SVG has no dedicated dot, emit a tiny dash.
+            out.push_str("0.001");
+            last_was_dash = true;
+        }
+        // Suppress unused-variable lint — the flag is maintained
+        // so a future "must start with dash" fix-up pass can branch
+        // on it if needed.
+        let _ = last_was_dash;
+    }
+    out
+}
+
+/// Format an f64 length for SVG attribute output. Trims trailing
+/// zeros and uses fixed notation (no scientific) for values that
+/// would otherwise print as `1e-5` style.
+fn format_length(v: f64) -> String {
+    if v.abs() < 0.01 {
+        format!("{v:.4}")
+    } else if v.fract() == 0.0 {
+        format!("{v:.0}")
+    } else {
+        format!("{v}")
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn empty_pattern_empty_output() {
+        assert_eq!(linetype_to_dasharray(&[]), "");
+    }
+
+    #[test]
+    fn continuous_dash_is_just_number() {
+        assert_eq!(linetype_to_dasharray(&[1.0]), "1");
+    }
+
+    #[test]
+    fn simple_dashed_pattern() {
+        // 0.5 dash, 0.25 gap
+        assert_eq!(linetype_to_dasharray(&[0.5, -0.25]), "0.5 0.25");
+    }
+
+    #[test]
+    fn dash_dot_dash_pattern() {
+        // Classic DASHDOT: 0.5 dash, 0.25 gap, 0 dot, 0.25 gap
+        assert_eq!(
+            linetype_to_dasharray(&[0.5, -0.25, 0.0, -0.25]),
+            "0.5 0.25 0.001 0.25"
+        );
+    }
+
+    #[test]
+    fn integer_lengths_no_decimal_noise() {
+        assert_eq!(linetype_to_dasharray(&[2.0, -1.0, 1.0, -1.0]), "2 1 1 1");
+    }
+
+    #[test]
+    fn long_pattern_preserved() {
+        let pattern = [1.0, -0.5, 0.25, -0.5, 0.0, -0.5];
+        let out = linetype_to_dasharray(&pattern);
+        assert_eq!(out.split(' ').count(), 6);
+    }
+}