@alizarin/napi 2.0.0-alpha.90 → 2.0.0-alpha.93

package/Cargo.toml

@@ -16,6 +16,7 @@ napi = { version = "2", features = ["napi6", "serde-json"] }
 napi-derive = "2"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
+uuid = { version = "1", features = ["v4", "v5"] }
 
 [build-dependencies]
 napi-build = "2"

package/__test__/index.mjs

@@ -345,7 +345,7 @@ describe('NapiPseudoValue property names', () => {
 
   // Create instance wrapper and load tiles
   const instanceWrapper = new NapiResourceInstanceWrapper(resource.resourceinstance.graph_id);
-  instanceWrapper.loadTilesFromResource(resource);
+  instanceWrapper.loadTilesFromResource(JSON.stringify(resource));
 
   // Get a PseudoList and PseudoValue
   const pseudoList = instanceWrapper.getValuesAtPath('basic_info.name');
@@ -433,13 +433,13 @@ describe('NapiResourceInstanceWrapper methods', () => {
 
   it('has setTileDataForNode method', () => {
     const wrapper = new NapiResourceInstanceWrapper(graphId);
-    wrapper.loadTilesFromResource(resource);
+    wrapper.loadTilesFromResource(JSON.stringify(resource));
     assert.equal(typeof wrapper.setTileDataForNode, 'function');
   });
 
   it('setTileDataForNode mutates tile data', () => {
     const wrapper = new NapiResourceInstanceWrapper(graphId);
-    wrapper.loadTilesFromResource(resource);
+    wrapper.loadTilesFromResource(JSON.stringify(resource));
 
     const tileIds = wrapper.getAllTileIds();
     assert.ok(tileIds.length > 0, 'should have tiles');
@@ -459,13 +459,13 @@ describe('NapiResourceInstanceWrapper methods', () => {
     assert.equal(typeof wrapper.tilesLoaded, 'function');
     assert.equal(wrapper.tilesLoaded(), false);
 
-    wrapper.loadTilesFromResource(resource);
+    wrapper.loadTilesFromResource(JSON.stringify(resource));
     assert.equal(wrapper.tilesLoaded(), true);
   });
 
   it('has toJson method', () => {
     const wrapper = new NapiResourceInstanceWrapper(graphId);
-    wrapper.loadTilesFromResource(resource);
+    wrapper.loadTilesFromResource(JSON.stringify(resource));
     assert.equal(typeof wrapper.toJson, 'function');
     // toJson requires populate() first; just verify the method exists
     // and that calling it without populate gives a meaningful error
@@ -481,7 +481,7 @@ describe('NapiResourceInstanceWrapper methods', () => {
 
   it('exportTilesJson returns valid JSON array of tiles', () => {
     const wrapper = new NapiResourceInstanceWrapper(graphId);
-    wrapper.loadTilesFromResource(resource);
+    wrapper.loadTilesFromResource(JSON.stringify(resource));
 
     const json = wrapper.exportTilesJson();
     assert.equal(typeof json, 'string');
@@ -499,7 +499,7 @@ describe('NapiResourceInstanceWrapper methods', () => {
 
   it('exportTilesJson reflects setTileDataForNode mutations', () => {
     const wrapper = new NapiResourceInstanceWrapper(graphId);
-    wrapper.loadTilesFromResource(resource);
+    wrapper.loadTilesFromResource(JSON.stringify(resource));
 
     const tileIds = wrapper.getAllTileIds();
     const tileId = tileIds[0];

package/index.d.ts

@@ -40,6 +40,10 @@ export declare function extensionResolveMarkers(datatype: string, tileData: any,
 export declare function hasExtensionHandler(datatype: string): boolean
 /** List all registered extension handler datatypes. */
 export declare function getRegisteredExtensionHandlers(): Array<string>
+/** Parse SKOS RDF/XML and return all collections as a JSON array. */
+export declare function parseSkosXml(xmlContent: string, baseUri: string): any
+/** Parse SKOS RDF/XML and return a single collection (the first one found). */
+export declare function parseSkosXmlToCollection(xmlContent: string, baseUri: string): any
 /**
  * Import a prebuild/pkg directory: register graphs, load SKOS collections,
  * and load ontology configs.
@@ -66,6 +70,33 @@ export declare class NapiNodeConfigManager {
   /** Build node configs from a NapiStaticGraph. */
   buildFromGraph(graph: NapiStaticGraph): void
 }
+export declare class NapiTileData {
+  has(key: string): boolean
+  get(key: string): any
+  set(key: string, value: any): void
+  delete(key: string): boolean
+  keys(): Array<string>
+}
+export declare class NapiStaticTile {
+  constructor(nodegroupId: string, tileid?: string | undefined | null, sortorder?: number | undefined | null, resourceinstanceId?: string | undefined | null, parenttileId?: string | undefined | null)
+  get data(): NapiTileData
+  /**
+   * Setter is a no-op — data is always accessed via the NapiTileData getter.
+   * Exists to prevent TypeError in strict mode when JS does
+   * `tile.data = tile.data || new Map()`.
+   */
+  set data(value: any)
+  get tileid(): string | null
+  set tileid(value?: string | undefined | null)
+  get nodegroupId(): string
+  get sortorder(): number | null
+  get resourceinstanceId(): string
+  get parenttileId(): string | null
+  set parenttileId(value?: string | undefined | null)
+  get provisionaledits(): any
+  /** Generate a tile ID if not already set. */
+  ensureId(): string
+}
 export declare class NapiPseudoValue {
   get node(): any
   get nodeId(): string | null
@@ -96,6 +127,12 @@ export declare class NapiPseudoValue {
   toSnapshot(): any
   /** Clear tile data */
   clear(): void
+  get tile(): NapiStaticTile | null
+  set tile(tile?: NapiStaticTile | undefined | null)
+  /** Get the inner PseudoValueCore wrapped as NapiPseudoValue. */
+  get inner(): NapiPseudoValue | null
+  /** Returns null — value is managed JS-side via _cachedValue. */
+  get value(): any
 }
 export declare class NapiPseudoList {
   get nodeAlias(): string
@@ -128,10 +165,15 @@ export declare class NapiValuesFromNodegroupResult {
 export declare class NapiResourceInstanceWrapper {
   /** Create a wrapper for a given graph (must be registered). */
   constructor(graphId: string)
-  /** Load tiles from a JSON array. */
-  loadTiles(tilesJs: any): void
-  /** Load tiles directly from a StaticResource JSON. */
-  loadTilesFromResource(resourceJs: any): void
+  /** Load tiles from a JSON string (single-pass deserialization). */
+  loadTiles(tilesJson: string): void
+  /** Load tiles directly from a StaticResource JSON string (single-pass deserialization). */
+  loadTilesFromResource(resourceJson: string): void
+  /**
+   * Load tiles directly from a NapiStaticResourceRegistry by resource ID.
+   * This avoids the JS round-trip of serializing tiles to JS and back.
+   */
+  loadFromRegistry(resourceId: string, registry: NapiStaticResourceRegistry): boolean
   /** Append tiles incrementally (for lazy loading). */
   appendTiles(tilesJs: any): void
   getTileCount(): number

package/index.js

@@ -310,10 +310,12 @@ if (!nativeBinding) {
   throw new Error(`Failed to load native binding`)
 }
 
-const { NapiRdmCache, NapiNodeConfigManager, NapiPseudoValue, NapiPseudoList, NapiPopulateResult, NapiEnsureNodegroupResult, NapiValuesFromNodegroupResult, NapiResourceInstanceWrapper, NapiResourceModelWrapper, NapiPrebuildExporter, NapiStaticGraph, NapiStaticResourceRegistry, buildGraphFromCsvs, buildBusinessDataFromCsv, extensionCoerce, extensionRenderDisplay, extensionResolveMarkers, hasExtensionHandler, getRegisteredExtensionHandlers, importPrebuild } = nativeBinding
+const { NapiRdmCache, NapiNodeConfigManager, NapiTileData, NapiStaticTile, NapiPseudoValue, NapiPseudoList, NapiPopulateResult, NapiEnsureNodegroupResult, NapiValuesFromNodegroupResult, NapiResourceInstanceWrapper, NapiResourceModelWrapper, NapiPrebuildExporter, NapiStaticGraph, NapiStaticResourceRegistry, buildGraphFromCsvs, buildBusinessDataFromCsv, extensionCoerce, extensionRenderDisplay, extensionResolveMarkers, hasExtensionHandler, getRegisteredExtensionHandlers, parseSkosXml, parseSkosXmlToCollection, importPrebuild } = nativeBinding
 
 module.exports.NapiRdmCache = NapiRdmCache
 module.exports.NapiNodeConfigManager = NapiNodeConfigManager
+module.exports.NapiTileData = NapiTileData
+module.exports.NapiStaticTile = NapiStaticTile
 module.exports.NapiPseudoValue = NapiPseudoValue
 module.exports.NapiPseudoList = NapiPseudoList
 module.exports.NapiPopulateResult = NapiPopulateResult
@@ -331,4 +333,6 @@ module.exports.extensionRenderDisplay = extensionRenderDisplay
 module.exports.extensionResolveMarkers = extensionResolveMarkers
 module.exports.hasExtensionHandler = hasExtensionHandler
 module.exports.getRegisteredExtensionHandlers = getRegisteredExtensionHandlers
+module.exports.parseSkosXml = parseSkosXml
+module.exports.parseSkosXmlToCollection = parseSkosXmlToCollection
 module.exports.importPrebuild = importPrebuild

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alizarin/napi",
-  "version": "2.0.0-alpha.90",
+  "version": "2.0.0-alpha.93",
   "license": "AGPL-3.0-or-later",
   "repository": {
     "type": "git",
@@ -30,8 +30,8 @@
     "@napi-rs/cli": "^2.18.0"
   },
   "optionalDependencies": {
-    "@alizarin/napi-win32-x64-msvc": "2.0.0-alpha.90",
-    "@alizarin/napi-darwin-x64": "2.0.0-alpha.90",
-    "@alizarin/napi-linux-x64-gnu": "2.0.0-alpha.90"
+    "@alizarin/napi-win32-x64-msvc": "2.0.0-alpha.93",
+    "@alizarin/napi-darwin-x64": "2.0.0-alpha.93",
+    "@alizarin/napi-linux-x64-gnu": "2.0.0-alpha.93"
   }
 }

package/src/instance_wrapper_napi.rs

@@ -4,7 +4,7 @@
 /// the TypeScript ViewModel layer (ResourceInstanceWrapper / PseudoValue / PseudoList)
 /// can work with either backend.
 use std::collections::HashMap;
-use std::sync::Arc;
+use std::sync::{Arc, Mutex};
 
 use napi::bindgen_prelude::*;
 use napi_derive::napi;
@@ -118,6 +118,181 @@ impl NapiNodeConfigManager {
     }
 }
 
+// =============================================================================
+// NapiTileData — Map-like interface over HashMap<String, Value>
+// =============================================================================
+
+#[napi]
+pub struct NapiTileData {
+    entries: Arc<Mutex<HashMap<String, serde_json::Value>>>,
+}
+
+#[napi]
+impl NapiTileData {
+    #[napi]
+    pub fn has(&self, key: String) -> bool {
+        self.entries.lock().unwrap().contains_key(&key)
+    }
+
+    #[napi]
+    pub fn get(&self, key: String) -> serde_json::Value {
+        self.entries
+            .lock()
+            .unwrap()
+            .get(&key)
+            .cloned()
+            .unwrap_or(serde_json::Value::Null)
+    }
+
+    #[napi]
+    pub fn set(&mut self, key: String, value: serde_json::Value) {
+        self.entries.lock().unwrap().insert(key, value);
+    }
+
+    #[napi]
+    pub fn delete(&mut self, key: String) -> bool {
+        self.entries.lock().unwrap().remove(&key).is_some()
+    }
+
+    #[napi]
+    pub fn keys(&self) -> Vec<String> {
+        self.entries.lock().unwrap().keys().cloned().collect()
+    }
+}
+
+// =============================================================================
+// NapiStaticTile — Rust-owned tile with Map-like .data access
+// =============================================================================
+
+#[napi]
+pub struct NapiStaticTile {
+    tileid: Option<String>,
+    nodegroup_id: String,
+    sortorder: Option<i32>,
+    resourceinstance_id: String,
+    parenttile_id: Option<String>,
+    provisionaledits: Option<Vec<serde_json::Value>>,
+    data_store: Arc<Mutex<HashMap<String, serde_json::Value>>>,
+}
+
+#[napi]
+impl NapiStaticTile {
+    #[napi(constructor)]
+    pub fn new(
+        nodegroup_id: String,
+        tileid: Option<String>,
+        sortorder: Option<i32>,
+        resourceinstance_id: Option<String>,
+        parenttile_id: Option<String>,
+    ) -> Self {
+        NapiStaticTile {
+            tileid,
+            nodegroup_id,
+            sortorder,
+            resourceinstance_id: resourceinstance_id.unwrap_or_default(),
+            parenttile_id,
+            provisionaledits: None,
+            data_store: Arc::new(Mutex::new(HashMap::new())),
+        }
+    }
+
+    #[napi(getter)]
+    pub fn data(&self) -> NapiTileData {
+        NapiTileData {
+            entries: self.data_store.clone(),
+        }
+    }
+
+    /// Setter is a no-op — data is always accessed via the NapiTileData getter.
+    /// Exists to prevent TypeError in strict mode when JS does
+    /// `tile.data = tile.data || new Map()`.
+    #[napi(setter)]
+    pub fn set_data(&mut self, _value: serde_json::Value) {
+        // No-op: mutations go through NapiTileData.set/delete
+    }
+
+    #[napi(getter)]
+    pub fn tileid(&self) -> Option<String> {
+        self.tileid.clone()
+    }
+
+    #[napi(setter)]
+    pub fn set_tileid(&mut self, value: Option<String>) {
+        self.tileid = value;
+    }
+
+    #[napi(getter)]
+    pub fn nodegroup_id(&self) -> String {
+        self.nodegroup_id.clone()
+    }
+
+    #[napi(getter)]
+    pub fn sortorder(&self) -> Option<i32> {
+        self.sortorder
+    }
+
+    #[napi(getter)]
+    pub fn resourceinstance_id(&self) -> String {
+        self.resourceinstance_id.clone()
+    }
+
+    #[napi(getter)]
+    pub fn parenttile_id(&self) -> Option<String> {
+        self.parenttile_id.clone()
+    }
+
+    #[napi(setter)]
+    pub fn set_parenttile_id(&mut self, value: Option<String>) {
+        self.parenttile_id = value;
+    }
+
+    #[napi(getter)]
+    pub fn provisionaledits(&self) -> serde_json::Value {
+        match &self.provisionaledits {
+            Some(edits) => serde_json::to_value(edits).unwrap_or(serde_json::Value::Null),
+            None => serde_json::Value::Null,
+        }
+    }
+
+    /// Generate a tile ID if not already set.
+    #[napi(js_name = "ensureId")]
+    pub fn ensure_id(&mut self) -> String {
+        if self.tileid.is_none() {
+            self.tileid = Some(uuid::Uuid::new_v4().to_string());
+        }
+        self.tileid.clone().unwrap()
+    }
+}
+
+impl NapiStaticTile {
+    /// Convert to core StaticTile for storage in PseudoValueCore.
+    pub(crate) fn to_static_tile(&self) -> StaticTile {
+        let data = self.data_store.lock().unwrap().clone();
+        StaticTile {
+            tileid: self.tileid.clone(),
+            nodegroup_id: self.nodegroup_id.clone(),
+            sortorder: self.sortorder,
+            resourceinstance_id: self.resourceinstance_id.clone(),
+            parenttile_id: self.parenttile_id.clone(),
+            provisionaledits: self.provisionaledits.clone(),
+            data,
+        }
+    }
+
+    /// Create from a core StaticTile.
+    pub(crate) fn from_static_tile(tile: &StaticTile) -> Self {
+        NapiStaticTile {
+            tileid: tile.tileid.clone(),
+            nodegroup_id: tile.nodegroup_id.clone(),
+            sortorder: tile.sortorder,
+            resourceinstance_id: tile.resourceinstance_id.clone(),
+            parenttile_id: tile.parenttile_id.clone(),
+            provisionaledits: tile.provisionaledits.clone(),
+            data_store: Arc::new(Mutex::new(tile.data.clone())),
+        }
+    }
+}
+
 // =============================================================================
 // NapiPseudoValue
 // =============================================================================
@@ -269,15 +444,17 @@ impl NapiPseudoValue {
     pub fn to_snapshot(&self) -> serde_json::Value {
         serde_json::json!({
             "nodeId": self.inner.node.nodeid,
+            "name": &self.inner.node.name,
             "alias": self.inner.node.alias,
             "datatype": &self.inner.node.datatype,
             "nodegroupId": self.inner.node.nodegroup_id,
+            "sortorder": self.inner.node.sortorder,
+            "isOuter": self.inner.is_outer(),
+            "isInner": self.inner.is_inner,
             "isCollector": self.inner.is_collector,
+            "accessed": false,
             "independent": self.inner.independent,
-            "exportable": self.inner.node.exportable,
-            "isrequired": self.inner.node.isrequired,
-            "issearchable": self.inner.node.issearchable,
-            "hascustomalias": self.inner.node.hascustomalias,
+            "hasTile": self.inner.tile.is_some(),
             "tileId": self.inner.tile.as_ref().and_then(|t| t.tileid.clone()),
             "tileData": &self.inner.tile_data,
             "valueLoaded": self.inner.tile.is_some(),
@@ -290,6 +467,45 @@ impl NapiPseudoValue {
     pub fn clear(&mut self) {
         self.inner.tile_data = None;
     }
+
+    // -- Tile getter/setter (NapiStaticTile, Rust-owned) --
+
+    #[napi(getter, js_name = "tile")]
+    pub fn get_tile(&self) -> Option<NapiStaticTile> {
+        self.inner
+            .tile
+            .as_ref()
+            .map(|t| NapiStaticTile::from_static_tile(t.as_ref()))
+    }
+
+    #[napi(setter, js_name = "tile")]
+    pub fn set_tile(&mut self, tile: Option<&NapiStaticTile>) {
+        match tile {
+            Some(t) => {
+                self.inner.tile = Some(Arc::new(t.to_static_tile()));
+            }
+            None => {
+                self.inner.tile = None;
+            }
+        }
+    }
+
+    // -- Inner (outer/inner pattern) --
+
+    /// Get the inner PseudoValueCore wrapped as NapiPseudoValue.
+    #[napi(getter)]
+    pub fn inner(&self) -> Option<NapiPseudoValue> {
+        self.inner
+            .inner
+            .as_ref()
+            .map(|i| NapiPseudoValue { inner: *i.clone() })
+    }
+
+    /// Returns null — value is managed JS-side via _cachedValue.
+    #[napi(getter)]
+    pub fn value(&self) -> serde_json::Value {
+        serde_json::Value::Null
+    }
 }
 
 // =============================================================================
@@ -530,19 +746,19 @@ impl NapiResourceInstanceWrapper {
     // Tile loading
     // =========================================================================
 
-    /// Load tiles from a JSON array.
+    /// Load tiles from a JSON string (single-pass deserialization).
     #[napi]
-    pub fn load_tiles(&mut self, tiles_js: serde_json::Value) -> Result<()> {
-        let tiles: Vec<StaticTile> = serde_json::from_value(tiles_js)
+    pub fn load_tiles(&mut self, tiles_json: String) -> Result<()> {
+        let tiles: Vec<StaticTile> = serde_json::from_str(&tiles_json)
             .map_err(|e| napi::Error::from_reason(format!("Invalid tiles JSON: {e}")))?;
         self.inner.load_tiles(tiles);
         Ok(())
     }
 
-    /// Load tiles directly from a StaticResource JSON.
+    /// Load tiles directly from a StaticResource JSON string (single-pass deserialization).
     #[napi]
-    pub fn load_tiles_from_resource(&mut self, resource_js: serde_json::Value) -> Result<()> {
-        let resource: StaticResource = serde_json::from_value(resource_js)
+    pub fn load_tiles_from_resource(&mut self, resource_json: String) -> Result<()> {
+        let resource: StaticResource = serde_json::from_str(&resource_json)
             .map_err(|e| napi::Error::from_reason(format!("Invalid resource JSON: {e}")))?;
 
         self.inner.resource_instance = Some(resource.resourceinstance.clone());

package/src/lib.rs

@@ -529,6 +529,35 @@ pub fn get_registered_extension_handlers() -> Vec<String> {
         .collect()
 }
 
+// ============================================================================
+// SKOS parsing
+// ============================================================================
+
+/// Parse SKOS RDF/XML and return all collections as a JSON array.
+#[napi(js_name = "parseSkosXml")]
+pub fn parse_skos_xml(xml_content: String, base_uri: String) -> Result<serde_json::Value> {
+    let collections = alizarin_core::skos::parse_skos_to_collections(&xml_content, &base_uri)
+        .map_err(napi::Error::from_reason)?;
+    serde_json::to_value(&collections).map_err(|e| napi::Error::from_reason(e.to_string()))
+}
+
+/// Parse SKOS RDF/XML and return a single collection (the first one found).
+#[napi(js_name = "parseSkosXmlToCollection")]
+pub fn parse_skos_xml_to_collection(
+    xml_content: String,
+    base_uri: String,
+) -> Result<serde_json::Value> {
+    let mut collections = alizarin_core::skos::parse_skos_to_collections(&xml_content, &base_uri)
+        .map_err(napi::Error::from_reason)?;
+    if collections.is_empty() {
+        return Err(napi::Error::from_reason(
+            "No SKOS ConceptScheme found in XML".to_string(),
+        ));
+    }
+    let collection = collections.remove(0);
+    serde_json::to_value(&collection).map_err(|e| napi::Error::from_reason(e.to_string()))
+}
+
 // ============================================================================
 // Prebuild import (high-level convenience)
 // ============================================================================