@ulb-darmstadt/shacl-form 1.9.0 → 1.9.2

package/dist/util.d.ts

@@ -11,3 +11,7 @@ export declare function removePrefixes(id: string, prefixes: Prefixes): string;
 export declare function findInstancesOf(clazz: NamedNode, template: ShaclPropertyTemplate): InputListEntry[];
 export declare function isURL(input: string): boolean;
 export declare function prioritizeByLanguage(languages: string[], text1?: Literal, text2?: Literal): Literal | undefined;
+export declare function extractLists(store: Store, { remove, ignoreErrors }?: {
+    remove?: boolean | undefined;
+    ignoreErrors?: boolean | undefined;
+}): Record<string, Term[]>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ulb-darmstadt/shacl-form",
-    "version": "1.9.0",
+    "version": "1.9.2",
     "description": "SHACL form generator",
     "main": "dist/form-default.js",
     "module": "dist/form-default.js",
@@ -55,7 +55,7 @@
         "@types/uuid": "^10.0.0",
         "rollup-plugin-peer-deps-external": "^2.2.4",
         "typescript": "^5.8.3",
-        "vite": "^7.0.5",
+        "vite": "^7.0.6",
         "vite-plugin-dts": "^4.5.4"
     },
     "dependencies": {
@@ -63,7 +63,7 @@
         "bootstrap": "^5.3.7",
         "jsonld": "^8.3.3",
         "leaflet": "^1.9.4",
-        "leaflet-editable": "^1.3.1",
+        "leaflet-editable": "^1.3.2",
         "leaflet.fullscreen": "^4.0.0",
         "mapbox-gl": "^3.13.0",
         "n3": "^1.26.0",
@@ -72,7 +72,7 @@
         "uuid": "^11.1.0"
     },
     "peerDependencies": {
-        "@ro-kit/ui-widgets": "^0.0.33",
+        "@ro-kit/ui-widgets": "^0.0.34",
         "mdui": "^2.1.4"
     }
 }

package/src/config.ts

@@ -4,6 +4,7 @@ import { PREFIX_SHACL, RDF_PREDICATE_TYPE } from './constants'
 import { ClassInstanceProvider } from './plugin'
 import { Loader } from './loader'
 import { Theme } from './theme'
