@ulb-darmstadt/shacl-form 1.7.3 → 1.8.0

package/src/node-template.ts

@@ -0,0 +1,82 @@
+import { BlankNode, NamedNode, Quad } from "n3"
+import { Config } from "./config"
+import { OWL_PREDICATE_IMPORTS, PREFIX_SHACL } from "./constants";
+import { Term } from "@rdfjs/types";
+
+const mappers: Record<string, (template: ShaclNodeTemplate, term: Term) => void> = {
+    [`${PREFIX_SHACL}property`]:     (template, term) => { template.properties.push(term as (BlankNode | NamedNode)) },
+    [`${PREFIX_SHACL}and`]:          (template, term) => { template.shaclAnd = term.value },
+    [`${PREFIX_SHACL}node`]:         (template, term) => { template.node = term as NamedNode },
+    [`${PREFIX_SHACL}targetClass`]:  (template, term) => { template.targetClass = term as NamedNode },
+    [`${PREFIX_SHACL}or`]:           (template, term) => {
+        const list = template.config.lists[term.value]
+        if (list?.length) {
+            template.shaclOr = list
+        } else {
+            console.error('list for sh:or not found:', term.value, 'existing lists:', template.config.lists)
+        }
+    },
+    [`${PREFIX_SHACL}xone`]:         (template, term) => {
+        const list = template.config.lists[term.value]
+        if (list?.length) {
+            template.shaclXone = list
+        } else {
+            console.error('list for sh:xone not found:', term.value, 'existing lists:', template.config.lists)
+        }
+    },
+    [OWL_PREDICATE_IMPORTS.id]:      (template, term) => { template.owlImports.push(term as NamedNode) }
+}
+
+export class ShaclNodeTemplate {
+    properties: (NamedNode | BlankNode)[] = []
+    node: NamedNode | undefined
+    shaclAnd: string | undefined    
+    shaclOr: Term[] | undefined
+    shaclXone: Term[] | undefined
+    targetClass: NamedNode | undefined
+
+    owlImports: NamedNode[] = []
+    config: Config
+    extendedShapes: NamedNode[] = []
+
+    constructor(quads: Quad[], config: Config) {
+        this.config = config
+        this.merge(quads)
+    }
+
+    merge(quads: Quad[]): ShaclNodeTemplate {
+        for (const quad of quads) {
+            mappers[quad.predicate.id]?.call(this, this, quad.object)
+        }
+        // resolve extended shapes
+        if (this.node || this.shaclAnd) {
+            if (this.node) {
+                this.extendedShapes.push(this.node)
+            }
+            if (this.shaclAnd) {
+                const list = this.config.lists[this.shaclAnd]
+                if (list?.length) {
+                    for (const node of list) {
+                        this.extendedShapes.push(node as NamedNode)
+                    }
+                }
+            }
+        }
+        return this
+    }
+
+    clone(): ShaclNodeTemplate {
+        const copy = Object.assign({}, this)
+        // arrays are not cloned but referenced, so create them manually
+        copy.owlImports = [ ...this.owlImports ]
+        if (this.shaclOr) {
+            copy.shaclOr = [ ...this.shaclOr ]
+        }
+        if (this.shaclXone) {
+            copy.shaclXone = [ ...this.shaclXone ]
+        }
+        copy.merge = this.merge.bind(copy)
+        copy.clone = this.clone.bind(copy)
+        return copy
+    }
+}

package/src/node.ts

@@ -1,10 +1,10 @@
 import { BlankNode, DataFactory, NamedNode, Store } from 'n3'
 import { Term } from '@rdfjs/types'
-import { PREFIX_SHACL, RDF_PREDICATE_TYPE, OWL_PREDICATE_IMPORTS } from './constants'
+import { PREFIX_SHACL, RDF_PREDICATE_TYPE, OWL_PREDICATE_IMPORTS, SHACL_PREDICATE_PROPERTY } from './constants'
 import { ShaclProperty } from './property'
 import { createShaclGroup } from './group'
 import { v4 as uuidv4 } from 'uuid'
