@ulb-darmstadt/shacl-form 1.7.2 → 1.7.4

package/dist/property-template.d.ts

@@ -28,9 +28,11 @@ export declare class ShaclPropertyTemplate {
     shaclAnd: string | undefined;
     shaclIn: string | undefined;
     shaclOr: Term[] | undefined;
+    shaclXone: Term[] | undefined;
     languageIn: Term[] | undefined;
     datatype: NamedNode | undefined;
     hasValue: Term | undefined;
+    qualifiedValueShape: Term | undefined;
     owlImports: NamedNode[];
     config: Config;
     extendedShapes: NamedNode[] | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ulb-darmstadt/shacl-form",
-    "version": "1.7.2",
+    "version": "1.7.4",
     "description": "SHACL form generator",
     "main": "dist/form-default.js",
     "module": "dist/form-default.js",
@@ -33,7 +33,7 @@
     },
     "devDependencies": {
         "@types/jsonld": "^1.5.15",
-        "@types/leaflet": "^1.9.18",
+        "@types/leaflet": "^1.9.19",
         "@types/leaflet-editable": "^1.2.6",
         "@types/leaflet.fullscreen": "^3.0.2",
         "@types/mapbox__mapbox-gl-draw": "^1.4.9",
@@ -49,12 +49,12 @@
     },
     "dependencies": {
         "@mapbox/mapbox-gl-draw": "^1.5.0",
-        "bootstrap": "^5.3.6",
+        "bootstrap": "^5.3.7",
         "jsonld": "^8.3.3",
         "leaflet": "^1.9.4",
         "leaflet-editable": "^1.3.1",
         "leaflet.fullscreen": "^4.0.0",
-        "mapbox-gl": "^3.12.0",
+        "mapbox-gl": "^3.13.0",
         "mdui": "^2.1.4",
         "n3": "^1.26.0",
         "shacl-engine": "^1.0.2",

package/src/constants.ts

@@ -20,6 +20,7 @@ export const OWL_PREDICATE_IMPORTS = DataFactory.namedNode(PREFIX_OWL + 'imports
 export const OWL_OBJECT_NAMED_INDIVIDUAL = DataFactory.namedNode(PREFIX_OWL + 'NamedIndividual')
 export const SHACL_OBJECT_NODE_SHAPE = DataFactory.namedNode(PREFIX_SHACL + 'NodeShape')
 export const SHACL_OBJECT_IRI = DataFactory.namedNode(PREFIX_SHACL + 'IRI')
+export const SHACL_PREDICATE_PROPERTY = DataFactory.namedNode(PREFIX_SHACL + 'property')
 export const SHACL_PREDICATE_CLASS = DataFactory.namedNode(PREFIX_SHACL + 'class')
 export const SHACL_PREDICATE_TARGET_CLASS = DataFactory.namedNode(PREFIX_SHACL + 'targetClass')
 export const SHACL_PREDICATE_NODE_KIND = DataFactory.namedNode(PREFIX_SHACL + 'nodeKind')

package/src/constraints.ts

@@ -3,7 +3,7 @@ import { Term } from '@rdfjs/types'
 import { ShaclNode } from "./node"
 import { ShaclProperty, createPropertyInstance } from "./property"
 import { Config } from './config'
-import { PREFIX_SHACL, RDF_PREDICATE_TYPE, SHACL_PREDICATE_CLASS, SHACL_PREDICATE_TARGET_CLASS, SHACL_PREDICATE_NODE_KIND, SHACL_OBJECT_IRI } from './constants'
+import { PREFIX_SHACL, RDF_PREDICATE_TYPE, SHACL_PREDICATE_CLASS, SHACL_PREDICATE_TARGET_CLASS, SHACL_PREDICATE_NODE_KIND, SHACL_OBJECT_IRI, SHACL_PREDICATE_PROPERTY } from './constants'
 import { findLabel, removePrefixes } from './util'
 import { ShaclPropertyTemplate } from './property-template'
 import { Editor, InputListEntry } from './theme'
@@ -17,18 +17,45 @@ export function createShaclOrConstraint(options: Term[], context: ShaclNode | Sh
     optionElements.push({ label: '--- please choose ---', value: '' })
 
     if (context instanceof ShaclNode) {
-        const properties: ShaclProperty[] = []
-        // expect options to be shacl properties
+        const properties: ShaclProperty[][] = []
+        // options can be shacl properties or blank nodes referring to (list of) properties
+        let optionsAreReferencedProperties = false
+        if (options.length) {
+            optionsAreReferencedProperties = config.shapesGraph.getObjects(options[0] , SHACL_PREDICATE_PROPERTY, null).length > 0
+        }
         for (let i = 0; i < options.length; i++) {
-            const property = new ShaclProperty(options[i] as NamedNode | BlankNode, context, config)
-            properties.push(property)
-            optionElements.push({ label: property.template.label, value: i.toString() })
+            if (optionsAreReferencedProperties) {
+                const quads = config.shapesGraph.getObjects(options[i] , SHACL_PREDICATE_PROPERTY, null)
+                // option can be single property or list of properties
+                const list: ShaclProperty[] = []
+                let combinedText = ''
+                for (const subject of quads) {
+                    const property = new ShaclProperty(subject as NamedNode | BlankNode, context, config)
+                    list.push(property)
+                    combinedText += (combinedText.length > 1 ? ' / ' : '') + property.template.label
+                }
+                properties.push(list)
+                optionElements.push({ label: combinedText, value: i.toString() })
+            } else {
+                const property = new ShaclProperty(options[i] as NamedNode | BlankNode, context, config)
+                properties.push([property])
+                optionElements.push({ label: property.template.label, value: i.toString() })
+            }
         }
         const editor = config.theme.createListEditor('Please choose', null, false, optionElements)
         const select = editor.querySelector('.editor') as Editor
         select.onchange = () => {
             if (select.value) {
-                constraintElement.replaceWith(properties[parseInt(select.value)])
+                const selectedOptions = properties[parseInt(select.value)]
+                let lastAddedProperty: ShaclProperty
+                if (selectedOptions.length) {
+                    lastAddedProperty = selectedOptions[0]
+                    constraintElement.replaceWith(selectedOptions[0])
+                }
+                for (let i = 1; i < selectedOptions.length; i++) {
+                    lastAddedProperty!.after(selectedOptions[1])
+                    lastAddedProperty = selectedOptions[1]
+                }
             }
         }
         constraintElement.appendChild(editor)
@@ -54,53 +81,73 @@ export function createShaclOrConstraint(options: Term[], context: ShaclNode | Sh
     return constraintElement
 }
 
-export function resolveShaclOrConstraint(template: ShaclPropertyTemplate, value: Term): ShaclPropertyTemplate {
-    if (!template.shaclOr) {
-        console.warn('can\'t resolve sh:or because template has no options', template)
-        return template
-    }
+export function resolveShaclOrConstraintOnProperty(subjects: Term[], value: Term, config: Config): Quad[] {
     if (value instanceof Literal) {
-        // value is a literal, try to resolve sh:or by matching on given value datatype
+        // value is a literal, try to resolve sh:or/sh:xone by matching on given value datatype
         const valueType = value.datatype
-        for (const subject of template.shaclOr) {
-            const options = template.config.shapesGraph.getQuads(subject, null, null, null)
+        for (const subject of subjects) {
+            const options = config.shapesGraph.getQuads(subject, null, null, null)
             for (const quad of options) {
                 if (quad.predicate.value === `${PREFIX_SHACL}datatype` && quad.object.equals(valueType)) {
-                    return template.clone().merge(options)
+                    return options
                 }
             }
         }
     } else {
-        // value is a NamedNode or BlankNode, try to resolve sh:or by matching rdf:type of given value with sh:node or sh:class in data graph or shapes graph
-        let types = template.config.dataGraph.getObjects(value, RDF_PREDICATE_TYPE, null)
-        types.push(...template.config.shapesGraph.getObjects(value, RDF_PREDICATE_TYPE, null))
-        for (const subject of template.shaclOr) {
-            const options = template.config.shapesGraph.getQuads(subject, null, null, null)
+        // value is a NamedNode or BlankNode, try to resolve sh:or/sh:xone by matching rdf:type of given value with sh:node or sh:class in data graph or shapes graph
+        const types = config.dataGraph.getObjects(value, RDF_PREDICATE_TYPE, null)
+        types.push(...config.shapesGraph.getObjects(value, RDF_PREDICATE_TYPE, null))
+        for (const subject of subjects) {
+            const options = config.shapesGraph.getQuads(subject, null, null, null)
             for (const quad of options) {
                 if (types.length > 0) {
-                    // try to find matching sh:node in sh:or values
+                    // try to find matching sh:node in sh:or/sh:xone values
                     if (quad.predicate.value === `${PREFIX_SHACL}node`) {
                         for (const type of types) {
-                            if (template.config.shapesGraph.getQuads(quad.object, SHACL_PREDICATE_TARGET_CLASS, type, null).length > 0) {
-                                return template.clone().merge(options)
+                            if (config.shapesGraph.getQuads(quad.object, SHACL_PREDICATE_TARGET_CLASS, type, null).length > 0) {
+                                return options
                             }
                         }
                     }
-                    // try to find matching sh:class in sh:or values
+                    // try to find matching sh:class in sh:or/sh:xone values
                     if (quad.predicate.equals(SHACL_PREDICATE_CLASS)) {
                         for (const type of types) {
                             if (quad.object.equals(type)) {
-                                return template.clone().merge(options)
+                                return options
                             }
                         }
                     }
                 } else if (quad.predicate.equals(SHACL_PREDICATE_NODE_KIND) && quad.object.equals(SHACL_OBJECT_IRI)) {
                     // if sh:nodeKind is sh:IRI, just use that
-                    return template.clone().merge(options)
+                    return options
+                }
+            }
+        }
+    }
+    console.error('couldn\'t resolve sh:or/sh:xone on property for value', value)
+    return []
+}
+
+export function resolveShaclOrConstraintOnNode(subjects: Term[], value: Term, config: Config): Term[] {
+    for (const subject of subjects) {
+        let subjectMatches = true
+        const propertySubjects = config.shapesGraph.getObjects(subject, SHACL_PREDICATE_PROPERTY, null)
+        for (const propertySubject of propertySubjects) {
+            const paths = config.shapesGraph.getObjects(propertySubject, `${PREFIX_SHACL}path`, null)
+            for (const path of paths) {
+                const values = config.dataGraph.getObjects(value, path, null)
+                values.push(...config.shapesGraph.getObjects(value, path, null))
+                if (!values.length) {
+                    subjectMatches = false
+                    break
                 }
             }
         }
+        if (subjectMatches) {
+            return propertySubjects
+        }
     }
-    console.error('couldn\'t resolve sh:or for value', value)
-    return template
+
+    console.error('couldn\'t resolve sh:or/sh:xone on node for value', value)
+    return []
 }

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 {
@@ -76,33 +76,8 @@ export class ShaclNode extends HTMLElement {
 
             for (const quad of quads) {
                 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
@@ -127,13 +102,10 @@ export class ShaclNode extends HTMLElement {
                         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;
                 }
             }
@@ -162,6 +134,57 @@ export class ShaclNode extends HTMLElement {
         }
         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.shapesGraph.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)
+            }
+        }
+        // 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(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)
+            }
+        })
+    }
+
+    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))
+            }
+        }
+        else {
+            console.error('list for sh:or/sh:xone not found:', subject, 'existing lists:', config.lists)
+        }
+    }
 }
 
 window.customElements.define('shacl-node', ShaclNode)

