@oml/language 0.9.0 → 0.11.0

package/out/oml/oml-edit.js

@@ -1,7 +1,7 @@
 // Copyright (c) 2026 Modelware. All rights reserved.
-import { URI } from 'langium';
+import { DocumentState, URI } from 'langium';
 import { RequestType } from 'vscode-languageserver-protocol';
-import { isAnnotation, isConceptInstance, isDescription, isImport, isOntology, isPropertyValueAssertion, isRelationInstance, isRule, isTypeAssertion, } from './generated/ast.js';
+import { isAnnotation, isConceptInstance, isDescription, isDescriptionBox, isImport, isOntology, isPropertyValueAssertion, isRelationInstance, isRule, isTypeAssertion, isVocabulary, isVocabularyBundle, } from './generated/ast.js';
 import { getOntologyModelIndex } from './oml-index.js';
 import { serializeOntology } from './oml-serializer.js';
 import { collectOntologyMembers, findOntologyMemberByName, getIriForNode, normalizeNamespace, } from './oml-utils.js';
@@ -58,7 +58,12 @@ async function resolveOntologyContext(shared, ontologyIri, cache) {
     const builder = shared.workspace.DocumentBuilder;
     const document = langiumDocuments.getDocument(uri)
         ?? await langiumDocuments.getOrCreateDocument(uri);
-    await builder.build([document], { validation: true });
+    // Only build if not yet Linked. Forcing validation:true when the workspace
+    // is already Validated causes a document-state conflict in Langium on Windows.
+    const docState = document?.state;
+    if (docState === undefined || docState < DocumentState.Linked) {
+        await builder.build([document], { validation: false });
+    }
     const ontology = document?.parseResult?.value;
     if (!ontology || !isOntology(ontology)) {
         throw new Error(`Resolved document '${modelUri}' is not an ontology.`);
@@ -85,8 +90,7 @@ async function executeOperation(shared, context, operation, contexts) {
                     ownedPropertyValues: [],
                     ownedTypes: []
                 };
-                statement.$container = context.ontology;
-                context.ontology.ownedStatements.push(statement);
+                pushAstArrayChild(context.ontology, 'ownedStatements', statement);
             }
             return new Set([context.ontologyIri]);
         case 'createRelationInstance':
@@ -102,15 +106,14 @@ async function executeOperation(shared, context, operation, contexts) {
                     sources: [],
                     targets: []
                 };
-                statement.$container = context.ontology;
-                context.ontology.ownedStatements.push(statement);
+                pushAstArrayChild(context.ontology, 'ownedStatements', statement);
             }
             return new Set([context.ontologyIri]);
         case 'createInstanceRef':
             ensureDescriptionOntology(context.ontology, operation.kind);
-            ensureReferenceImport(context.ontology, operation.instanceIri);
+            await ensureReferenceImport(shared, context.ontology, operation.instanceIri);
             if (operation.typeIri) {
-                ensureReferenceImport(context.ontology, operation.typeIri);
+                await ensureReferenceImport(shared, context.ontology, operation.typeIri);
             }
             {
                 const ownedTypes = [];
@@ -128,15 +131,17 @@ async function executeOperation(shared, context, operation, contexts) {
                     ownedTypes
                 };
                 statement.__targetIri = normalizeIri(operation.instanceIri);
-                statement.$container = context.ontology;
-                context.ontology.ownedStatements.push(statement);
+                pushAstArrayChild(context.ontology, 'ownedStatements', statement);
+                for (const typeAssertion of ownedTypes) {
+                    attachAstNode(typeAssertion, statement, 'ownedTypes');
+                }
             }
             return new Set([context.ontologyIri]);
         case 'createRelationInstanceRef':
             ensureDescriptionOntology(context.ontology, operation.kind);
