@ulb-darmstadt/shacl-form 1.10.4 → 2.0.0-rc2

package/src/themes/material.ts

@@ -1,253 +0,0 @@
-import { ShaclPropertyTemplate } from '../property-template'
-import { Term } from '@rdfjs/types'
-import { Button, TextField, Checkbox } from 'mdui'
-import { Theme } from '../theme'
-import { InputListEntry, Editor } from '../theme'
-import { Literal, NamedNode } from 'n3'
-import { Term as N3Term }  from 'n3'
-import css from './material.css?raw'
-import { PREFIX_SHACL, PREFIX_XSD, XSD_DATATYPE_STRING } from '../constants'
-import { RokitSelect } from '@ro-kit/ui-widgets'
-
-export class MaterialTheme extends Theme {
-    constructor() {
-        super(css)
-    }
-
-    createDefaultTemplate(label: string, value: Term | null, required: boolean, editor: Editor, template?: ShaclPropertyTemplate): HTMLElement {
-        editor.classList.add('editor')
-        if (template?.datatype) {
-            // store datatype on editor, this is used for RDF serialization
-            editor.shaclDatatype = template.datatype
-        } else if (value instanceof Literal) {
-            editor.shaclDatatype = value.datatype
-        }
-        if (template?.minCount !== undefined) {
-            editor.dataset.minCount = String(template.minCount)
-        }
-        if (template?.class) {
-            editor.dataset.class = template.class.value
-        }
-        if (template?.nodeKind) {
-            editor.dataset.nodeKind = template.nodeKind.value
-        } else if (value instanceof NamedNode) {
-            editor.dataset.nodeKind = PREFIX_SHACL + 'IRI'
-        }
-        if (template?.hasValue || template?.readonly) {
-            editor.disabled = true
-        }
-        editor.value = value?.value || template?.defaultValue?.value || ''
-    
-        const placeholder = template?.description ? template.description.value : template?.pattern ? template.pattern : null
-        if (placeholder) {
-            editor.setAttribute('placeholder', placeholder)
-        }
-        if (required) {
-            editor.setAttribute('required', 'true')
-        }
-    
-        const result = document.createElement('div')
-        if (label) {
-            const labelElem = document.createElement('label')
-            labelElem.htmlFor = editor.id
-            labelElem.innerText = label
-            result.appendChild(labelElem)
-        }
-        result.appendChild(editor)
-        return result
-    }
-    
-    createTextEditor(label: string, value: Term | null, required: boolean, template: ShaclPropertyTemplate): HTMLElement {
-        const editor = new TextField()
-        editor.variant = 'outlined'
-        editor.label = label
-        editor.type = 'text'
-        if (template.description) {
-            editor.helper = template.description.value
-        }
-        if (template.singleLine === false) {
-            editor.rows = 5
-        }
-        if (template.pattern) {
-            editor.pattern = template.pattern
-        }
-        // @ts-ignore
-        return this.createDefaultTemplate('', value, required, editor, template)
-    }
-
-    createNumberEditor(label: string, value: Term | null, required: boolean, template: ShaclPropertyTemplate): HTMLElement {
-        const editor = new TextField()
-        editor.variant = 'outlined'
-        editor.type = 'number'
-        editor.label = label
-        editor.helper = template.description ?.value || ''
-        const min = template.minInclusive !== undefined ? template.minInclusive : template.minExclusive !== undefined ? template.minExclusive + 1 : undefined
-        const max = template.maxInclusive !== undefined ? template.maxInclusive : template.maxExclusive !== undefined ? template.maxExclusive - 1 : undefined
-        if (min !== undefined) {
-            editor.setAttribute('min', String(min))
-        }
-        if (max !== undefined) {
-            editor.setAttribute('max', String(max))
-        }
-        if (template.datatype?.value !== PREFIX_XSD + 'integer') {
-            editor.setAttribute('step', '0.1')
-        }
-        // @ts-ignore
-        return this.createDefaultTemplate('', value, required, editor, template)
-    }
-
-    createListEditor(label: string, value: Term | null, required: boolean, listEntries: InputListEntry[], template?: ShaclPropertyTemplate): HTMLElement {
-        const editor = new RokitSelect()
-        editor.clearable = true
-        const result = this.createDefaultTemplate(label, null, required, editor, template)
-        const ul = document.createElement('ul')
-        let isFlatList = true
-
-        const appendListEntry = (entry: InputListEntry, parent: HTMLUListElement) => {
-            const li = document.createElement('li')
-            if (typeof entry.value === 'string') {
-                li.dataset.value = entry.value
-                li.innerText = entry.label ? entry.label : entry.value
-            } else {
-                if (entry.value instanceof Literal && entry.value.datatype.equals(XSD_DATATYPE_STRING)) {
-                    li.dataset.value = entry.value.value
-                } else {
-                    // this is needed for typed rdf literals
-                    li.dataset.value = (entry.value as N3Term).id
-                }
-                li.innerText = entry.label ? entry.label : entry.value.value
-            }
-            parent.appendChild(li)
-            if (entry.children?.length) {
-                isFlatList = false
-                const ul = document.createElement('ul')
-                li.appendChild(ul)
-                for (const child of entry.children) {
-                    appendListEntry(child, ul)
-                }
-            }
-        }
-
-        for (const item of listEntries) {
-            appendListEntry(item, ul)
-        }
-        if (!isFlatList) {
-            editor.collapse = true
-        }
-
-        editor.appendChild(ul)
-        if (value) {
-            editor.value = value.value
-        }
-        return result
-    }
-
-    createBooleanEditor(label: string, value: Term | null, required: boolean, template: ShaclPropertyTemplate): HTMLElement {
-        const editor = new Checkbox()
-        const result = this.createDefaultTemplate('', value, required, editor, template)
-        // 'required' on checkboxes forces the user to tick the checkbox, which is not what we want here
-        editor.removeAttribute('required')
-        if (value instanceof Literal) {
-            editor.checked = value.value === 'true'
-        }
-        editor.innerText = label
-        return result
-    }
-
-    createDateEditor(_: string, value: Term | null, required: boolean, template: ShaclPropertyTemplate): HTMLElement {
-        const editor = new TextField()
-        editor.variant = 'outlined'
-        editor.helper = template?.description?.value || template?.label || ''
-        if (template.datatype?.value  === PREFIX_XSD + 'dateTime') {
-            editor.type = 'datetime-local'
-            // this enables seconds in dateTime input
-            editor.setAttribute('step', '1')
-        }
-        else {
-            editor.type = 'date'
-        }
-        editor.classList.add('pr-0')
-        // @ts-ignore
-        const result = this.createDefaultTemplate('', null, required, editor, template)
-        if (value) {
-            try {
-                let isoDate = new Date(value.value).toISOString()
-                if (template.datatype?.value  === PREFIX_XSD + 'dateTime') {
-                    isoDate = isoDate.slice(0, 19)
-                } else {
-                    isoDate = isoDate.slice(0, 10)
-                }
-                editor.value = isoDate
-            } catch(ex) {
-                console.error(ex, value)
-            }
-        }
-        return result
-    }
-
-    createLangStringEditor(label: string, value: Term | null, required: boolean, template: ShaclPropertyTemplate): HTMLElement {
-        const result = this.createTextEditor(label, value, required, template)
-        const editor = result.querySelector(':scope .editor') as Editor
-        let langChooser: HTMLSelectElement | HTMLInputElement
-        if (template.languageIn?.length) {
-            langChooser = document.createElement('select')
-            for (const lang of template.languageIn) {
-                const option = document.createElement('option')
-                option.innerText = lang.value
-                langChooser.appendChild(option)
-            }
-        } else {
-            langChooser = document.createElement('input')
-            langChooser.maxLength = 5 // e.g. en-US
-            langChooser.placeholder = 'lang?'
-        }
-        langChooser.title = 'Language of the text'
-        langChooser.classList.add('lang-chooser')
-        // if lang chooser changes, fire a change event on the text input instead. this is for shacl validation handling.
-        langChooser.addEventListener('change', (ev) => {
-            ev.stopPropagation();
-            if (editor) {
-                editor.dataset.lang = langChooser.value
-                editor.dispatchEvent(new Event('change', { bubbles: true }))
-            }
-        })
-        if (value instanceof Literal) {
-            langChooser.value = value.language
-        }
-        editor.dataset.lang = langChooser.value
-        editor.after(langChooser)
-        return result
-    }
-
-    createFileEditor(label: string, value: Term | null, required: boolean, template: ShaclPropertyTemplate): HTMLElement {
-        const editor = document.createElement('input')
-        editor.type = 'file'
-        editor.addEventListener('change', (e) => {
-            if (editor.files?.length) {
-                e.stopPropagation()
-                const reader = new FileReader()
-                reader.readAsDataURL(editor.files[0])
-                reader.onload = () => {
-                    (editor as Editor)['binaryData'] = btoa(reader.result as string)
-                    editor.parentElement?.dispatchEvent(new Event('change', { bubbles: true }))
-                }
-            } else {
-                (editor as Editor)['binaryData'] = undefined               
-            }
-        })
-        return this.createDefaultTemplate(label, value, required, editor, template)
-    }
-
-    createButton(label: string, primary: boolean): HTMLElement {
-        let button
-        if (primary) {
-            button = new Button()
-            button.classList.add('primary')
-        } else {
-            button = new Button()
-            button.classList.add('secondary')
-        }
-        button.innerHTML = label
-        return button
-    }
-}