-import { createShaclOrConstraint } from './constraints'
+import { createShaclOrConstraint, resolveShaclOrConstraintOnNode } from './constraints'
 import { Config } from './config'
 
 export class ShaclNode extends HTMLElement {
@@ -14,24 +14,26 @@ export class ShaclNode extends HTMLElement {
     targetClass: NamedNode | undefined
     owlImports: NamedNode[] = []
     config: Config
+    linked: boolean
 
-    constructor(shaclSubject: NamedNode, config: Config, valueSubject: NamedNode | BlankNode | undefined, parent?: ShaclNode, nodeKind?: NamedNode, label?: string) {
+    constructor(shaclSubject: NamedNode, config: Config, valueSubject: NamedNode | BlankNode | undefined, parent?: ShaclNode, nodeKind?: NamedNode, label?: string, linked?: boolean) {
         super()
 
         this.parent = parent
         this.config = config
         this.shaclSubject = shaclSubject
+        this.linked = linked || false
         let nodeId: NamedNode | BlankNode | undefined = valueSubject
         if (!nodeId) {
             // if no value subject given, create new node id with a type depending on own nodeKind or given parent property nodeKind
             if (!nodeKind) {
-                const spec = config.shapesGraph.getObjects(shaclSubject, `${PREFIX_SHACL}nodeKind`, null)
+                const spec = config.store.getObjects(shaclSubject, `${PREFIX_SHACL}nodeKind`, null)
                 if (spec.length) {
                     nodeKind = spec[0] as NamedNode
                 }
             }
             // if nodeKind is not set, but a value namespace is configured or if nodeKind is sh:IRI, then create a NamedNode
-            if ((nodeKind === undefined && config.attributes.valuesNamespace) || nodeKind?.id === `${PREFIX_SHACL}IRI`) {
+            if ((nodeKind === undefined && config.attributes.valuesNamespace) || nodeKind?.value === `${PREFIX_SHACL}IRI`) {
                 // no requirements on node type, so create a NamedNode and use configured value namespace
                 nodeId = DataFactory.namedNode(config.attributes.valuesNamespace + uuidv4())
             } else {
@@ -45,17 +47,19 @@ export class ShaclNode extends HTMLElement {
         const id = JSON.stringify([shaclSubject, valueSubject])
         if (valueSubject && config.renderedNodes.has(id)) {
             // node/value pair is already rendered in the form, so just display a reference
-            if (label && config.attributes.collapse === null) {
-                const labelElem = document.createElement('label')
-                labelElem.innerText = label
-                this.appendChild(labelElem)
-            }
+            label = label || "Link"
+            const labelElem = document.createElement('label')
+            labelElem.innerText = label
+            labelElem.classList.add('linked')
+            this.appendChild(labelElem)
+
             const anchor = document.createElement('a')
-            anchor.innerText = valueSubject.id
+            let refId = (valueSubject.termType === 'BlankNode') ? '_:' + valueSubject.value : valueSubject.value
+            anchor.innerText = refId
             anchor.classList.add('ref-link')
             anchor.onclick = () => {
                 // if anchor is clicked, scroll referenced shacl node into view
-                this.config.form.querySelector(`shacl-node[data-node-id='${this.nodeId.id}']`)?.scrollIntoView()
+                this.config.form.querySelector(`shacl-node[data-node-id='${refId}']`)?.scrollIntoView()
             }
             this.appendChild(anchor)
             this.style.flexDirection = 'row'
@@ -64,9 +68,6 @@ export class ShaclNode extends HTMLElement {
                 config.renderedNodes.add(id)
             }
             this.dataset.nodeId = this.nodeId.id
-            const quads = config.shapesGraph.getQuads(shaclSubject, null, null, null)
-            let list: Term[] | undefined
-
             if (this.config.attributes.showNodeIds !== null) {
                 const div = document.createElement('div')
                 div.innerText = `id: ${this.nodeId.id}`
@@ -74,39 +75,19 @@ export class ShaclNode extends HTMLElement {
                 this.appendChild(div)
             }
 
-            for (const quad of quads) {
+            // first initialize owl:imports, this is needed before adding properties to properly resolve class instances etc.
+            for (const owlImport of config.store.getQuads(shaclSubject, OWL_PREDICATE_IMPORTS, null, null)) {
+                this.owlImports.push(owlImport.object as NamedNode)
+            }
+            // now parse other node quads
+            for (const quad of config.store.getQuads(shaclSubject, null, null, null)) {
                 switch (quad.predicate.id) {
-                    case `${PREFIX_SHACL}property`:
-                        let parentElement: HTMLElement = this
-                        // check if property belongs to a group
-                        const groupRef = config.shapesGraph.getQuads(quad.object as Term, `${PREFIX_SHACL}group`, null, null)
-                        if (groupRef.length > 0) {
-                            const groupSubject = groupRef[0].object.value
-                            if (config.groups.indexOf(groupSubject) > -1) {
-                                // check if group element already exists, otherwise create it
-                                let group = this.querySelector(`:scope > .shacl-group[data-subject='${groupSubject}']`) as HTMLElement
-                                if (!group) {
-                                    group = createShaclGroup(groupSubject, config)
-                                    this.appendChild(group)
-                                }
-                                parentElement = group
-                            } else {
-                                console.warn('ignoring unknown group reference', groupRef[0], 'existing groups:', config.groups)
-                            }
-                        }
-                        // delay creating/appending the property until we finished parsing the node.
-                        // This is needed to have possible owlImports parsed before creating the property.
-                        setTimeout(() => {
-                            const property = new ShaclProperty(quad.object as NamedNode | BlankNode, this, config, valueSubject)
-                            // do not add empty properties (i.e. properties with no instances). This can be the case e.g. in viewer mode when there is no data for the respective property.
-                            if (property.childElementCount > 0) {
-                                parentElement.appendChild(property)
-                            }
-                        })
+                    case SHACL_PREDICATE_PROPERTY.id:
+                        this.addPropertyInstance(quad.object, config, valueSubject)
                         break;
                     case `${PREFIX_SHACL}and`:
                         // inheritance via sh:and
-                        list = config.lists[quad.object.value]
+                        const list = config.lists[quad.object.value]
                         if (list?.length) {
                             for (const shape of list) {
                                 this.prepend(new ShaclNode(shape as NamedNode, config, valueSubject, this))
@@ -123,17 +104,11 @@ export class ShaclNode extends HTMLElement {
                     case `${PREFIX_SHACL}targetClass`:
                         this.targetClass = quad.object as NamedNode
                         break;
-                    case OWL_PREDICATE_IMPORTS.id:
-                        this.owlImports.push(quad.object as NamedNode)
-                        break;
                     case `${PREFIX_SHACL}or`:
-                        list = config.lists[quad.object.value]
-                        if (list?.length) {
-                            this.appendChild(createShaclOrConstraint(list, this, config))
-                        }
-                        else {
-                            console.error('list not found:', quad.object.value, 'existing lists:', config.lists)
-                        }
+                        this.tryResolve(quad.object, valueSubject, config)
+                        break;
+                    case `${PREFIX_SHACL}xone`:
+                        this.tryResolve(quad.object, valueSubject, config)
                         break;
                 }
             }
@@ -150,18 +125,68 @@ export class ShaclNode extends HTMLElement {
         if (!subject) {
             subject = this.nodeId
         }
-        for (const shape of this.querySelectorAll(':scope > shacl-node, :scope > .shacl-group > shacl-node, :scope > shacl-property, :scope > .shacl-group > shacl-property')) {
-            (shape as ShaclNode | ShaclProperty).toRDF(graph, subject)
+        // output triples only if node is not a link
+        if (!this.linked) {
+            for (const shape of this.querySelectorAll(':scope > shacl-node, :scope > .shacl-group > shacl-node, :scope > shacl-property, :scope > .shacl-group > shacl-property')) {
+                (shape as ShaclNode | ShaclProperty).toRDF(graph, subject)
+            }
+            if (this.targetClass) {
+                graph.addQuad(subject, RDF_PREDICATE_TYPE, this.targetClass, this.config.valuesGraphId)
+            }
+            // if this is the root shacl node, check if we should add one of the rdf:type or dcterms:conformsTo predicates
+            if (this.config.attributes.generateNodeShapeReference && !this.parent) {
+                graph.addQuad(subject, DataFactory.namedNode(this.config.attributes.generateNodeShapeReference), this.shaclSubject, this.config.valuesGraphId)
+            }
+        }
+        return subject
+    }
+
+    addPropertyInstance(shaclSubject: Term, config: Config, valueSubject: NamedNode | BlankNode | undefined) {
+        let parentElement: HTMLElement = this
+        // check if property belongs to a group
+        const groupRef = config.store.getQuads(shaclSubject as Term, `${PREFIX_SHACL}group`, null, null)
+        if (groupRef.length > 0) {
+            const groupSubject = groupRef[0].object.value
+            if (config.groups.indexOf(groupSubject) > -1) {
+                // check if group element already exists, otherwise create it
+                let group = this.querySelector(`:scope > .shacl-group[data-subject='${groupSubject}']`) as HTMLElement
+                if (!group) {
+                    group = createShaclGroup(groupSubject, config)
+                    this.appendChild(group)
+                }
+                parentElement = group
+            } else {
+                console.warn('ignoring unknown group reference', groupRef[0], 'existing groups:', config.groups)
+            }
+        }
+        const property = new ShaclProperty(shaclSubject as NamedNode | BlankNode, this, config, valueSubject)
+        // do not add empty properties (i.e. properties with no instances). This can be the case e.g. in viewer mode when there is no data for the respective property.
+        if (property.childElementCount > 0) {
+            parentElement.appendChild(property)
         }
-        if (this.targetClass) {
-            graph.addQuad(subject, RDF_PREDICATE_TYPE, this.targetClass, this.config.valuesGraph)
+    }
+
+    tryResolve(subject: Term, valueSubject: NamedNode | BlankNode | undefined, config: Config) {
+        const list = config.lists[subject.value]
+        if (list?.length) {
+            let resolved = false
+            if (valueSubject) {
+                const resolvedPropertySubjects = resolveShaclOrConstraintOnNode(list, valueSubject, config)
+                if (resolvedPropertySubjects.length) {
+                    for (const propertySubject of resolvedPropertySubjects) {
+                        this.addPropertyInstance(propertySubject, config, valueSubject)
+                    }
+                    resolved = true
+                }
+            }
+            if (!resolved) {
+                this.appendChild(createShaclOrConstraint(list, this, config))
+            }
         }
-        // if this is the root shacl node, check if we should add one of the rdf:type or dcterms:conformsTo predicates
-        if (this.config.attributes.generateNodeShapeReference && !this.parent) {
-            graph.addQuad(subject, DataFactory.namedNode(this.config.attributes.generateNodeShapeReference), this.shaclSubject, this.config.valuesGraph)
+        else {
+            console.error('list for sh:or/sh:xone not found:', subject, 'existing lists:', config.lists)
         }
-        return subject
     }
 }
 
-window.customElements.define('shacl-node', ShaclNode)
+window.customElements.define('shacl-node', ShaclNode)

package/src/plugins/leaflet.ts

@@ -136,12 +136,12 @@ export class LeafletPlugin extends Plugin {
             document.body.style.position = 'fixed'
             dialog.showModal()
         }
-        const instance = fieldFactory(template, value || null)
+        const instance = fieldFactory(template, value || null, true)
         instance.appendChild(button)
         return instance
     }
 
-    createViewer(template: ShaclPropertyTemplate, value: Term): HTMLElement {
+    createViewer(_: ShaclPropertyTemplate, value: Term): HTMLElement {
         const container = document.createElement('div')
         const geometry = wktToGeometry(value.value)
         if (geometry?.coordinates?.length) {

package/src/plugins/mapbox.ts

@@ -4,8 +4,8 @@ import { ShaclPropertyTemplate } from '../property-template'
 import { Editor, fieldFactory } from '../theme'
 import { Map, NavigationControl, FullscreenControl, LngLatBounds, LngLatLike } from 'mapbox-gl'
 import MapboxDraw from '@mapbox/mapbox-gl-draw'
-import mapboxGlCss from 'mapbox-gl/dist/mapbox-gl.css'
-import mapboxGlDrawCss from '@mapbox/mapbox-gl-draw/dist/mapbox-gl-draw.css'
+import mapboxGlCss from 'mapbox-gl/dist/mapbox-gl.css?raw'
+import mapboxGlDrawCss from '@mapbox/mapbox-gl-draw/dist/mapbox-gl-draw.css?raw'
 import { Geometry, geometryToWkt, wktToGeometry } from './map-util'
 
 const css = `
@@ -106,12 +106,12 @@ export class MapboxPlugin extends Plugin {
             document.body.style.position = 'fixed'
             dialog.showModal()
         }
-        const instance = fieldFactory(template, value || null)
+        const instance = fieldFactory(template, value || null, true)
         instance.appendChild(button)
         return instance
     }
 
-    createViewer(template: ShaclPropertyTemplate, value: Term): HTMLElement {
+    createViewer(_: ShaclPropertyTemplate, value: Term): HTMLElement {
         const container = document.createElement('div')
         const geometry = wktToGeometry(value.value)
         if (geometry?.coordinates?.length) {

package/src/property-template.ts

@@ -34,11 +34,11 @@ const mappers: Record<string, (template: ShaclPropertyTemplate, term: Term) => v
     [`${PREFIX_SHACL}qualifiedValueShape`]:     (template, term) => { template.qualifiedValueShape = term },
     [`${PREFIX_SHACL}qualifiedMinCount`]: (template, term) => { template.minCount = parseInt(term.value) },
     [`${PREFIX_SHACL}qualifiedMaxCount`]: (template, term) => { template.maxCount = parseInt(term.value) },
-    [OWL_PREDICATE_IMPORTS.id]:   (template, term) => { template.owlImports.push(term as NamedNode) },
-    [SHACL_PREDICATE_CLASS.id]:   (template, term) => {
+    [OWL_PREDICATE_IMPORTS.id]:      (template, term) => { template.owlImports.push(term as NamedNode) },
+    [SHACL_PREDICATE_CLASS.id]:      (template, term) => {
         template.class = term as NamedNode
         // try to find node shape that has requested target class
-        const nodeShapes = template.config.shapesGraph.getSubjects(SHACL_PREDICATE_TARGET_CLASS, term, null)
+        const nodeShapes = template.config.store.getSubjects(SHACL_PREDICATE_TARGET_CLASS, term, null)
         if (nodeShapes.length > 0) {
             template.node = nodeShapes[0] as NamedNode
         }
@@ -48,12 +48,20 @@ const mappers: Record<string, (template: ShaclPropertyTemplate, term: Term) => v
         if (list?.length) {
             template.shaclOr = list
         } else {
-            console.error('list not found:', term.value, 'existing lists:', template.config.lists)
+            console.error('list for sh:or not found:', term.value, 'existing lists:', template.config.lists)
+        }
+    },
+    [`${PREFIX_SHACL}xone`]:           (template, term) => {
+        const list = template.config.lists[term.value]
+        if (list?.length) {
+            template.shaclXone = list
+        } else {
+            console.error('list for sh:xone not found:', term.value, 'existing lists:', template.config.lists)
         }
     }
 }
 
-export class ShaclPropertyTemplate  {
+export class ShaclPropertyTemplate {
     parent: ShaclNode
     label = ''
     name: Literal | undefined
@@ -79,6 +87,7 @@ export class ShaclPropertyTemplate  {
     shaclAnd: string | undefined
     shaclIn: string | undefined
     shaclOr: Term[] | undefined
+    shaclXone: Term[] | undefined
     languageIn: Term[] | undefined
     datatype: NamedNode | undefined
     hasValue: Term | undefined
@@ -86,14 +95,14 @@ export class ShaclPropertyTemplate  {
     owlImports: NamedNode[] = []
 
     config: Config
-    extendedShapes: NamedNode[] | undefined
+    extendedShapes: NamedNode[]  = []
 
     constructor(quads: Quad[], parent: ShaclNode, config: Config) {
         this.parent = parent
         this.config = config
         this.merge(quads)
         if (this.qualifiedValueShape) {
-            this.merge(config.shapesGraph.getQuads(this.qualifiedValueShape, null, null, null))
+            this.merge(config.store.getQuads(this.qualifiedValueShape, null, null, null))
         }
     }
 
@@ -108,7 +117,6 @@ export class ShaclPropertyTemplate  {
         }
         // resolve extended shapes
         if (this.node || this.shaclAnd) {
-            this.extendedShapes = []
             if (this.node) {
                 this.extendedShapes.push(this.node)
             }
@@ -134,6 +142,9 @@ export class ShaclPropertyTemplate  {
         if (this.shaclOr) {
             copy.shaclOr = [ ...this.shaclOr ]
         }
+        if (this.shaclXone) {
+            copy.shaclXone = [ ...this.shaclXone ]
+        }
         copy.merge = this.merge.bind(copy)
         copy.clone = this.clone.bind(copy)
         return copy