+import { extractLists } from './util'
 
 export class ElementAttributes {
     shapes: string | null = null
@@ -99,19 +100,10 @@ export class Config {
 
     set store(store: Store) {
         this._store = store
-        this.lists = store.extractLists()
+        this.lists = extractLists(store)
         this.groups = []
         store.forSubjects(subject => {
             this.groups.push(subject.id)
         }, RDF_PREDICATE_TYPE, `${PREFIX_SHACL}PropertyGroup`, null)
     }
-
-    registerPrefixes(prefixes: Prefixes) {
-        for (const key in prefixes) {
-            // ignore empty (default) namespace
-            if (key) {
-                this.prefixes[key] = prefixes[key]
-            } 
-        }
-    }
 }

package/src/loader.ts

@@ -1,4 +1,4 @@
-import { Store, Quad, NamedNode, DataFactory, Parser, Prefixes } from 'n3'
+import { Store, Quad, NamedNode, DataFactory, StreamParser } from 'n3'
 import { DATA_GRAPH, DCTERMS_PREDICATE_CONFORMS_TO, OWL_PREDICATE_IMPORTS, RDF_PREDICATE_TYPE, SHACL_PREDICATE_CLASS, SHAPES_GRAPH } from './constants'
 import { Config } from './config'
 import { isURL } from './util'
@@ -11,7 +11,6 @@ import { toRDF } from 'jsonld'
 // that import the same resources
 const loadedURLCache: Record<string, Promise<string>> = {}
 const loadedClassesCache: Record<string, Promise<string>> = {}
-const ttlParser = new Parser()
 let sharedShapesGraph: Store | undefined
 
 export class Loader {
@@ -69,7 +68,8 @@ export class Loader {
         const parse = async (input: string) => {
             const dependencies: Promise<void>[] = []
             await new Promise((resolve, reject) => {
-                const addQuad = (quad: Quad) => {
+                const parser = guessContentType(input) === 'xml' ? new RdfXmlParser() : new StreamParser()
+                parser.on('data', (quad: Quad) => {
                     store.add(new Quad(quad.subject, quad.predicate, quad.object, graph))
                     // check if this is an owl:imports predicate and try to load the url
                     if (this.config.attributes.ignoreOwlImports === null && OWL_PREDICATE_IMPORTS.equals(quad.predicate)) {
@@ -98,44 +98,22 @@ export class Loader {
                             dependencies.push(this.importRDF(promise, store, graph))
                         }
                     }
-                }
-                const type = guessContentType(input)
-                if (type === 'xml') {
-                    const parser = new RdfXmlParser()
-                    parser.on('data', (quad: Quad) => {
-                        addQuad(quad)
-                    })
-                    .on('error', (error) => {
-                        console.warn('failed parsing graph', graph, error.message)
-                        reject(error)
-                    })
-                    .on('prefix', (prefix, iri) => {
-                        // ignore empty (default) namespace
-                        if (prefix) {
-                            this.config.prefixes[prefix] = iri
-                        }
-                    })
-                    .on('end', () => {
-                        resolve(null)
-                    })
-                    parser.write(input)
-                    parser.end()
-                } else {
-                    ttlParser.parse(input, (error: Error, quad: Quad, prefixes: Prefixes) => {
-                        if (error) {
-                            console.warn('failed parsing graph', graph, error.message)
-                            return reject(error)
-                        }
-                        if (quad) {
-                            addQuad(quad)
-                            return
-                        }
-                        if (prefixes) {
-                            this.config.registerPrefixes(prefixes)
-                        }
-                        resolve(null)
-                    })                
-                }
+                })
+                .on('error', (error) => {
+                    console.warn('failed parsing graph', graph, error.message)
+                    reject(error)
+                })
+                .on('prefix', (prefix, iri) => {
+                    // ignore empty (default) namespace
+                    if (prefix) {
+                        this.config.prefixes[prefix] = iri
+                    }
+                })
+                .on('end', () => {
+                    resolve(null)
+                })
+                parser.write(input)
+                parser.end()
             })
             try {
                 await Promise.allSettled(dependencies)

package/src/util.ts

@@ -1,5 +1,5 @@
 import { Literal, NamedNode, Prefixes, Quad, Store } from 'n3'
-import { DATA_GRAPH, PREFIX_FOAF, PREFIX_RDFS, PREFIX_SHACL, PREFIX_SKOS, RDFS_PREDICATE_SUBCLASS_OF, RDF_PREDICATE_TYPE, SHAPES_GRAPH, SKOS_PREDICATE_BROADER, SKOS_PREDICATE_NARROWER } from './constants'
+import { DATA_GRAPH, PREFIX_FOAF, PREFIX_RDF, PREFIX_RDFS, PREFIX_SHACL, PREFIX_SKOS, RDFS_PREDICATE_SUBCLASS_OF, RDF_PREDICATE_TYPE, SHAPES_GRAPH, SKOS_PREDICATE_BROADER, SKOS_PREDICATE_NARROWER } from './constants'
 import { Term } from '@rdfjs/types'
 import { InputListEntry } from './theme'
 import { ShaclPropertyTemplate } from './property-template'
@@ -44,7 +44,7 @@ export function findObjectByPredicate(quads: Quad[], predicate: string, prefix:
 }
 
 export function focusFirstInputElement(context: HTMLElement) {
-    (context.querySelector('input,select,textarea') as HTMLElement)?.focus()
+    (context.querySelector('.editor') as HTMLElement)?.focus()
 }
 
 export function findLabel(quads: Quad[], languages: string[]): string {
@@ -170,4 +170,106 @@ export function prioritizeByLanguage(languages: string[], text1?: Literal, text2
         return text1
     }
     return index2 > index1 ? text1 : text2
-}
+}
+
+/*
+ This code is taken from https://github.com/rdfjs/N3.js/blob/main/src/N3Store.js and adapted to allow rdf:type triples in lists.
+ Can be removed as soon as https://github.com/rdfjs/N3.js/issues/546 is fixed.
+*/
+export function  extractLists(store: Store, { remove = false, ignoreErrors = false } = {}) {
+    const lists: Record<string, Term[]> = {} // has scalar keys so could be a simple Object
+    const onError = ignoreErrors ? (() => true) :
+                  ((node: Term, message: string) => { throw new Error(`${node.value} ${message}`) })
+
+    // Traverse each list from its tail
+    const tails = store.getQuads(null, PREFIX_RDF + 'rest', PREFIX_RDF + 'nil', null)
+    const toRemove = remove ? [...tails] : []
+    tails.forEach(tailQuad => {
+      const items = []             // the members found as objects of rdf:first quads
+      let malformed = false        // signals whether the current list is malformed
+      let head                     // the head of the list (_:b1 in above example)
+      let headPos: string                // set to subject or object when head is set
+      const graph = tailQuad.graph // make sure list is in exactly one graph
+
+      // Traverse the list from tail to end
+      let current: Term | null = tailQuad.subject
+      while (current && !malformed) {
+        const objectQuads = store.getQuads(null, null, current, null)
+        const subjectQuads = store.getQuads(current, null, null, null).filter(quad => !quad.predicate.equals(RDF_PREDICATE_TYPE))
+        let quad, first = null, rest = null, parent = null
+
+        // Find the first and rest of this list node
+        for (let i = 0; i < subjectQuads.length && !malformed; i++) {
+          quad = subjectQuads[i]
+          if (!quad.graph.equals(graph))
+            malformed = onError(current, 'not confined to single graph')
+          else if (head)
+            malformed = onError(current, 'has non-list arcs out')
+
+          // one rdf:first
+          else if (quad.predicate.value === PREFIX_RDF + 'first') {
+            if (first)
+              malformed = onError(current, 'has multiple rdf:first arcs')
+            else
+              toRemove.push(first = quad)
+          }
+
+          // one rdf:rest
+          else if (quad.predicate.value === PREFIX_RDF + 'rest') {
+            if (rest)
+              malformed = onError(current, 'has multiple rdf:rest arcs')
+            else
+              toRemove.push(rest = quad)
+          }
+
+          // alien triple
+          else if (objectQuads.length)
+            malformed = onError(current, 'can\'t be subject and object')
+          else {
+            head = quad // e.g. { (1 2 3) :p :o }
+            headPos = 'subject'
+          }
+        }
+
+        // { :s :p (1 2) } arrives here with no head
+        // { (1 2) :p :o } arrives here with head set to the list.
+        for (let i = 0; i < objectQuads.length && !malformed; ++i) {
+          quad = objectQuads[i]
+          if (head)
+            malformed = onError(current, 'can\'t have coreferences')
+          // one rdf:rest
+          else if (quad.predicate.value === PREFIX_RDF + 'rest') {
+            if (parent)
+              malformed = onError(current, 'has incoming rdf:rest arcs')
+            else
+              parent = quad
+          }
+          else {
+            head = quad // e.g. { :s :p (1 2) }
+            headPos = 'object'
+          }
+        }
+
+        // Store the list item and continue with parent
+        if (!first)
+          malformed = onError(current, 'has no list head')
+        else
+          items.unshift(first.object)
+        current = parent && parent.subject
+      }
+
+      // Don't remove any quads if the list is malformed
+      if (malformed)
+        remove = false
+      // Store the list under the value of its head
+      else if (head) {
+        // @ts-ignore
+        lists[head[headPos].value] = items
+      }
+    })
+
+    // Remove list quads if requested
+    if (remove)
+      store.removeQuads(toRemove)
+    return lists
+  }