package/src/util.ts

@@ -1,275 +0,0 @@
-import { Literal, NamedNode, Prefixes, Quad, Store } from 'n3'
-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'
-import { ShaclNode } from './node'
-
-export function findObjectValueByPredicate(quads: Quad[], predicate: string, prefix: string = PREFIX_SHACL, languages?: string[]): string {
-    let result = ''
-    const object = findObjectByPredicate(quads, predicate, prefix, languages)
-    if (object) {
-        result = object.value
-    }
-    return result
-}
-
-export function findObjectByPredicate(quads: Quad[], predicate: string, prefix: string = PREFIX_SHACL, languages?: string[]): Term | undefined {
-    let candidate: Term | undefined
-    const prefixedPredicate = prefix + predicate
-
-    if (languages?.length) {
-        for (const language of languages) {
-            for (const quad of quads) {
-                if (quad.predicate.value === prefixedPredicate) {
-                    if (quad.object.id.endsWith(`@${language}`)) {
-                        return quad.object
-                    }
-                    else if (quad.object.id.indexOf('@') < 0) {
-                        candidate = quad.object
-                    } else if (!candidate) {
-                        candidate = quad.object
-                    }
-                }
-            }
-        }
-    } else {
-        for (const quad of quads) {
-            if (quad.predicate.value === prefixedPredicate) {
-                return quad.object
-            }
-        }
-    }
-    return candidate
-}
-
-export function focusFirstInputElement(context: HTMLElement) {
-    (context.querySelector('.editor') as HTMLElement)?.focus()
-}
-
-export function findLabel(quads: Quad[], languages: string[]): string {
-    return findObjectValueByPredicate(quads, 'prefLabel', PREFIX_SKOS, languages) ||
-    findObjectValueByPredicate(quads, 'label', PREFIX_RDFS, languages) ||
-    findObjectValueByPredicate(quads, 'name', PREFIX_FOAF, languages)
-}
-
-export function createInputListEntries(subjects: Term[], shapesGraph: Store, languages: string[]): InputListEntry[] {
-    const entries: InputListEntry[] = []
-    for (const subject of subjects) {
-        entries.push({ value: subject, label: findLabel(shapesGraph.getQuads(subject, null, null, null), languages), children: [] })
-    }
-    return entries
-}
-
-export function removePrefixes(id: string, prefixes: Prefixes): string {
-    for (const key in prefixes) {
-        // need to ignore type check. 'prefix' is a string and not a NamedNode<string> (seems to be a bug in n3 typings)
-        // @ts-ignore
-        id = id.replace(prefixes[key], '')
-    }
-    return id
-}
-
-function findClassInstancesFromOwlImports(clazz: NamedNode, context: ShaclNode | ShaclPropertyTemplate, shapesGraph: Store, instances: Term[], alreadyCheckedImports = new Set<string>()) {
-    for (const owlImport of context.owlImports) {
-        if (!alreadyCheckedImports.has(owlImport.id)) {
-            alreadyCheckedImports.add(owlImport.id)
-            instances.push(...shapesGraph.getSubjects(RDF_PREDICATE_TYPE, clazz, owlImport))
-        }
-    }
-    if (context.parent) {
-        findClassInstancesFromOwlImports(clazz, context.parent, shapesGraph, instances, alreadyCheckedImports)
-    }
-}
-
-export function findInstancesOf(clazz: NamedNode, template: ShaclPropertyTemplate): InputListEntry[] {
-    // if template has sh:in, then just use that as class instances
-    if (template.shaclIn) {
-        const list = template.config.lists[template.shaclIn]
-        return createInputListEntries(list?.length ? list : [], template.config.store, template.config.languages)
-    } else {
-        // find instances in the shapes graph
-        const instances = template.config.store.getSubjects(RDF_PREDICATE_TYPE, clazz, SHAPES_GRAPH)
-        // find instances in the data graph
-        instances.push(...template.config.store.getSubjects(RDF_PREDICATE_TYPE, clazz, DATA_GRAPH))
-        // find instances in imported taxonomies
-        findClassInstancesFromOwlImports(clazz, template, template.config.store, instances)
-
-        // initialize structures needed for building a class instance hierarchy
-        const nodes = new Map<string, InputListEntry>()   // URI -> InputListEntry
-        const childToParent = new Map<string, string>() // URI -> parentURI
-
-        // initialize all instances as InputListEntry's with no children
-        for (const instance of instances) {
-            nodes.set(instance.id, { value: instance, label: findLabel(template.config.store.getQuads(instance, null, null, null), template.config.languages), children: [] })
-        }
-
-        // record broader/narrower/subClassOf hierarchical relationships
-        for (const instance of instances) {
-            for (const parent of template.config.store.getObjects(instance, SKOS_PREDICATE_BROADER, null)) {
-                if (nodes.has(parent.id)) {
-                    childToParent.set(instance.id, parent.id)
-                }
-            }
-            for (const child of template.config.store.getObjects(instance, SKOS_PREDICATE_NARROWER, null)) {
-                if (nodes.has(child.id)) {
-                    childToParent.set(child.id, instance.id)
-                }
-            }
-            for (const parent of template.config.store.getObjects(instance, RDFS_PREDICATE_SUBCLASS_OF, null)) {
-                if (nodes.has(parent.id)) {
-                    childToParent.set(instance.id, parent.id)
-                }
-            }
-        }
-
-        // build hierarchy by nesting children under parents
-        for (const [child, parent] of childToParent.entries()) {
-            nodes.get(parent)?.children?.push(nodes.get(child)!)
-        }
-
-        // find root nodes (no parent relationship)
-        const roots: InputListEntry[] = []
-        for (const [uri, node] of nodes.entries()) {
-            if (!childToParent.has(uri)) {
-                roots.push(node)
-            }
-        }
-
-        // add sub class instances
-        for (const subClass of template.config.store.getSubjects(RDFS_PREDICATE_SUBCLASS_OF, clazz, null)) {
-            roots.push(...findInstancesOf(subClass as NamedNode, template))
-        }
-        return roots
-    }
-}
-
-export function isURL(input: string): boolean {
-    let url: URL
-    try {
-        url = new URL(input)
-    } catch (_) {
-        return false
-    }
-    return url.protocol === 'http:' || url.protocol === 'https:'
-}
-
-export function prioritizeByLanguage(languages: string[], text1?: Literal, text2?: Literal): Literal | undefined {
-    if (text1 === undefined) {
-        return text2
-    }
-    if (text2 === undefined) {
-        return text1
-    }
-    const index1 = languages.indexOf(text1.language)
-    if (index1 < 0) {
-        return text2
-    }
-    const index2 = languages.indexOf(text2.language)
-    if (index2 < 0) {
-        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
-  }