alizarin 0.2.1-alpha.83

package/dist/alizarin.js

@@ -0,0 +1,47 @@
+import { A, K, G, p, R, o, S, L, N, c, I, J, T, k, y, Q, t, B, l, b, _, j, D, m, F, H, r, a, i, z, O, q, P, x, d, f, s, E, h, u, M, v, e, w } from "./main-r-MmUiQf.js";
+export {
+  A as AlizarinModel,
+  K as CollectionMutator,
+  G as GraphManager,
+  p as GraphMutator,
+  R as RDM,
+  o as ResourceModelWrapper,
+  S as autoDetectBackend,
+  L as buildGraphFromModelCsvs,
+  N as buildResourcesFromBusinessCsv,
+  c as client,
+  I as collectionToSkosXml,
+  J as collectionsToSkosXml,
+  T as createResourceRegistry,
+  k as createWKRM,
+  y as ensureWasmRdmCache,
+  Q as getBackend,
+  t as getCurrentLanguage,
+  B as getTimingStats,
+  l as getWKRMClass,
+  b as graphManager,
+  _ as initWasm,
+  j as interfaces,
+  D as logTimingStats,
+  m as nodeConfig,
+  F as parseSkosXml,
+  H as parseSkosXmlToCollection,
+  r as registerExtensionHandler,
+  a as registerResolvableDatatype,
+  i as renderers,
+  z as resetTimingStats,
+  O as setBackend,
+  q as setCurrentLanguage,
+  P as setNapiModule,
+  x as setWasmURL,
+  d as slugify,
+  f as staticStore,
+  s as staticTypes,
+  E as tracing,
+  h as unregisterResolvableDatatype,
+  u as utils,
+  M as validateModelCsvs,
+  v as version,
+  e as viewModels,
+  w as wasmReady
+};

package/dist/alizarin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"alizarin.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/backend.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Backend abstraction for WASM vs NAPI.
+ *
+ * When running in Node.js CLI environments (e.g., starches-builder), the NAPI
+ * backend avoids WASM linear memory limits. In browsers or when NAPI is
+ * unavailable, the WASM backend is used.
+ *
+ * Usage:
+ *   import { setBackend, createInstanceWrapper } from './backend';
+ *   setBackend('napi');  // before any wrapper creation
+ */
+import type { StaticResource } from "./static-types";
+export type BackendType = 'wasm' | 'napi';
+/**
+ * Register the loaded WASM module. Called by _wasm.ts after initialization.
+ * This avoids require() of ESM packages in factory functions.
+ */
+export declare function setWasmModule(mod: any): void;
+/**
+ * Set the active backend. Must be called before creating any instance wrappers.
+ */
+export declare function setBackend(backend: BackendType): void;
+export declare function getBackend(): BackendType;
+/**
+ * Register a pre-loaded NAPI module (for when require() path resolution
+ * doesn't work, e.g., in bundled environments).
+ */
+export declare function setNapiModule(mod: any): void;
+/**
+ * Create an instance wrapper for a resource.
+ * Returns either a WASMResourceInstanceWrapper or NapiResourceInstanceWrapper,
+ * both of which share the same method interface.
+ */
+export declare function createInstanceWrapperForResource(resource: StaticResource): any;
+/**
+ * Create an instance wrapper for a model (no resource data yet).
+ */
+export declare function createInstanceWrapperForModel(graphId: string): any;
+/**
+ * Create a resource registry (for staticStore).
+ */
+export declare function createResourceRegistry(): any;
+/**
+ * Get or create a backend-appropriate RDM cache.
+ * In WASM mode returns WasmRdmCache; in NAPI mode returns NapiRdmCache.
+ */
+export declare function getRdmCache(): any;
+/**
+ * Get or create a backend-appropriate node config manager.
+ */
+export declare function getNodeConfigManager(): any;
+/**
+ * Create a model wrapper backend (graph schema operations).
+ * Returns either a WASMResourceModelWrapper or NapiResourceModelWrapper.
+ *
+ * In WASM mode, the wkrm is passed to the constructor (WASM stores it).
+ * In NAPI mode, only the graph and defaultAllow are needed — wkrm is
+ * stored in the TS ResourceModelWrapper directly.
+ */
+export declare function createResourceModelWrapper(wkrm: any, graph: any, defaultAllow: boolean): any;
+/**
+ * Create a WKRM (Well-Known Resource Model) from graph metadata.
+ * In WASM mode uses the Rust WKRM class; in NAPI mode uses a pure TS equivalent.
+ */
+export declare function createWKRM(meta: any): any;
+/**
+ * Get the WKRM class itself (for instanceof checks or direct construction).
+ */
+export declare function getWKRMClass(): any;
+/**
+ * Auto-detect the best backend for the current environment.
+ * Prefers NAPI in Node.js when available, falls back to WASM.
+ */
+export declare function autoDetectBackend(): BackendType;

