@oml/owl 0.16.6 → 0.18.0

package/src/owl/owl-tbox.ts

@@ -52,6 +52,11 @@ const OML = {
     hasTarget: namedNode('http://opencaesar.io/oml#hasTarget'),
 };
 
+export interface HasValueRestriction {
+    property: string;
+    value: { kind: 'named'; iri: string } | { kind: 'literal'; value: string; datatype: string; language: string };
+}
+
 export interface TBoxIndex {
     superClasses: Map<string, string[]>;
     subProperties: Map<string, string[]>;
@@ -64,6 +69,7 @@ export interface TBoxIndex {
     transitiveProperties: Set<string>;
     functionalProperties: Set<string>;
     inverseFunctionalProperties: Set<string>;
+    hasValueRestrictions: Map<string, HasValueRestriction[]>;
 }
 
 export interface ForwardRuleDefinition {
@@ -152,6 +158,42 @@ export class TBoxIndexBuilder {
             }
         }
 
+        // cls-hv1: collect owl:hasValue restrictions from blank node restriction nodes.
+        // Pattern: C rdfs:subClassOf _:r, _:r owl:onProperty P, _:r owl:hasValue V
+        const bnodeProperty = new Map<string, string>();
+        const bnodeValue = new Map<string, HasValueRestriction['value']>();
+        const classToRestrictionBnodes = new Map<string, string[]>();
+        for (const q of quads) {
+            if (q.subject.termType === 'BlankNode') {
+                if (q.predicate.value === 'http://www.w3.org/2002/07/owl#onProperty' && q.object.termType === 'NamedNode') {
+                    bnodeProperty.set(q.subject.value, q.object.value);
+                } else if (q.predicate.value === 'http://www.w3.org/2002/07/owl#hasValue') {
+                    if (q.object.termType === 'NamedNode') {
+                        bnodeValue.set(q.subject.value, { kind: 'named', iri: q.object.value });
+                    } else if (q.object.termType === 'Literal') {
+                        bnodeValue.set(q.subject.value, { kind: 'literal', value: q.object.value, datatype: q.object.datatype?.value ?? '', language: q.object.language ?? '' });
+                    }
+                }
+            } else if (q.subject.termType === 'NamedNode' && q.predicate.value === RDFS.subClassOf.value && q.object.termType === 'BlankNode') {
+                const list = classToRestrictionBnodes.get(q.subject.value) ?? [];
+                list.push(q.object.value);
+                classToRestrictionBnodes.set(q.subject.value, list);
+            }
+        }
+        for (const [classIri, bnodeIds] of classToRestrictionBnodes) {
+            for (const bnodeId of bnodeIds) {
+                const property = bnodeProperty.get(bnodeId);
+                const value = bnodeValue.get(bnodeId);
+                if (property && value) {
+                    const list = index.hasValueRestrictions.get(classIri) ?? [];
+                    if (!list.some((r) => r.property === property && this.sameHasValue(r.value, value))) {
+                        list.push({ property, value });
+                        index.hasValueRestrictions.set(classIri, list);
+                    }
+                }
+            }
+        }
+
         if (ontology && isVocabulary(ontology)) {
             index.forwardRules.push(...this.buildForwardRules(ontology));
         }
@@ -189,6 +231,7 @@ export class TBoxIndexBuilder {
             this.mergeSet(merged.transitiveProperties, own.transitiveProperties);
             this.mergeSet(merged.functionalProperties, own.functionalProperties);
             this.mergeSet(merged.inverseFunctionalProperties, own.inverseFunctionalProperties);
+            this.mergeHasValueRestrictions(merged.hasValueRestrictions, own.hasValueRestrictions);
         }
 
         this.closeSuperClassesTransitively(merged.superClasses);
@@ -224,9 +267,23 @@ export class TBoxIndexBuilder {
             transitiveProperties: new Set<string>(),
             functionalProperties: new Set<string>(),
             inverseFunctionalProperties: new Set<string>(),
+            hasValueRestrictions: new Map<string, HasValueRestriction[]>(),
         };
     }
 
+    private sameHasValue(a: HasValueRestriction['value'], b: HasValueRestriction['value']): boolean {
+        if (a.kind !== b.kind) {
+            return false;
+        }
+        if (a.kind === 'named' && b.kind === 'named') {
+            return a.iri === b.iri;
+        }
+        if (a.kind === 'literal' && b.kind === 'literal') {
+            return a.value === b.value && a.datatype === b.datatype && a.language === b.language;
+        }
+        return false;
+    }
+
     private mergeStringArrayMap(target: Map<string, string[]>, source: Map<string, string[]>): void {
         for (const [key, values] of source.entries()) {
             const existing = target.get(key) ?? [];
@@ -245,6 +302,18 @@ export class TBoxIndexBuilder {
         }
     }
 
+    private mergeHasValueRestrictions(target: Map<string, HasValueRestriction[]>, source: Map<string, HasValueRestriction[]>): void {
+        for (const [classIri, restrictions] of source.entries()) {
+            const existing = target.get(classIri) ?? [];
+            for (const r of restrictions) {
+                if (!existing.some((e) => e.property === r.property && this.sameHasValue(e.value, r.value))) {
+                    existing.push(r);
+                }
+            }
+            target.set(classIri, existing);
+        }
+    }
+
     private mergeForwardRules(target: ForwardRuleDefinition[], source: ForwardRuleDefinition[]): void {
         const merged = new Map<string, ForwardRuleDefinition>();
         for (const rule of target) {
@@ -393,7 +462,10 @@ export class TBoxIndexBuilder {
             return { kind: 'literal', value: String(literalValue.value), datatype: 'http://www.w3.org/2001/XMLSchema#decimal', language: '' };
         }
         if (isDoubleLiteral(literalValue)) {
-            return { kind: 'literal', value: String(literalValue.value), datatype: 'http://www.w3.org/2001/XMLSchema#double', language: '' };
+            const v = literalValue.value;
+            const doubleStr = typeof v === 'string' ? v
+                : Number.isInteger(v as number) ? `${v}.0e0` : `${v}e0`;
+            return { kind: 'literal', value: doubleStr, datatype: 'http://www.w3.org/2001/XMLSchema#double', language: '' };
         }
         if (isQuotedLiteral(literalValue)) {
             if (literalValue.type) {