package/src/property-template.ts

@@ -31,8 +31,11 @@ const mappers: Record<string, (template: ShaclPropertyTemplate, term: Term) => v
     [`${PREFIX_SHACL}languageIn`]:   (template, term) => { template.languageIn = template.config.lists[term.value]; template.datatype = DataFactory.namedNode(PREFIX_RDF + 'langString') },
     [`${PREFIX_SHACL}defaultValue`]: (template, term) => { template.defaultValue = term },
     [`${PREFIX_SHACL}hasValue`]:     (template, term) => { template.hasValue = term },
-    [OWL_PREDICATE_IMPORTS.id]:   (template, term) => { template.owlImports.push(term as NamedNode) },
-    [SHACL_PREDICATE_CLASS.id]:   (template, term) => {
+    [`${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) => {
         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)
@@ -45,7 +48,15 @@ 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)
         }
     }
 }
@@ -76,9 +87,11 @@ export class ShaclPropertyTemplate  {
     shaclAnd: string | undefined
     shaclIn: string | undefined
     shaclOr: Term[] | undefined
+    shaclXone: Term[] | undefined
     languageIn: Term[] | undefined
     datatype: NamedNode | undefined
     hasValue: Term | undefined
+    qualifiedValueShape: Term | undefined
     owlImports: NamedNode[] = []
 
     config: Config
@@ -88,6 +101,9 @@ export class ShaclPropertyTemplate  {
         this.parent = parent
         this.config = config
         this.merge(quads)
+        if (this.qualifiedValueShape) {
+            this.merge(config.shapesGraph.getQuads(this.qualifiedValueShape, null, null, null))
+        }
     }
 
     merge(quads: Quad[]): ShaclPropertyTemplate {
@@ -127,6 +143,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

package/src/property.ts

@@ -2,12 +2,13 @@ import { BlankNode, DataFactory, NamedNode, Store } from 'n3'
 import { Term } from '@rdfjs/types'
 import { ShaclNode } from './node'
 import { focusFirstInputElement } from './util'
-import { createShaclOrConstraint, resolveShaclOrConstraint } from './constraints'
+import { createShaclOrConstraint, resolveShaclOrConstraintOnProperty } from './constraints'
 import { Config } from './config'
 import { ShaclPropertyTemplate } from './property-template'
 import { Editor, fieldFactory } from './theme'
 import { toRDF } from './serialize'
 import { findPlugin } from './plugin'
+import { RDF_PREDICATE_TYPE, SHACL_PREDICATE_TARGET_CLASS } from './constants'
 
 export class ShaclProperty extends HTMLElement {
     template: ShaclPropertyTemplate
@@ -46,6 +47,22 @@ export class ShaclProperty extends HTMLElement {
             const values = valueSubject ? config.dataGraph.getQuads(valueSubject, this.template.path, null, null) : []
             let valuesContainHasValue = false
             for (const value of values) {
+                // ignore values that do not conform to this property.
+                // this might be the case when there are multiple properties with the same sh:path in a NodeShape.
+                if (this.template.node) {
+                    const targetClasses = config.shapesGraph.getObjects(this.template.node, SHACL_PREDICATE_TARGET_CLASS, null)
+                    if (targetClasses.length > 0) {
+                        let hasTargetClass = false
+                        for (let i = 0; i < targetClasses.length && !hasTargetClass; i++) {
+                            if (config.dataGraph.getQuads(value.object, RDF_PREDICATE_TYPE, targetClasses[i], null).length > 0) {
+                                hasTargetClass = true
+                            }        
+                        }
+                        if (!hasTargetClass) {
+                            continue
+                        }
+                    }
+                }
                 this.addPropertyInstance(value.object)
                 if (this.template.hasValue && value.object.equals(this.template.hasValue)) {
                     valuesContainHasValue = true
@@ -83,22 +100,29 @@ export class ShaclProperty extends HTMLElement {
 
     addPropertyInstance(value?: Term): HTMLElement {
         let instance: HTMLElement
-        if (this.template.shaclOr?.length) {
+        if (this.template.shaclOr?.length || this.template.shaclXone?.length) {
+            const options = this.template.shaclOr?.length ? this.template.shaclOr : this.template.shaclXone as Term[]
+            let resolved = false
             if (value) {
-                instance = createPropertyInstance(resolveShaclOrConstraint(this.template, value), value, true)
-            } else {
-                instance = createShaclOrConstraint(this.template.shaclOr, this, this.template.config)
+                const resolvedOptions = resolveShaclOrConstraintOnProperty(options, value, this.template.config)
+                if (resolvedOptions.length) {
+                    instance = createPropertyInstance(this.template.clone().merge(resolvedOptions), value, true)
+                    resolved = true
+                }
+            } 
+            if (!resolved) {
+                instance = createShaclOrConstraint(options, this, this.template.config)
                 appendRemoveButton(instance, '')
             }
         } else {
             instance = createPropertyInstance(this.template, value)
         }
         if (this.template.config.editMode) {
-            this.insertBefore(instance, this.addButton!)
+            this.insertBefore(instance!, this.addButton!)
         } else {
-            this.appendChild(instance)
+            this.appendChild(instance!)
         }
-        return instance
+        return instance!
     }
 
     updateControls() {

package/src/util.ts

@@ -85,22 +85,32 @@ function findClassInstancesFromOwlImports(clazz: NamedNode, context: ShaclNode |
 }
 
 export function findInstancesOf(clazz: NamedNode, template: ShaclPropertyTemplate, indent = 0): InputListEntry[] {
-    // find instances in the shapes graph
-    const instances: Term[] = template.config.shapesGraph.getSubjects(RDF_PREDICATE_TYPE, clazz, SHAPES_GRAPH)
-    // find instances in the data graph
-    instances.push(...template.config.dataGraph.getSubjects(RDF_PREDICATE_TYPE, clazz, null))
-    // find instances in imported taxonomies
-    findClassInstancesFromOwlImports(clazz, template, template.config.shapesGraph, instances)
-    
-    const entries = createInputListEntries(instances, template.config.shapesGraph, template.config.languages, indent)
-    for (const subClass of template.config.shapesGraph.getSubjects(RDFS_PREDICATE_SUBCLASS_OF, clazz, null)) {
-        entries.push(...findInstancesOf(subClass as NamedNode, template, indent + 1))
+    let instances: Term[]
+    // if template has sh:in, then just use that as class instances
+    if (template.shaclIn) {
+        const list = template.config.lists[template.shaclIn]
+        instances = list?.length ? list : []
+    } else {
+        // find instances in the shapes graph
+        instances = template.config.shapesGraph.getSubjects(RDF_PREDICATE_TYPE, clazz, SHAPES_GRAPH)
+        // find instances in the data graph
+        instances.push(...template.config.dataGraph.getSubjects(RDF_PREDICATE_TYPE, clazz, null))
+        // find instances in imported taxonomies
+        findClassInstancesFromOwlImports(clazz, template, template.config.shapesGraph, instances)
     }
-    if (template.config.shapesGraph.getQuads(clazz, RDF_PREDICATE_TYPE, OWL_OBJECT_NAMED_INDIVIDUAL, null).length > 0) {
-        entries.push(...createInputListEntries([ clazz ], template.config.shapesGraph, template.config.languages, indent))
-        for (const subClass of template.config.shapesGraph.getSubjects(SKOS_PREDICATE_BROADER, clazz, null)) {
+
+    const entries = createInputListEntries(instances, template.config.shapesGraph, template.config.languages, indent)
+    // build inheritance tree only if sh:in is not defined
+    if (template.shaclIn === undefined) {
+        for (const subClass of template.config.shapesGraph.getSubjects(RDFS_PREDICATE_SUBCLASS_OF, clazz, null)) {
             entries.push(...findInstancesOf(subClass as NamedNode, template, indent + 1))
         }
+        if (template.config.shapesGraph.getQuads(clazz, RDF_PREDICATE_TYPE, OWL_OBJECT_NAMED_INDIVIDUAL, null).length > 0) {
+            entries.push(...createInputListEntries([ clazz ], template.config.shapesGraph, template.config.languages, indent))
+            for (const subClass of template.config.shapesGraph.getSubjects(SKOS_PREDICATE_BROADER, clazz, null)) {
+                entries.push(...findInstancesOf(subClass as NamedNode, template, indent + 1))
+            }
+        }
     }
     return entries
 }