package/dist/cards.d.ts

@@ -0,0 +1,21 @@
+import { StaticNode } from "./static-types";
+declare class CardComponent {
+    id: string;
+    name: string;
+    constructor(id: string, name: string);
+}
+declare class Widget {
+    id: string;
+    name: string;
+    datatype: string;
+    defaultConfig: string;
+    constructor(id: string, name: string, datatype: string, defaultConfig: string);
+    getDefaultConfig(): {
+        [key: string]: any;
+    };
+}
+declare const DEFAULT_CARD_COMPONENT: CardComponent;
+declare function getDefaultWidgetForNode(node: StaticNode, preferences?: {
+    [key: string]: string;
+}): Widget;
+export { DEFAULT_CARD_COMPONENT, CardComponent, getDefaultWidgetForNode, Widget };

package/dist/client.d.ts

@@ -0,0 +1,86 @@
+import { StaticGraphMeta, StaticGraph, StaticResource, StaticResourceSummary, StaticResourceRegistry, StaticTile } from "./static-types";
+import { StaticCollection } from "./rdm";
+declare class GraphResult {
+    models: {
+        [graphId: string]: StaticGraphMeta;
+    };
+    constructor(jsonData: GraphResult);
+}
+declare abstract class ArchesClient {
+    registry: StaticResourceRegistry | null;
+    abstract getGraphs(): Promise<GraphResult>;
+    abstract getGraph(graph: StaticGraphMeta): Promise<StaticGraph | null>;
+    abstract getGraphByIdOnly(graphId: string): Promise<StaticGraph | null>;
+    abstract getResources(graphId: string, limit: number, reloadIfSeen: boolean): Promise<StaticResource[]>;
+    abstract getResource(resourceId: string): Promise<StaticResource>;
+    abstract getCollection(collectionId: string): Promise<StaticCollection>;
+    abstract getResourceSummaries(graphId: string, limit: number): Promise<StaticResourceSummary[]>;
+    abstract getResourceTiles(resourceId: string): Promise<StaticTile[]>;
+}
+declare class ArchesClientRemote extends ArchesClient {
+    archesUrl: string;
+    constructor(archesUrl: string);
+    getGraphs(): Promise<GraphResult>;
+    getGraph(graph: StaticGraphMeta): Promise<StaticGraph>;
+    getGraphByIdOnly(graphId: string): Promise<StaticGraph>;
+    getResource(resourceId: string): Promise<StaticResource>;
+    getCollection(collectionId: string): Promise<StaticCollection>;
+    getResources(graphId: string, limit: number, _reloadIfSeen: boolean): Promise<StaticResource[]>;
+    getResourceSummaries(graphId: string, limit: number): Promise<StaticResourceSummary[]>;
+    getResourceTiles(resourceId: string): Promise<StaticTile[]>;
+}
+declare class ArchesClientRemoteStatic extends ArchesClient {
+    archesUrl: string;
+    allGraphFile: () => string;
+    graphToGraphFile?: (graph: StaticGraphMeta) => string;
+    graphIdToGraphFile: (graphId: string) => string;
+    graphIdToResourcesFiles: ((graphId: string) => string[]) | ((graphId: string) => Promise<string[]>) | ((graphId: string) => AsyncGenerator<string>);
+    resourceIdToFile: (resourceId: string) => string;
+    collectionIdToFile: (collectionId: string) => string;
+    constructor(archesUrl: string, { allGraphFile, graphToGraphFile, graphIdToResourcesFiles, resourceIdToFile, collectionIdToFile, graphIdToGraphFile, }?: {
+        allGraphFile?: () => string;
+        graphToGraphFile?: (graph: StaticGraphMeta) => string;
+        graphIdToGraphFile?: (graphId: string) => string;
+        graphIdToResourcesFiles?: ((graphId: string) => string[]) | ((graphId: string) => Promise<string[]>) | ((graphId: string) => AsyncGenerator<string>);
+        resourceIdToFile?: (resourceId: string) => string;
+        collectionIdToFile?: (collectionId: string) => string;
+    });
+    getGraphs(): Promise<GraphResult>;
+    getGraph(graph: StaticGraphMeta): Promise<StaticGraph | null>;
+    getGraphByIdOnly(graphId: string): Promise<StaticGraph | null>;
+    getResource(resourceId: string): Promise<StaticResource>;
+    getCollection(collectionId: string): Promise<StaticCollection>;
+    getResources(graphId: string, limit: number, _reloadIfSeen: boolean): Promise<StaticResource[]>;
+    getResourceSummaries(graphId: string, limit: number): Promise<StaticResourceSummary[]>;
+    getResourceTiles(resourceId: string): Promise<StaticTile[]>;
+}
+declare class ArchesClientLocal extends ArchesClient {
+    allGraphFile: () => string;
+    graphToGraphFile?: (graph: StaticGraphMeta) => string;
+    graphIdToGraphFile: (graphId: string) => string;
+    graphIdToResourcesFiles: ((graphId: string) => string[]) | ((graphId: string) => Promise<string[]>) | ((graphId: string) => AsyncGenerator<string>);
+    resourceIdToFile: (resourceId: string) => string;
+    collectionIdToFile: (collectionId: string) => string;
+    __loadedFileCache: {
+        [graphId: string]: string[];
+    };
+    private ensureFs;
+    constructor({ allGraphFile, graphToGraphFile, graphIdToResourcesFiles, resourceIdToFile, collectionIdToFile, graphIdToGraphFile, }?: {
+        allGraphFile?: () => string;
+        graphToGraphFile?: (graph: StaticGraphMeta) => string;
+        graphIdToGraphFile?: (graphId: string) => string;
+        graphIdToResourcesFiles?: ((graphId: string) => string[]) | ((graphId: string) => Promise<string[]>) | ((graphId: string) => AsyncGenerator<string>);
+        resourceIdToFile?: (resourceId: string) => string;
+        collectionIdToFile?: (collectionId: string) => string;
+    });
+    getGraphs(): Promise<GraphResult>;
+    getGraph(graph: StaticGraphMeta): Promise<StaticGraph | null>;
+    getGraphByIdOnly(graphId: string): Promise<StaticGraph | null>;
+    getResource(resourceId: string): Promise<StaticResource>;
+    getCollection(collectionId: string): Promise<StaticCollection>;
+    getResources(graphId: string, limit: number | null, reloadIfSeen: boolean): Promise<StaticResource[]>;
+    getResourceSummaries(graphId: string, limit: number): Promise<StaticResourceSummary[]>;
+    getResourceTiles(resourceId: string): Promise<StaticTile[]>;
+}
+declare const archesClient: ArchesClientRemote;
+export { archesClient, ArchesClient, ArchesClientRemoteStatic, ArchesClientRemote, ArchesClientLocal, GraphResult, };