-            ensureReferenceImport(context.ontology, operation.instanceIri);
+            await ensureReferenceImport(shared, context.ontology, operation.instanceIri);
             if (operation.typeIri) {
-                ensureReferenceImport(context.ontology, operation.typeIri);
+                await ensureReferenceImport(shared, context.ontology, operation.typeIri);
             }
             {
                 const ownedTypes = [];
@@ -156,13 +161,20 @@ async function executeOperation(shared, context, operation, contexts) {
                     targets: []
                 };
                 statement.__targetIri = normalizeIri(operation.instanceIri);
-                statement.$container = context.ontology;
-                context.ontology.ownedStatements.push(statement);
+                pushAstArrayChild(context.ontology, 'ownedStatements', statement);
+                for (const typeAssertion of ownedTypes) {
+                    attachAstNode(typeAssertion, statement, 'ownedTypes');
+                }
             }
             return new Set([context.ontologyIri]);
         case 'addAssertion':
             ensureDescriptionOntology(context.ontology, operation.kind);
-            return addAssertion(context.ontology, operation.subjectIri, operation.predicateIri, operation.object)
+            return await addAssertion(shared, context.ontology, operation.subjectIri, operation.predicateIri, operation.object)
+                ? new Set([context.ontologyIri])
+                : new Set();
+        case 'updateAssertion':
+            ensureDescriptionOntology(context.ontology, operation.kind);
+            return await updateAssertion(shared, context.ontology, operation.subjectIri, operation.predicateIri, operation.object)
                 ? new Set([context.ontologyIri])
                 : new Set();
         case 'removeAssertion':
