node-opcua-uanodeset-rdf 2.182.0

package/README.md

@@ -0,0 +1,294 @@
+# node-opcua-uanodeset-rdf
+
+Export an OPC UA information model as **JSON-LD**, so it can be queried with SPARQL, reasoned
+over with an OWL toolchain, or joined to data that was never OPC UA in the first place.
+
+see http://node-opcua.github.io/
+
+```bash
+npm install node-opcua-uanodeset-rdf
+```
+
+## Why
+
+An address space is already a graph: nodes, typed edges, subtype chains. What it lacks is a way
+to ask graph questions of it. `HasComponent` is a traversal in an SDK, but a *predicate* in RDF,
+and once the model is in a triple store you can ask things the OPC UA services have no method
+for:
+
+> every DataType in this model with a field whose own DataType is not defined by any model I
+> imported
+
+> the transitive closure of `HasSubtype` under `DeviceType`, across DI and a vendor companion
+> specification loaded side by side
+
+> which nodes changed between two published versions of a companion specification
+
+That is the job. Get the model once, export it, and let a graph database answer.
+
+## What comes out
+
+```jsonc
+{
+  "@context":  { /* prefixes, property terms, and per-document predicates */ },
+  "@graph":    [ /* the ontology node, then one entry per node */ ],
+  "@included": [ /* OWL property declarations, and foreign attachments */ ]
+}
+```
+
+The first `@graph` entry describes the model itself, as both a `uardf:UANodeSet` and an
+`owl:Ontology`. Every entry after it is a node:
+
+```jsonc
+{
+  "@id": "di:DeviceType",
+  "@type": ["uardf:UAObjectType", "owl:Class"],
+  "nodeId": "nsu=http://opcfoundation.org/UA/DI/;i=1002",
+  "browseName": "nsu=http://opcfoundation.org/UA/DI/;DeviceType",
+  "name": "DeviceType",
+  "subClassOf": "di:ComponentType",
+  "di:ParameterSet": "di:bnN1PWh0dHA6..."
+}
+```
+
+Three ideas carry most of the mapping:
+
+- **Types get readable IRIs, instances get stable ones.** An ObjectType, VariableType,
+  ReferenceType or DataType is `<prefix>:<BrowseName>`; everything else is
+  `<prefix>:<base64url(canonical NodeId)>`, unpadded. So `di:DeviceType` is legible in a query
+  and an instance IRI survives a renaming.
+- **Three references become fields rather than edges.** `HasTypeDefinition` becomes part of
+  `@type` (a Property is `["uardf:UAVariable", "opcua:PropertyType"]`), `HasSubtype` becomes
+  `subClassOf`, and `HasModellingRule` becomes `modellingRule`. That is what makes the OWL
+  reasoning work: a subtype chain is a class hierarchy.
+- **`@included` carries the schema.** One `owl:ObjectProperty` declaration per reference type the
+  model defines, with its inverse and its `subPropertyOf`, so a reasoner knows what the
+  predicates mean.
+
+The legacy OPC Binary machinery is dropped: every node whose TypeDefinition is
+`DataTypeDictionaryType` or `DataTypeDescriptionType`, and everything they own. The structure
+DataTypes are kept, with their `DataTypeDefinition`. On the DI nodeset that is 14 nodes of 447.
+
+[`VOCABULARY.md`](./VOCABULARY.md) is the full account: prefixes, IRI minting, the ontology node,
+type composition, the reference rules, the three kinds of `@included` entry.
+
+## Which entry point
+
+That document can be produced two ways, and each has an entry point of its own so that neither
+drags in what only the other needs.
+
+| | [`/address-space`](#node-opcua-uanodeset-rdfaddress-space) | [`/session`](#node-opcua-uanodeset-rdfsession) |
+|---|---|---|
+| you have | the NodeSet2 document | an `OPCUAClient` or a `PseudoSession` |
+| covers | every node of the namespace | every node reachable by browsing |
+| `symbolicName` | yes | no |
+| `owl:imports` | yes | no |
+
+Prefer `/address-space` when you have the document. Reach for `/session` when you do not, which
+for a vendor's own companion specification is often the only option there is.
+
+The root module re-exports both, for callers that want both.
+
+---
+
+# `node-opcua-uanodeset-rdf/address-space`
+
+The complete source. An address space retains the NodeSet2 metadata that OPC UA has no attribute
+for, so an export taken this way is the reference the other is judged against.
+
+```ts
+import { writeFile } from "node:fs/promises";
+import { AddressSpace } from "node-opcua-address-space";
+import { generateAddressSpace } from "node-opcua-address-space/nodeJS";
+import { nodesets } from "node-opcua-nodesets";
+import { addressSpaceToJsonLdText } from "node-opcua-uanodeset-rdf/address-space";
+
+const addressSpace = AddressSpace.create();
+await generateAddressSpace(addressSpace, [nodesets.standard, nodesets.di]);
+
+// with no modelUri, the last namespace loaded is the one exported
+await writeFile("Opc.Ua.Di.jsonld", addressSpaceToJsonLdText(addressSpace), "utf8");
+
+addressSpace.dispose();
+```
+
+A whole address space is needed rather than the one namespace, and that is not an implementation
+detail: a type's IRI is its BrowseName, including for types belonging to the models this one
+merely imports, so the exporter has to resolve NodeIds it never read.
+
+Two fields of the ontology node are written in the source document's `Models` element and are not
+retained by the loader. Supply them if you want them in the output:
+
+```ts
+import { addressSpaceToJsonLd } from "node-opcua-uanodeset-rdf/address-space";
+
+const doc = addressSpaceToJsonLd(addressSpace, {
+    modelUri: "http://opcfoundation.org/UA/DI/",
+    model: { modelVersion: "1.5.0", xmlSchemaUri: "http://opcfoundation.org/UA/DI/Types.xsd" }
+});
+```
+
+| export | what it is |
+|---|---|
+| `addressSpaceToJsonLdText(addressSpace, options?)` | one namespace as a JSON-LD document, serialised |
+| `addressSpaceToJsonLd(addressSpace, options?)` | the same as a plain object, to hand to a JSON-LD library |
+| `addressSpaceToRdfModel(addressSpace, modelUri?)` | the collected model, to inspect or amend before mapping it |
+
+---
+
+# `node-opcua-uanodeset-rdf/session`
+
+Nothing reachable from this entry point mentions `node-opcua-address-space`, at the type level or
+the runtime one, so a client application uses it without loading the address-space machinery it
+has no other use for.
+
+## With an `OPCUAClient`
+
+This is the case a nodeset file cannot serve: a device implementing a companion specification you
+do not have, exported straight into a triple store.
+
+```ts
+import { writeFile } from "node:fs/promises";
+import { OPCUAClient } from "node-opcua-client";
+import { sessionToJsonLdText } from "node-opcua-uanodeset-rdf/session";
+
+await OPCUAClient.create({ endpointMustExist: false }).withSessionAsync(
+    "opc.tcp://localhost:26543",
+    async (session) => {
+        const jsonld = await sessionToJsonLdText(session, {
+            modelUri: "http://acme.com/UA/Widget/"
+        });
+        await writeFile("Widget.jsonld", jsonld, "utf8");
+    }
+);
+```
+
+## With a `PseudoSession`
+
+`PseudoSession` puts the session interface in front of an address space you already hold. No
+server, no socket, no endpoint.
+
+```ts
+import { AddressSpace, PseudoSession } from "node-opcua-address-space";
+import { generateAddressSpace } from "node-opcua-address-space/nodeJS";
+import { nodesets } from "node-opcua-nodesets";
+import { sessionToJsonLdText } from "node-opcua-uanodeset-rdf/session";
+
+const addressSpace = AddressSpace.create();
+await generateAddressSpace(addressSpace, [nodesets.standard, nodesets.di]);
+
+const jsonld = await sessionToJsonLdText(new PseudoSession(addressSpace), {
+    modelUri: "http://opcfoundation.org/UA/DI/"
+});
+
+addressSpace.dispose();
+```
+
+It is also how this entry point is tested. Both paths then see the same model, so every
+difference between the two documents is something OPC UA cannot say about a node rather than
+something the collector got wrong.
+
+## What a session has to provide
+
+`RdfSession` is not a session type. It is the three services collecting a model actually calls:
+
+```ts
+type RdfSession = IBasicSessionBrowseAsyncMultiple &
+    IBasicSessionBrowseNextAsyncMultiple &
+    IBasicSessionReadAsyncMultiple;
+```
+
+Browse, follow the continuation point a browse hands back, read attributes. `create`, `close`,
+subscriptions and the rest of a session's surface are deliberately outside it, so a caller may
+pass something much smaller than a session.
+
+Browse is chunked by the server's own `MaxNodesPerBrowse` and `MaxBrowseContinuationPoints`,
+which `browseAll` reads for itself. Attribute reads use a fixed modest batch: honouring a
+server's `MaxNodesPerRead` belongs in a client that specialises in it, not in an exporter.
+
+## What a session cannot tell you
+
+Three differences from the address-space export, all structural rather than unfinished work, each
+measured by exporting one DI address space both ways.
+
+- **No service lists the nodes of a namespace.** Browse walks references; nothing enumerates. So
+  the model is whatever a crawl from Root reaches, and a node nothing points at is invisible. On
+  DI that is exactly nine: the well-known function-group Objects `Configuration`, `Tuning`,
+  `Maintenance`, `Diagnostics`, `Statistics`, `Status`, `Operational`, `OperationCounters` and
+  `Identification`, which carry no inverse reference of any type.
+- **`SymbolicName` is not an attribute.** It is NodeSet2 metadata, so `uardf:symbolicName` is
+  absent from every entry.
+- **`NamespaceMetadataType` states no required models.** It carries `NamespaceUri`,
+  `NamespaceVersion` and `NamespacePublicationDate` and no list of imports, so the ontology node
+  has `version` and `publicationDate` but no `requiredModels` and no `owl:imports`.
+
+Everything else agrees, node for node and predicate for predicate: the same `@id`, `@type`,
+`dataType`, `value` and children, the same `@context` terms, the same `@included` entries.
+
+| export | what it is |
+|---|---|
+| `sessionToJsonLdText(session, options?)` | one namespace as a JSON-LD document, serialised |
+| `sessionToJsonLd(session, options?)` | the same as a plain object |
+| `sessionToRdfModel(session, modelUri?)` | the collected model, to inspect or amend before mapping it |
+| `RdfSession` | the intersection above |
+
+---
+
+## Shared API
+
+Both entry points also export:
+
+| export | what it is |
+|---|---|
+| `JsonLdOptions` | `{ modelUri?, model?: { xmlSchemaUri?, modelVersion? } }` |
+| `modelToJsonLd(model, options?)` | the mapping itself, for a model collected some third way |
+| `RdfModel`, `RdfNode`, `RdfReference`, `RdfTarget` | the collected model's types |
+| `UARDF` | `http://opcfoundation.org/rdf/uacore#`, the vocabulary namespace |
+| `OPCUA_NAMESPACE` | `http://opcfoundation.org/UA/` |
+| `prefixOfNamespace(uri)` | the prefix a namespace URI gets: its last non-empty path segment, lowercased |
+
+Collecting a model and mapping it are separate on purpose. `modelToJsonLd` is synchronous and
+reads nothing but an `RdfModel`, which is why the session collector could be added without
+touching a line of the vocabulary, and why a third source would need no more than a function
+returning an `RdfModel`.
+
+## Status
+
+**This is an export, not a serialisation format.** There is no reader, and it never registers
+with the address-space loader. To read or write a JSON nodeset you want
+[`node-opcua-uanodeset-json`](../node-opcua-uanodeset-json), which implements the normative
+Annex I formats. The two answer different questions: Annex I is how a model is exchanged, this is
+how a model is queried.
+
+**The vocabulary is not in the specification.** OPC 10000-6 Annex I runs I.1 to I.24 and has no
+RDF section. This vocabulary belongs to the OPC Foundation's `UA-NodeSetTool`, whose own
+`rdf_prototype.md` no longer describes what it emits, so its output *is* the specification and
+`VOCABULARY.md` is a reverse-engineered account of it.
+
+**Parity** with that tool, measured on `Opc.Ua.Di.NodeSet2`:
+
+| | reference tool | this package |
+|---|---|---|
+| `@graph` entries | 434 | **434** |
+| `@included` entries | 172 | 173 |
+| `@context` terms | 239 | 220 |
+| entries byte-identical | n/a | 66 of 434 |
+
+Graph membership matches exactly, so a query over either document sees the same nodes. It is not
+yet byte-identical, and with no reader there is no round trip, no fixpoint and no digest
+equivalence to lean on: a diff against the reference implementation is the only oracle. The gap
+is one undocumented rule, whether a child is written under a BrowseName-derived predicate or
+under the generic reference type. Three hypotheses were tested and all three failed, so the
+question is recorded in `VOCABULARY.md` rather than answered with a rule that merely fits one
+nodeset.
+
+## On the name
+
+`node-opcua-nodeset-*` is a reserved prefix. The nodeset code generator sweeps every folder
+matching it and rewrites `packages/tsconfig.json` from what it finds, so a hand-written package
+sitting there breaks `generate:nodesets`. Hence `uanodeset`, matching
+`node-opcua-uanodeset-json`.
+
+## License
+
+MIT

package/VOCABULARY.md

@@ -0,0 +1,186 @@
+# The OPC UA JSON-LD vocabulary
+
+This is a **reverse-engineered** description of the JSON-LD an OPC UA information model is
+exported as by `OPCF-Members/UA-NodeSetTool`. It is written down here because no accurate
+description existed: the tool's own `rdf_prototype.md` describes an earlier shape, and the
+differences are not small.
+
+Nothing here is normative. **OPC 10000-6 Annex I has no RDF section** — the annex runs I.1 to
+I.24 and stops at `DataTypeField`. This vocabulary is the reference implementation's own.
+
+Everything below was established by generating output for real nodesets and reading it. Where a
+rule could not be established, it says so rather than guessing.
+
+---
+
+## Document shape
+
+```jsonc
+{
+  "@context":  { /* prefixes, property terms, and per-document predicates */ },
+  "@graph":    [ /* the ontology node, then one entry per node */ ],
+  "@included": [ /* OWL property declarations, and foreign attachments */ ]
+}
+```
+
+There is no root `@id` and no root `@type`. (`rdf_prototype.md` describes both, plus `modelUri`,
+`version` and `requiredModels` at the root, and nodes flagged `isNormative` / `isExternal`. None
+of that is emitted.)
+
+## Prefixes
+
+| prefix | expands to |
+|---|---|
+| `opcua` | `http://opcfoundation.org/UA/` |
+| `uardf` | `http://opcfoundation.org/rdf/uacore#` |
+| `owl` | `http://www.w3.org/2002/07/owl#` |
+| `rdfs` | `http://www.w3.org/2000/01/rdf-schema#` |
+| `xsd` | `http://www.w3.org/2001/XMLSchema#` |
+| *model* | the exported model's namespace URI |
+
+The model's prefix is its namespace URI's **last non-empty path segment, lowercased** —
+`http://opcfoundation.org/UA/DI/` becomes `di`.
+
+Note the vocabulary prefix is `uardf`, **not** `opcua` as `rdf_prototype.md` states. Only the
+reference types and BrowseName-derived predicates live under `opcua:`.
+
+## Node identity
+
+| node kind | IRI |
+|---|---|
+| ObjectType, VariableType, ReferenceType, DataType | `<prefix>:<BrowseName>` |
+| everything else | `<prefix>:<base64url(canonical NodeId)>` |
+
+The canonical NodeId is the Annex I form (`i=85`, or `nsu=<uri>;i=85`), base64url encoded
+**without padding**. So `nsu=http://opcfoundation.org/UA/DI/;i=6450` becomes
+`di:bnN1PWh0dHA6Ly9vcGNmb3VuZGF0aW9uLm9yZy9VQS9ESS87aT02NDUw`.
+
+## The ontology node
+
+The first entry of `@graph` describes the model itself:
+
+```jsonc
+{
+  "@id": "http://opcfoundation.org/UA/DI/",
+  "@type": ["uardf:UANodeSet", "owl:Ontology"],
+  "modelUri": "...", "xmlSchemaUri": "...",
+  "version": "1.05.0", "modelVersion": "1.5.0",
+  "owl:versionInfo": "1.5.0",
+  "owl:versionIRI": { "@id": "<modelUri><modelVersion>" },
+  "publicationDate": "2025-11-15T00:00:00Z",
+  "requiredModels": [ { "modelUri": "...", "version": "...", "publicationDate": "..." } ],
+  "owl:imports": [ { "@id": "http://opcfoundation.org/UA/" } ]
+}
+```
+
+`xmlSchemaUri` and `modelVersion` are written in the source document's `Models` element and are
+**not retained by node-opcua's address space**, so this package takes them through
+`JsonLdOptions.model` rather than inventing them.
+
+## Node entries
+
+Every node carries `@id`, `@type`, `nodeId`, `namespaceUri`, `browseName` and `name`.
+`browseName` is the Annex I QualifiedName form (bare in namespace 0, `nsu=<uri>;<name>`
+otherwise); `name` is the bare BrowseName.
+
+`@type` is `uardf:UAObject`, `uardf:UAVariable`, `uardf:UAMethod`, `uardf:UAObjectType`,
+`uardf:UAVariableType`, `uardf:UAReferenceType`, `uardf:UADataType` or `uardf:UAView`, plus:
+
+- `owl:Class` for the four type NodeClasses;
+- the **TypeDefinition's IRI** for instances, so a Property is `["uardf:UAVariable",
+  "opcua:PropertyType"]`.
+
+Other fields: `subClassOf` (from the inverse `HasSubtype`), `parent`, `symbolicName`,
+`description` as a language map (`{"@none": "..."}` when no locale), `dataType`, `valueRank`
+(omitted when scalar), `arrayDimensions`, `definition`, and `value` as a raw Part 6 1.05 JSON
+Variant carried as a `@json` literal.
+
+## References
+
+`HasTypeDefinition`, `HasModellingRule` and `HasSubtype` are never written as references:
+the first two become `@type` and `modellingRule`, the third becomes `subClassOf`.
+
+Everything else is written one of two ways:
+
+- **as a predicate named after the child's BrowseName** — `di:ParameterSet`, `opcua:EnumStrings`;
+- **as a predicate named after the reference type** — `opcua:HasComponent`, whose value is an
+  array when several children share it.
+
+**The rule choosing between the two is not established.** Observed on the DI nodeset:
+`IdleToPreparing` and `ParameterSet` get BrowseName predicates; `Idle`, `Error`, `Installing`
+and `Abort` do not, and appear under `opcua:HasComponent` instead. It is not name uniqueness
+(`PercentComplete` occurs twice and *does* get one; `Error` occurs once and does not), and it is
+not the NodeClass or the reference type (States and Transitions are both Objects reached by
+`HasComponent`, and they differ). **This is the open question to put to the maintainer.**
+
+A BrowseName that names a placeholder (`<ParameterIdentifier>`) never becomes a predicate.
+
+## `@included`
+
+Three kinds of entry:
+
+1. **ReferenceType declarations**, one per reference type the model defines:
+   `{"@id", "@type": "owl:ObjectProperty", "label", "symmetric", "inverseOf", "inverseName",
+   "subPropertyOf"}`. A symmetric type is its own inverse.
+2. **Predicate declarations**, one per BrowseName-derived predicate, minimal:
+   `{"@id", "@type": "owl:ObjectProperty", "subPropertyOf": "<the reference type reaching it>"}`.
+3. **Foreign attachments**: a node in *another* model that this model hangs children on, written
+   as `{"@id": "<that node>", "<predicate>": "<child>"}` with no `@type`. It cannot go in
+   `@graph`, because the document does not define that node.
+
+## What is dropped
+
+The legacy OPC Binary machinery: every node whose TypeDefinition is `DataTypeDictionaryType`
+(`i=72`) or `DataTypeDescriptionType` (`i=69`), **and everything those nodes own**. The structure
+DataTypes themselves are kept, with their `DataTypeDefinition`; only the encoding dictionaries and
+description blobs go. On the DI nodeset that is 14 nodes of 448.
+
+---
+
+## Parity status of this implementation
+
+Measured against the reference implementation for `Opc.Ua.Di.NodeSet2`:
+
+| | reference | this package |
+|---|---|---|
+| `@graph` entries | 434 | **434** |
+| `@included` entries | 172 | 173 |
+| `@context` terms | 239 | 220 |
+| entries byte-identical | — | 66 of 434 |
+
+`@graph` membership matches exactly. The remaining differences are concentrated in which
+predicate a child is written under (the open question above) and in the reference-type aliases
+that `@context` needs so the `subPropertyOf` values in `@included` resolve.
+
+**This exporter is not yet a drop-in replacement**, and the numbers above are the honest state of
+it rather than an aspiration.
+
+---
+
+## What a session cannot tell you
+
+The same document can be produced from a live session
+(`node-opcua-uanodeset-rdf/session`) rather than a loaded address space. That is the only way to
+export a server whose nodeset file you do not have, and it is not the equal of the address-space
+path. Three differences are structural, not defects waiting to be fixed, and each was measured on
+DI by exporting the same address space both ways.
+
+**1. There is no service that lists the nodes of a namespace.** Browse walks references; nothing
+enumerates. So a session-sourced model is whatever a crawl from Root reaches, and a node nothing
+points at is invisible. On DI that is nine nodes: the well-known function-group Objects
+`Configuration`, `Tuning`, `Maintenance`, `Diagnostics`, `Statistics`, `Status`, `Operational`,
+`OperationCounters` and `Identification`. They carry no inverse reference of any type, so no crawl
+from any root reaches them. Every other node of the namespace is reached, and each is written with
+the same `@id`, `@type`, `dataType`, `value` and predicates as the address-space export gives it.
+
+**2. `SymbolicName` is not an attribute.** It is NodeSet2 metadata, so `uardf:symbolicName` is
+absent from every entry of a session-sourced document.
+
+**3. `NamespaceMetadataType` states no required models.** It carries `NamespaceUri`,
+`NamespaceVersion` and `NamespacePublicationDate`, and no list of imports. So the ontology node of
+a session-sourced document has `version` and `publicationDate` but no `requiredModels` and no
+`owl:imports`, which is what a reasoner uses to pull the imported models in. A caller that knows
+the imports can still supply `xmlSchemaUri` and `modelVersion` through `JsonLdOptions.model`.
+
+Everything else agrees: the `@context` terms, the `@included` entries, the drop rule for the
+legacy OPC Binary machinery, and every predicate on every node reached.

package/dist/address_space.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The address-space entry point: `node-opcua-uanodeset-rdf/address-space`.
+ *
+ * This is the complete source and the one to prefer where the model has been loaded from its
+ * NodeSet2 document: an address space retains the metadata OPC UA has no attribute for, so an
+ * export taken this way is the reference a session-sourced one is judged against.
+ */
+import type { IAddressSpace } from "node-opcua-address-space";
+import { type JsonLdOptions } from "./to_jsonld.js";
+export { addressSpaceToRdfModel } from "./from_address_space.js";
+export type { RdfModel, RdfModelReference, RdfNode, RdfReference, RdfTarget } from "./model.js";
+export { type JsonLdOptions, modelToJsonLd, OPCUA_NAMESPACE, prefixOfNamespace, UARDF } from "./to_jsonld.js";
+/** a namespace of an address space as a JSON-LD document */
+export declare function addressSpaceToJsonLd(addressSpace: IAddressSpace, options?: JsonLdOptions): Record<string, unknown>;
+/** a namespace of an address space as a JSON-LD document, serialised */
+export declare function addressSpaceToJsonLdText(addressSpace: IAddressSpace, options?: JsonLdOptions): string;

package/dist/address_space.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * The address-space entry point: `node-opcua-uanodeset-rdf/address-space`.
+ *
+ * This is the complete source and the one to prefer where the model has been loaded from its
+ * NodeSet2 document: an address space retains the metadata OPC UA has no attribute for, so an
+ * export taken this way is the reference a session-sourced one is judged against.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UARDF = exports.prefixOfNamespace = exports.OPCUA_NAMESPACE = exports.modelToJsonLd = exports.addressSpaceToRdfModel = void 0;
+exports.addressSpaceToJsonLd = addressSpaceToJsonLd;
+exports.addressSpaceToJsonLdText = addressSpaceToJsonLdText;
+const from_address_space_js_1 = require("./from_address_space.js");
+const to_jsonld_js_1 = require("./to_jsonld.js");
+var from_address_space_js_2 = require("./from_address_space.js");
+Object.defineProperty(exports, "addressSpaceToRdfModel", { enumerable: true, get: function () { return from_address_space_js_2.addressSpaceToRdfModel; } });
+var to_jsonld_js_2 = require("./to_jsonld.js");
+Object.defineProperty(exports, "modelToJsonLd", { enumerable: true, get: function () { return to_jsonld_js_2.modelToJsonLd; } });
+Object.defineProperty(exports, "OPCUA_NAMESPACE", { enumerable: true, get: function () { return to_jsonld_js_2.OPCUA_NAMESPACE; } });
+Object.defineProperty(exports, "prefixOfNamespace", { enumerable: true, get: function () { return to_jsonld_js_2.prefixOfNamespace; } });
+Object.defineProperty(exports, "UARDF", { enumerable: true, get: function () { return to_jsonld_js_2.UARDF; } });
+/** a namespace of an address space as a JSON-LD document */
+function addressSpaceToJsonLd(addressSpace, options = {}) {
+    return (0, to_jsonld_js_1.modelToJsonLd)((0, from_address_space_js_1.addressSpaceToRdfModel)(addressSpace, options.modelUri), options);
+}
+/** a namespace of an address space as a JSON-LD document, serialised */
+function addressSpaceToJsonLdText(addressSpace, options = {}) {
+    return `${JSON.stringify(addressSpaceToJsonLd(addressSpace, options), null, 2)}\n`;
+}
+//# sourceMappingURL=address_space.js.map

package/dist/address_space.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"address_space.js","sourceRoot":"","sources":["../source/address_space.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;AAWH,oDAEC;AAGD,4DAEC;AAfD,mEAAiE;AACjE,iDAAmE;AAEnE,iEAAiE;AAAxD,+HAAA,sBAAsB,OAAA;AAE/B,+CAA8G;AAAjF,6GAAA,aAAa,OAAA;AAAE,+GAAA,eAAe,OAAA;AAAE,iHAAA,iBAAiB,OAAA;AAAE,qGAAA,KAAK,OAAA;AAErF,4DAA4D;AAC5D,SAAgB,oBAAoB,CAAC,YAA2B,EAAE,UAAyB,EAAE;IACzF,OAAO,IAAA,4BAAa,EAAC,IAAA,8CAAsB,EAAC,YAAY,EAAE,OAAO,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,CAAC;AAC1F,CAAC;AAED,wEAAwE;AACxE,SAAgB,wBAAwB,CAAC,YAA2B,EAAE,UAAyB,EAAE;IAC7F,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,oBAAoB,CAAC,YAAY,EAAE,OAAO,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC;AACvF,CAAC"}

package/dist/from_address_space.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Collecting an `RdfModel` from a loaded address space.
+ *
+ * This is the complete source: an address space retains the NodeSet2 metadata that OPC UA has no
+ * attribute for, so an export taken this way is the reference against which a session-sourced one
+ * is judged.
+ *
+ * Foreign nodes are converted lazily. The mapper names supertypes, reference types and type
+ * definitions belonging to models this one only imports, and there is no point walking all of
+ * `Opc.Ua` to find the handful it actually asks for.
+ */
+import type { IAddressSpace } from "node-opcua-address-space";
+import type { RdfModel } from "./model.js";
+/** the model a namespace of an address space describes */
+export declare function addressSpaceToRdfModel(addressSpace: IAddressSpace, modelUri?: string): RdfModel;

package/dist/from_address_space.js

@@ -0,0 +1,110 @@
+"use strict";
+/**
+ * Collecting an `RdfModel` from a loaded address space.
+ *
+ * This is the complete source: an address space retains the NodeSet2 metadata that OPC UA has no
+ * attribute for, so an export taken this way is the reference against which a session-sourced one
+ * is judged.
+ *
+ * Foreign nodes are converted lazily. The mapper names supertypes, reference types and type
+ * definitions belonging to models this one only imports, and there is no point walking all of
+ * `Opc.Ua` to find the handful it actually asks for.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addressSpaceToRdfModel = addressSpaceToRdfModel;
+const node_opcua_data_model_1 = require("node-opcua-data-model");
+/**
+ * one node.
+ *
+ * `full` is false for a node the exporter only has to name. Skipping the value read there is not
+ * an optimisation for its own sake: reading a value can be expensive, or fail, on a node this
+ * document never describes.
+ */
+function toRdfNode(node, full) {
+    const out = {
+        nodeId: node.nodeId,
+        nodeClass: node.nodeClass,
+        browseName: node.browseName,
+        references: node.allReferences().map((reference) => ({
+            referenceTypeId: reference.referenceType,
+            isForward: reference.isForward,
+            targetId: reference.nodeId
+        }))
+    };
+    const typeDefinition = node.typeDefinitionObj?.nodeId;
+    if (typeDefinition)
+        out.typeDefinition = typeDefinition;
+    const supertype = node.subtypeOfObj?.nodeId;
+    if (supertype)
+        out.subtypeOf = supertype;
+    if (node.description?.text)
+        out.description = node.description;
+    if (node.nodeClass === node_opcua_data_model_1.NodeClass.ReferenceType) {
+        const referenceType = node;
+        out.symmetric = !!referenceType.symmetric;
+        if (referenceType.inverseName)
+            out.inverseName = referenceType.inverseName;
+    }
+    if (!full)
+        return out;
+    const symbolicName = node.symbolicName;
+    if (symbolicName)
+        out.symbolicName = symbolicName;
+    if (node.nodeClass === node_opcua_data_model_1.NodeClass.Variable || node.nodeClass === node_opcua_data_model_1.NodeClass.VariableType) {
+        const variable = node;
+        if (variable.dataType)
+            out.dataType = variable.dataType;
+        if (variable.valueRank !== undefined)
+            out.valueRank = variable.valueRank;
+        if (variable.arrayDimensions)
+            out.arrayDimensions = variable.arrayDimensions;
+        try {
+            const dataValue = variable.readValue();
+            if (dataValue?.value)
+                out.value = dataValue.value;
+        }
+        catch {
+            // a value that cannot be read contributes none, which is not an error for an export
+        }
+    }
+    return out;
+}
+/** the model a namespace of an address space describes */
+function addressSpaceToRdfModel(addressSpace, modelUri) {
+    const namespaces = addressSpace.getNamespaceArray();
+    const target = modelUri ? namespaces.find((n) => n.namespaceUri === modelUri) : namespaces[namespaces.length - 1];
+    if (!target) {
+        throw new Error(`the address space holds no namespace ${modelUri}`);
+    }
+    const cache = new Map();
+    const nodes = [];
+    for (const node of namespaces[target.index].nodeIterator()) {
+        const converted = toRdfNode(node, true);
+        cache.set(node.nodeId.toString(), converted);
+        nodes.push(converted);
+    }
+    return {
+        namespaceUris: namespaces.map((n) => n.namespaceUri),
+        target: {
+            index: target.index,
+            namespaceUri: target.namespaceUri,
+            version: target.version,
+            publicationDate: target.publicationDate,
+            requiredModels: target.getRequiredModels?.()
+        },
+        nodes,
+        resolve(nodeId) {
+            const key = nodeId.toString();
+            const known = cache.get(key);
+            if (known)
+                return known;
+            const found = addressSpace.findNode(nodeId);
+            if (!found)
+                return undefined;
+            const converted = toRdfNode(found, false);
+            cache.set(key, converted);
+            return converted;
+        }
+    };
+}
+//# sourceMappingURL=from_address_space.js.map

package/dist/from_address_space.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"from_address_space.js","sourceRoot":"","sources":["../source/from_address_space.ts"],"names":[],"mappings":"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"}