package/dist/collectionMutator.d.ts

@@ -0,0 +1,155 @@
+import { StaticCollection, StaticConcept, SkosNodeType } from './static-types';
+/**
+ * Options for adding a concept to a collection
+ */
+export interface AddConceptOptions {
+    /** The label value (string) or multilingual labels */
+    label: string | {
+        [lang: string]: string;
+    };
+    /** Optional parent concept ID to add this as a child */
+    parentId?: string;
+    /** Optional source/identifier URI */
+    source?: string;
+    /** Optional sort order */
+    sortOrder?: number;
+    /** Optional explicit ID (otherwise generated from label) */
+    id?: string;
+    /** Optional URI for the concept */
+    uri?: string;
+}
+/**
+ * Result of adding a concept
+ */
+export interface AddConceptResult {
+    concept: StaticConcept;
+    id: string;
+}
+/**
+ * Mutator class for StaticCollection that provides methods for adding,
+ * modifying, and removing concepts including nested children.
+ */
+export declare class CollectionMutator {
+    private collection;
+    constructor(collection: StaticCollection);
+    /**
+     * Get the underlying collection
+     */
+    getCollection(): StaticCollection;
+    /**
+     * Create a new empty collection with a mutator.
+     *
+     * @param name - Collection name (string or multilingual object)
+     * @param options - Optional settings
+     * @param options.collectionId - Explicit ID (otherwise generated from name)
+     * @param options.nodeType - 'ConceptScheme' (default) or 'Collection' for Arches-compatible
+     * @param options.uri - Optional URI for the collection
+     *
+     * Both types support hierarchical concepts via narrower/broader relationships.
+     * The difference is how membership is expressed in RDF:
+     * - ConceptScheme: uses skos:inScheme on concepts
+     * - Collection: uses skos:member to list all concepts (including children)
+     *
+     * @example
+     * // Create a hierarchical ConceptScheme (default)
+     * const scheme = CollectionMutator.createEmpty("Categories");
+     * scheme.addConcept({ label: "Parent" });
+     * scheme.addChildConcept(parentId, { label: "Child" }); // narrower/broader
+     *
+     * @example
+     * // Create an Arches-compatible Collection with hierarchy
+     * const collection = CollectionMutator.createEmpty("My Collection", { nodeType: 'Collection' });
+     * const parent = collection.addConcept({ label: "Parent" });
+     * collection.addChildConcept(parent.id, { label: "Child" }); // narrower/broader, all listed as members
+     */
+    static createEmpty(name: string | {
+        [lang: string]: string;
+    }, options?: string | {
+        collectionId?: string;
+        nodeType?: SkosNodeType;
+        uri?: string;
+    }): CollectionMutator;
+    /**
+     * Create a new Arches-compatible Collection.
+     * Convenience method equivalent to createEmpty(name, { nodeType: 'Collection' })
+     * Collections can have hierarchical concepts (narrower/broader) but list all
+     * concepts (including children) as members via skos:member.
+     */
+    static createArchesCollection(name: string | {
+        [lang: string]: string;
+    }, options?: {
+        collectionId?: string;
+        uri?: string;
+    }): CollectionMutator;
+    /**
+     * Add a top-level concept to the collection.
+     * Use parentId to create hierarchy (narrower/broader relationships on concepts).
+     */
+    addConcept(options: AddConceptOptions): AddConceptResult;
+    /**
+     * Add a top-level member concept (alias for addConcept).
+     * Useful when working with Collections to make intent clear.
+     * Use addChildConcept() to create hierarchical concepts.
+     */
+    addMember(options: Omit<AddConceptOptions, 'parentId'>): AddConceptResult;
+    /**
+     * Add a child concept under an existing concept.
+     * For both ConceptScheme and Collection types, this creates a narrower/broader hierarchy
+     * on the concepts. Collections list all concepts (including children) as members.
+     */
+    addChildConcept(parentId: string, options: Omit<AddConceptOptions, 'parentId'>): AddConceptResult;
+    /**
+     * Add multiple concepts at once, supporting nested structure
+     * @param concepts Array of concepts with optional children
+     * @param parentId Optional parent ID to add all concepts under
+     */
+    addConcepts(concepts: Array<AddConceptOptions & {
+        children?: Array<AddConceptOptions & {
+            children?: any[];
+        }>;
+    }>, parentId?: string): AddConceptResult[];
+    /**
+     * Remove a concept by ID (and all its children)
+     */
+    removeConcept(conceptId: string): boolean;
+    /**
+     * Move a concept to a new parent (or to top level if parentId is null)
+     */
+    moveConcept(conceptId: string, newParentId: string | null): boolean;
+    /**
+     * Update a concept's properties
+     */
+    updateConcept(conceptId: string, updates: Partial<Omit<AddConceptOptions, 'id' | 'parentId'>>): boolean;
+    /**
+     * Get a concept by ID
+     */
+    getConcept(conceptId: string): StaticConcept | null;
+    /**
+     * Get all concept IDs in the collection (including nested)
+     */
+    getAllConceptIds(): string[];
+    /**
+     * Get the path from root to a concept (list of concept IDs)
+     */
+    getConceptPath(conceptId: string): string[] | null;
+    /**
+     * Create a concept object from options
+     */
+    private _createConcept;
+    /**
+     * Find a concept by ID in the entire tree
+     */
+    private _findConcept;
+    /**
+     * Index a concept and its children in __allConcepts and __values
+     */
+    private _indexConcept;
+    /**
+     * Remove a concept and its children from indexes
+     */
+    private _unindexConcept;
+    /**
+     * Remove a concept from a parent's children list
+     */
+    private _removeFromChildren;
+}