@@ -171,7 +183,11 @@ async function executeOperation(shared, context, operation, contexts) {
                 ? new Set([context.ontologyIri])
                 : new Set();
         case 'addAnnotation':
-            return addAnnotation(context.ontology, operation.subjectIri, operation.predicateIri, operation.object)
+            return await addAnnotation(shared, context.ontology, operation.subjectIri, operation.predicateIri, operation.object)
+                ? new Set([context.ontologyIri])
+                : new Set();
+        case 'updateAnnotation':
+            return await updateAnnotation(shared, context.ontology, operation.subjectIri, operation.predicateIri, operation.object)
                 ? new Set([context.ontologyIri])
                 : new Set();
         case 'removeAnnotation':
@@ -200,7 +216,10 @@ async function resolveOntologyContextByModelUri(shared, modelUri, cache) {
     const builder = shared.workspace.DocumentBuilder;
     const document = langiumDocuments.getDocument(uri)
         ?? await langiumDocuments.getOrCreateDocument(uri);
-    await builder.build([document], { validation: true });
+    const docState2 = document?.state;
+    if (docState2 === undefined || docState2 < DocumentState.Linked) {
+        await builder.build([document], { validation: false });
+    }
     const ontology = document?.parseResult?.value;
     if (!ontology || !isOntology(ontology)) {
         throw new Error(`Resolved document '${modelUri}' is not an ontology.`);
@@ -225,7 +244,7 @@ function ensureUniqueLocalName(ontology, memberName) {
         throw new Error(`A member named '${memberName}' already exists in the ontology.`);
     }
 }
-function addAssertion(ontology, subjectIri, predicateIri, objectValue) {
+async function addAssertion(shared, ontology, subjectIri, predicateIri, objectValue) {
     const normalizedPredicate = normalizeIri(predicateIri);
     const subject = findNamedInstanceByIri(ontology, subjectIri);
     if (!subject) {
@@ -236,9 +255,9 @@ function addAssertion(ontology, subjectIri, predicateIri, objectValue) {
         if ((subject.ownedTypes ?? []).some((entry) => matchesPredicateRef(ontology, entry?.type, normalizedTypeIri))) {
             return false;
         }
-        ensureReferenceImport(ontology, normalizedTypeIri);
+        await ensureReferenceImport(shared, ontology, normalizedTypeIri);
         subject.ownedTypes ?? (subject.ownedTypes = []);
-        subject.ownedTypes.push({
+        pushAstArrayChild(subject, 'ownedTypes', {
             $type: 'TypeAssertion',
             type: asRef(ontology, normalizedTypeIri)
         });
@@ -249,7 +268,7 @@ function addAssertion(ontology, subjectIri, predicateIri, objectValue) {
             throw new Error(`Predicate '${predicateIri}' applies only to relation instances.`);
         }
         const sourceIri = normalizeIri(asRequiredIri(objectValue, 'source assertion object'));
-        ensureReferenceImport(ontology, sourceIri);
+        await ensureReferenceImport(shared, ontology, sourceIri);
         subject.sources ?? (subject.sources = []);
         subject.sources.push(asRef(ontology, sourceIri));
         return true;
@@ -259,7 +278,7 @@ function addAssertion(ontology, subjectIri, predicateIri, objectValue) {
             throw new Error(`Predicate '${predicateIri}' applies only to relation instances.`);
         }
         const targetIri = normalizeIri(asRequiredIri(objectValue, 'target assertion object'));
-        ensureReferenceImport(ontology, targetIri);
+        await ensureReferenceImport(shared, ontology, targetIri);
         subject.targets ?? (subject.targets = []);
         subject.targets.push(asRef(ontology, targetIri));
         return true;
@@ -267,6 +286,7 @@ function addAssertion(ontology, subjectIri, predicateIri, objectValue) {
     subject.ownedPropertyValues ?? (subject.ownedPropertyValues = []);
     let propertyAssertion = subject.ownedPropertyValues.find((assertion) => matchesPredicateRef(ontology, assertion?.property, normalizedPredicate));
     if (!propertyAssertion) {
+        await ensureReferenceImport(shared, ontology, normalizedPredicate);
         propertyAssertion = {
             $type: 'PropertyValueAssertion',
             property: asRef(ontology, normalizedPredicate),
@@ -274,7 +294,13 @@ function addAssertion(ontology, subjectIri, predicateIri, objectValue) {
             referencedValues: [],
             containedValues: []
         };
-        subject.ownedPropertyValues.push(propertyAssertion);
+        pushAstArrayChild(subject, 'ownedPropertyValues', propertyAssertion);
+    }
+    if (isIriLike(objectValue)) {
+        await ensureReferenceImport(shared, ontology, normalizeIri(asRequiredIri(objectValue, 'assertion object')));
+    }
+    else {
+        await ensureTypedLiteralDatatypeImport(shared, ontology, objectValue);
     }
     appendAssertionValue(ontology, propertyAssertion, objectValue);
     return true;
@@ -367,20 +393,56 @@ function removeAssertion(ontology, subjectIri, predicateIri, objectValue) {
     subject.ownedPropertyValues = remaining;
     return changed;
 }
-function addAnnotation(ontology, subjectIri, predicateIri, objectValue) {
+async function updateAssertion(shared, ontology, subjectIri, predicateIri, objectValue) {
+    const normalizedPredicate = normalizeIri(predicateIri);
+    const subject = findNamedInstanceByIri(ontology, subjectIri);
+    if (!subject) {
+        throw new Error(`Subject '${subjectIri}' was not found in the ontology.`);
+    }
+    if (normalizedPredicate === RDF_TYPE_IRI || isSourcePredicate(normalizedPredicate) || isTargetPredicate(normalizedPredicate)) {
+        const removed = removeAssertion(ontology, subjectIri, predicateIri, undefined);
+        const added = await addAssertion(shared, ontology, subjectIri, predicateIri, objectValue);
+        return removed || added;
+    }
+    subject.ownedPropertyValues ?? (subject.ownedPropertyValues = []);
+    let propertyAssertion = subject.ownedPropertyValues.find((assertion) => matchesPredicateRef(ontology, assertion?.property, normalizedPredicate));
+    if (!propertyAssertion) {
+        return addAssertion(shared, ontology, subjectIri, predicateIri, objectValue);
+    }
+    if (isIriLike(objectValue)) {
+        await ensureReferenceImport(shared, ontology, normalizeIri(asRequiredIri(objectValue, 'assertion object')));
+    }
+    else {
+        await ensureTypedLiteralDatatypeImport(shared, ontology, objectValue);
+    }
+    propertyAssertion.literalValues = [];
+    propertyAssertion.referencedValues = [];
+    propertyAssertion.containedValues = [];
+    appendAssertionValue(ontology, propertyAssertion, objectValue);
+    return true;
+}
+async function addAnnotation(shared, ontology, subjectIri, predicateIri, objectValue) {
     const subject = findAnnotationSubjectByIri(ontology, subjectIri);
     if (!subject) {
         throw new Error(`Annotation subject '${subjectIri}' was not found in the ontology.`);
     }
+    const normalizedPredicate = normalizeIri(predicateIri);
+    await ensureReferenceImport(shared, ontology, normalizedPredicate);
     subject.ownedAnnotations ?? (subject.ownedAnnotations = []);
     const annotation = {
         $type: 'Annotation',
-        property: asRef(ontology, predicateIri),
+        property: asRef(ontology, normalizedPredicate),
         literalValues: [],
         referencedValues: []
     };
+    if (isIriLike(objectValue)) {
+        await ensureReferenceImport(shared, ontology, normalizeIri(asRequiredIri(objectValue, 'annotation object')));
+    }
+    else {
+        await ensureTypedLiteralDatatypeImport(shared, ontology, objectValue);
+    }
     appendAnnotationValue(ontology, annotation, objectValue);
-    subject.ownedAnnotations.push(annotation);
+    pushAstArrayChild(subject, 'ownedAnnotations', annotation);
     return true;
 }
 function removeAnnotation(ontology, subjectIri, predicateIri, objectValue) {
@@ -420,6 +482,28 @@ function removeAnnotation(ontology, subjectIri, predicateIri, objectValue) {
     subject.ownedAnnotations = kept;
     return changed;
 }
+async function updateAnnotation(shared, ontology, subjectIri, predicateIri, objectValue) {
+    const subject = findAnnotationSubjectByIri(ontology, subjectIri);
+    if (!subject) {
+        throw new Error(`Annotation subject '${subjectIri}' was not found in the ontology.`);
+    }
+    const normalizedPredicate = normalizeIri(predicateIri);
+    subject.ownedAnnotations ?? (subject.ownedAnnotations = []);
+    const annotation = subject.ownedAnnotations.find((entry) => matchesPredicateRef(ontology, entry?.property, normalizedPredicate));
+    if (!annotation) {
+        return addAnnotation(shared, ontology, subjectIri, predicateIri, objectValue);
+    }
+    if (isIriLike(objectValue)) {
+        await ensureReferenceImport(shared, ontology, normalizeIri(asRequiredIri(objectValue, 'annotation object')));
+    }
+    else {
+        await ensureTypedLiteralDatatypeImport(shared, ontology, objectValue);
+    }
+    annotation.literalValues = [];
+    annotation.referencedValues = [];
+    appendAnnotationValue(ontology, annotation, objectValue);
+    return true;
+}
 function deleteMemberRef(ontology, memberIri, typeIri) {
     if (!Array.isArray(ontology.ownedStatements)) {
         return false;
@@ -718,9 +802,7 @@ function matchesPredicateRef(ontology, ref, iri) {
         return false;
     }
     const normalizedWanted = normalizeIri(iri);
-    const refText = typeof ref === 'string'
-        ? ref
-        : (typeof ref.$refText === 'string' ? ref.$refText : undefined);
+    const refText = getRefText(ref);
     if (refText) {
         const normalizedRefText = normalizeIri(expandRefTextToIri(ontology, refText) ?? refText);
         if (isSameIriTarget(normalizedRefText, normalizedWanted)) {
@@ -734,13 +816,12 @@ function matchesPredicateRef(ontology, ref, iri) {
 function appendAssertionValue(ontology, assertion, objectValue) {
     if (isIriLike(objectValue)) {
         const normalizedObjectIri = normalizeIri(asRequiredIri(objectValue, 'assertion object'));
-        ensureReferenceImport(ontology, normalizedObjectIri);
         assertion.referencedValues ?? (assertion.referencedValues = []);
         assertion.referencedValues.push(asRef(ontology, normalizedObjectIri));
         return;
     }
     assertion.literalValues ?? (assertion.literalValues = []);
-    assertion.literalValues.push(asLiteral(objectValue));
+    pushAstArrayChild(assertion, 'literalValues', asLiteral(ontology, objectValue));
 }
 function removeAssertionValue(ontology, assertion, objectValue) {
     if (isIriLike(objectValue)) {
@@ -748,19 +829,18 @@ function removeAssertionValue(ontology, assertion, objectValue) {
         assertion.referencedValues = (assertion.referencedValues ?? []).filter((ref) => !matchesPredicateRef(ontology, ref, normalizedIri));
         return;
     }
-    const normalizedLiteral = normalizeLiteralValue(asLiteral(objectValue));
+    const normalizedLiteral = normalizeLiteralValue(asLiteral(ontology, objectValue));
     assertion.literalValues = (assertion.literalValues ?? []).filter((literal) => normalizeLiteralValue(literal) !== normalizedLiteral);
 }
 function appendAnnotationValue(ontology, annotation, objectValue) {
     if (isIriLike(objectValue)) {
         const normalizedObjectIri = normalizeIri(asRequiredIri(objectValue, 'annotation object'));
-        ensureReferenceImport(ontology, normalizedObjectIri);
         annotation.referencedValues ?? (annotation.referencedValues = []);
         annotation.referencedValues.push(asRef(ontology, normalizedObjectIri));
         return;
     }
     annotation.literalValues ?? (annotation.literalValues = []);
-    annotation.literalValues.push(asLiteral(objectValue));
+    pushAstArrayChild(annotation, 'literalValues', asLiteral(ontology, objectValue));
 }
 function removeAnnotationValue(ontology, annotation, objectValue) {
     if (isIriLike(objectValue)) {
@@ -768,7 +848,7 @@ function removeAnnotationValue(ontology, annotation, objectValue) {
         annotation.referencedValues = (annotation.referencedValues ?? []).filter((ref) => !matchesPredicateRef(ontology, ref, normalizedIri));
         return;
     }
-    const normalizedLiteral = normalizeLiteralValue(asLiteral(objectValue));
+    const normalizedLiteral = normalizeLiteralValue(asLiteral(ontology, objectValue));
     annotation.literalValues = (annotation.literalValues ?? []).filter((literal) => normalizeLiteralValue(literal) !== normalizedLiteral);
 }
 function normalizeLiteralValue(literal) {
@@ -893,7 +973,7 @@ function expandLocalRefText(rawNamespace, localName) {
     }
     return `${namespace}#${local}`;
 }
-function ensureReferenceImport(ontology, iri) {
+async function ensureReferenceImport(shared, ontology, iri) {
     const target = parseIriParts(iri);
     if (!target) {
         return;
@@ -923,17 +1003,53 @@ function ensureReferenceImport(ontology, iri) {
     }
     const prefix = pickImportPrefix(target.namespace, usedPrefixes);
     const importedRef = `<${target.namespace}${target.separator}>`;
+    const importKind = await resolveImportKind(shared, ontology, target.namespace);
     const importStatement = {
         $type: 'Import',
-        kind: 'extends',
+        kind: importKind,
         prefix,
         imported: { $refText: importedRef }
     };
-    importStatement.$container = ontology;
-    if (!Array.isArray(ontology.ownedImports)) {
-        ontology.ownedImports = [];
+    pushAstArrayChild(ontology, 'ownedImports', importStatement);
+}
+async function resolveImportKind(shared, importing, importedNamespace) {
+    const imported = await findOntologyByNamespace(shared, importedNamespace);
+    if (imported) {
+        if (importing.$type === imported.$type) {
+            return 'extends';
+        }
+        if (isVocabulary(importing) && isDescription(imported)) {
+            return 'uses';
+        }
+        if (isDescriptionBox(importing) && isVocabulary(imported)) {
+            return 'uses';
+        }
+        if (isVocabularyBundle(importing) && isVocabulary(imported)) {
+            return 'includes';
+        }
+    }
+    if (isVocabularyBundle(importing)) {
+        return 'includes';
+    }
+    if (isDescriptionBox(importing)) {
+        return 'uses';
     }
-    ontology.ownedImports.push(importStatement);
+    return 'extends';
+}
+async function findOntologyByNamespace(shared, namespace) {
+    const index = getOntologyModelIndex(shared);
+    const modelUri = index.resolveModelUri(normalizeNamespace(namespace));
+    if (!modelUri) {
+        return undefined;
+    }
+    const uri = URI.parse(modelUri);
+    const langiumDocuments = shared.workspace.LangiumDocuments;
+    const builder = shared.workspace.DocumentBuilder;
+    const document = langiumDocuments.getDocument(uri)
+        ?? await langiumDocuments.getOrCreateDocument(uri);
+    await builder.build([document], { validation: false });
+    const ontology = document?.parseResult?.value;
+    return ontology && isOntology(ontology) ? ontology : undefined;
 }
 function parseIriParts(iri) {
     const normalized = normalizeIri(iri);
@@ -1070,7 +1186,17 @@ function pickImportPrefix(namespace, usedPrefixes) {
     }
     return `${candidateBase}${suffix}`;
 }
-function asLiteral(value) {
+function asLiteral(ontology, value) {
+    if (isTypedQuotedLiteralTransport(value)) {
+        const literalValue = String(value.value ?? '');
+        const datatypeIri = typeof value.datatypeIri === 'string' ? value.datatypeIri.trim() : '';
+        const datatypeRefText = typeof value.datatypeRefText === 'string' ? value.datatypeRefText.trim() : '';
+        return datatypeIri
+            ? { $type: 'QuotedLiteral', value: literalValue, type: { $refText: toRefText(ontology, normalizeIri(datatypeIri)) } }
+            : datatypeRefText
+                ? { $type: 'QuotedLiteral', value: literalValue, type: { $refText: datatypeRefText } }
+                : { $type: 'QuotedLiteral', value: literalValue };
+    }
     if (typeof value === 'boolean') {
         return { $type: 'BooleanLiteral', value };
     }
@@ -1082,6 +1208,38 @@ function asLiteral(value) {
     }
     return { $type: 'QuotedLiteral', value: String(value ?? '') };
 }
+async function ensureTypedLiteralDatatypeImport(shared, ontology, value) {
+    if (!isTypedQuotedLiteralTransport(value)) {
+        return;
+    }
+    const datatypeIri = typeof value.datatypeIri === 'string' ? normalizeIri(value.datatypeIri) : '';
+    if (!datatypeIri) {
+        return;
+    }
+    await ensureReferenceImport(shared, ontology, datatypeIri);
+}
+function isTypedQuotedLiteralTransport(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+    const record = value;
+    if (record.$type === 'QuotedLiteral') {
+        return true;
+    }
+    return (typeof record.datatypeIri === 'string' || typeof record.datatypeRefText === 'string') && 'value' in record;
+}
+function attachAstNode(node, parent, containerProperty) {
+    node.$container = parent;
+    node.$containerProperty = containerProperty;
+    return node;
+}
+function pushAstArrayChild(parent, property, node) {
+    if (!Array.isArray(parent[property])) {
+        parent[property] = [];
+    }
+    attachAstNode(node, parent, property);
+    parent[property].push(node);
+}
 function asRequiredIri(value, context) {
     if (!isIriLike(value)) {
         throw new Error(`Expected IRI for ${context}.`);