package/dist/csvModelLoader.d.ts

@@ -0,0 +1,59 @@
+/**
+ * CSV Model Loader
+ *
+ * Thin TypeScript wrapper over the WASM `buildGraphFromModelCsvs` and
+ * `validateModelCsvs` functions. Parses the 3-CSV format (graph.csv,
+ * nodes.csv, collections.csv) and builds an Arches resource model graph
+ * with SKOS collections.
+ *
+ * @module csvModelLoader
+ */
+export interface CsvModelDiagnostic {
+    level: 'Error' | 'Warning';
+    file: string;
+    line: number | null;
+    message: string;
+}
+export interface CsvModelBuildResult {
+    graph: any;
+    collections: any[];
+}
+/**
+ * Build a graph and collections from the 3-CSV model format.
+ *
+ * @param graphCsv - Contents of graph.csv
+ * @param nodesCsv - Contents of nodes.csv
+ * @param rdmNamespace - RDM namespace string (UUID or URL) for deterministic ID generation
+ * @param collectionsCsv - Contents of collections.csv (optional)
+ * @returns The built graph and collections
+ * @throws Error with diagnostics if validation or build fails
+ */
+export declare function buildGraphFromModelCsvs(graphCsv: string, nodesCsv: string, rdmNamespace: string, collectionsCsv?: string): CsvModelBuildResult;
+/**
+ * Validate 3-CSV model files without building.
+ *
+ * @param graphCsv - Contents of graph.csv
+ * @param nodesCsv - Contents of nodes.csv
+ * @param collectionsCsv - Contents of collections.csv (optional)
+ * @returns Array of diagnostics (errors and warnings)
+ */
+export declare function validateModelCsvs(graphCsv: string, nodesCsv: string, collectionsCsv?: string): CsvModelDiagnostic[];
+export interface BusinessDataResult {
+    business_data: {
+        resources: any[];
+    };
+}
+/**
+ * Build resource instances from a business data CSV.
+ *
+ * Columns are node aliases (not UUIDs). Concept values are labels
+ * resolved against the collections. ResourceIDs generate deterministic UUIDs.
+ *
+ * @param csvData - Business data CSV with ResourceID as first column
+ * @param graph - Built graph JSON (from buildGraphFromModelCsvs)
+ * @param collections - Built collections array (from buildGraphFromModelCsvs)
+ * @param defaultLanguage - Default language code (default "en")
+ * @param strictConcepts - Error on unresolved concept labels (default true)
+ * @returns Business data wrapper with resources array
+ */
+export declare function buildResourcesFromBusinessCsv(csvData: string, graph: any, collections: any[], defaultLanguage?: string, strictConcepts?: boolean): BusinessDataResult;

package/dist/full.d.ts

@@ -0,0 +1,3 @@
+export * from './main';
+import '../ext/js/@alizarin/filelist/src/main';
+import '../ext/js/@alizarin/clm/src/main';