@oml/language 0.18.0 → 0.19.0

package/src/oml/oml-index.ts

@@ -2,11 +2,23 @@
 
 import { DocumentState, URI, type LangiumDocument } from 'langium';
 import type { LangiumSharedServices } from 'langium/lsp';
-import { isAspect, isConcept, isConceptInstance, isDescription, isOntology, isRelationEntity, isRelationInstance, isScalar } from './generated/ast.js';
+import { isAspect, isConcept, isConceptInstance, isDescription, isOntology, isRelationEntity, isRelationInstance, isScalar, isUnit } from './generated/ast.js';
 import { collectOntologyMembers, getIriForNode, getSourceLocation, type SourceLocation } from './oml-utils.js';
 
 const OML_LABEL_IRI = 'http://opencaesar.io/oml#label';
 
+function ontologyIriFromMemberIri(memberIri: string): string | undefined {
+    const hash = memberIri.lastIndexOf('#');
+    if (hash >= 0) {
+        return memberIri.slice(0, hash);
+    }
+    const slash = memberIri.lastIndexOf('/');
+    if (slash >= 0) {
+        return memberIri.slice(0, slash);
+    }
+    return undefined;
+}
+
 const ontologyIndexByShared = new WeakMap<object, OmlIndex>();
 
 export interface OmlIndexedInstance {
@@ -20,6 +32,28 @@ export interface OmlIndexedInstance {
     location?: SourceLocation;
 }
 
+export interface OmlIndexedUnit {
+    unitIri: string;
+    symbol: string;
+    kindIris: string[];
+    ontologyIri: string;
+    modelUri: string;
+}
+
+export type OmlClassKind = 'aspect' | 'concept' | 'relationEntity';
+
+export interface OmlIndexedClass {
+    classIri: string;
+    kind: OmlClassKind;
+    name?: string;
+    label?: string;
+    prefix?: string;
+    ontologyIri: string;
+    modelUri: string;
+    superIris: string[];
+    location?: SourceLocation;
+}
+
 export function getOntologyModelIndex(shared: LangiumSharedServices): OmlIndex {
     const key = shared as object;
     const existing = ontologyIndexByShared.get(key);
@@ -34,6 +68,7 @@ export function getOntologyModelIndex(shared: LangiumSharedServices): OmlIndex {
 export class OmlIndex {
     private readonly workspaceModelUrisByOntologyIri = new Map<string, Set<string>>();
     private readonly workspaceNamespaceByModelUri = new Map<string, string>();
+    private readonly prefixByOntologyIri = new Map<string, string>();
     private readonly memberLabelByIri = new Map<string, string>();
     private readonly labeledMemberIrisByModelUri = new Map<string, Set<string>>();
     private readonly instanceIrisByTypeIri = new Map<string, Set<string>>();
@@ -42,6 +77,11 @@ export class OmlIndex {
     private readonly indexedInstanceIrisByModelUri = new Map<string, Set<string>>();
     private readonly subTypeIrisByTypeIri = new Map<string, Set<string>>();
     private readonly typeSuperIrisByModelUri = new Map<string, Map<string, Set<string>>>();
+    private readonly unitIrisBySymbol = new Map<string, Set<string>>();
+    private readonly indexedUnitsByIri = new Map<string, OmlIndexedUnit>();
+    private readonly unitIrisByModelUri = new Map<string, Set<string>>();
+    private readonly indexedClassesByIri = new Map<string, OmlIndexedClass>();
+    private readonly classIrisByModelUri = new Map<string, Set<string>>();
 
     constructor(private readonly shared: LangiumSharedServices) {
         this.shared.workspace.DocumentBuilder.onUpdate((_changed, deleted) => {
@@ -246,6 +286,8 @@ export class OmlIndex {
         this.removeTypesForModelUri(modelUri);
         this.removeIndexedInstancesForModelUri(modelUri);
         this.removeTypeHierarchyForModelUri(modelUri);
+        this.removeUnitsForModelUri(modelUri);
+        this.removeIndexedClassesForModelUri(modelUri);
         this.unindexModelUri(modelUri);
     }
 
@@ -275,6 +317,23 @@ export class OmlIndex {
         modelUris.add(modelUri);
         this.workspaceModelUrisByOntologyIri.set(ontologyIri, modelUris);
         this.workspaceNamespaceByModelUri.set(modelUri, namespace);
+        const prefix = this.getPrefix(document);
+        if (prefix) {
+            this.prefixByOntologyIri.set(ontologyIri, prefix);
+        }
+    }
+
+    getPrefixForOntologyIri(ontologyIri: string): string | undefined {
+        this.ensureIndexedFromLoadedDocuments();
+        return this.prefixByOntologyIri.get(ontologyIri);
+    }
+
+    getPrefixForMemberIri(memberIri: string): string | undefined {
+        const normalized = this.normalizeIri(memberIri);
+        if (!normalized) return undefined;
+        const ontologyIri = ontologyIriFromMemberIri(normalized);
+        if (!ontologyIri) return undefined;
+        return this.getPrefixForOntologyIri(ontologyIri);
     }
 
     private indexLinkedDocument(document: LangiumDocument): void {
@@ -283,12 +342,16 @@ export class OmlIndex {
         this.removeTypesForModelUri(modelUri);
         this.removeIndexedInstancesForModelUri(modelUri);
         this.removeTypeHierarchyForModelUri(modelUri);
+        this.removeUnitsForModelUri(modelUri);
+        this.removeIndexedClassesForModelUri(modelUri);
         const root = document.parseResult?.value;
         if (!isOntology(root)) {
             return;
         }
 
         this.indexTypeHierarchy(root as any, modelUri);
+        this.indexUnits(root as any, modelUri);
+        this.indexClasses(root as any, modelUri);
 
         if (!isDescription(root)) {
             return;
@@ -354,6 +417,141 @@ export class OmlIndex {
         }
     }
 
+    getUnitsBySymbol(symbol: string): OmlIndexedUnit[] {
+        this.ensureIndexedFromLoadedDocuments();
+        const iris = this.unitIrisBySymbol.get(symbol);
+        if (!iris) return [];
+        const results: OmlIndexedUnit[] = [];
+        for (const iri of iris) {
+            const entry = this.indexedUnitsByIri.get(iri);
+            if (entry) results.push(entry);
+        }
+        return results;
+    }
+
+    getAllUnits(): OmlIndexedUnit[] {
+        this.ensureIndexedFromLoadedDocuments();
+        return [...this.indexedUnitsByIri.values()];
+    }
+
+    private indexUnits(root: any, modelUri: string): void {
+        const ontologyIri = this.resolveOntologyIri(modelUri) ?? '';
+        const modelUnitIris = new Set<string>();
+        for (const member of collectOntologyMembers(root as any)) {
+            if (!isUnit(member)) continue;
+            const unitIri = this.normalizeIri(getIriForNode(member) ?? '');
+            if (!unitIri) continue;
+            const symbols = (((member as any).symbol ?? []) as unknown[]).filter((s): s is string => typeof s === 'string' && s.length > 0);
+            if (symbols.length === 0) continue;
+            const kindIris = (((member as any).kinds ?? []) as any[])
+                .map((kindRef) => this.normalizeIri(getIriForNode(kindRef?.ref) ?? ''))
+                .filter((iri): iri is string => Boolean(iri));
+            for (const symbol of symbols) {
+                const entry: OmlIndexedUnit = { unitIri, symbol, kindIris, ontologyIri, modelUri };
+                this.indexedUnitsByIri.set(unitIri, entry);
+                const byIri = this.unitIrisBySymbol.get(symbol) ?? new Set<string>();
+                byIri.add(unitIri);
+                this.unitIrisBySymbol.set(symbol, byIri);
+                modelUnitIris.add(unitIri);
+            }
+        }
+        if (modelUnitIris.size > 0) {
+            this.unitIrisByModelUri.set(modelUri, modelUnitIris);
+        }
+    }
+
+    getAllClasses(): OmlIndexedClass[] {
+        this.ensureIndexedFromLoadedDocuments();
+        return [...this.indexedClassesByIri.values()];
+    }
+
+    private indexClasses(root: any, modelUri: string): void {
+        const ontologyIri = this.resolveOntologyIri(modelUri) ?? '';
+        const rootPrefix = typeof root?.prefix === 'string' && root.prefix.length > 0 ? root.prefix : undefined;
+        if (ontologyIri && rootPrefix) {
+            this.prefixByOntologyIri.set(ontologyIri, rootPrefix);
+        }
+        const modelClassIris = new Set<string>();
+        for (const member of collectOntologyMembers(root as any)) {
+            let kind: OmlClassKind | undefined;
+            if (isAspect(member)) {
+                kind = 'aspect';
+            } else if (isConcept(member)) {
+                kind = 'concept';
+            } else if (isRelationEntity(member)) {
+                kind = 'relationEntity';
+            }
+            if (!kind) {
+                continue;
+            }
+            const classIri = this.normalizeIri(getIriForNode(member) ?? '');
+            if (!classIri) {
+                continue;
+            }
+            const label = this.extractLabel(member);
+            if (label !== undefined) {
+                this.memberLabelByIri.set(classIri, label);
+                const labeled = this.labeledMemberIrisByModelUri.get(modelUri) ?? new Set<string>();
+                labeled.add(classIri);
+                this.labeledMemberIrisByModelUri.set(modelUri, labeled);
+            }
+            const specializations = Array.isArray((member as any).ownedSpecializations) ? (member as any).ownedSpecializations : [];
+            const superIris: string[] = [];
+            for (const specialization of specializations) {
+                const superIri = this.normalizeIri(getIriForNode(specialization?.superTerm?.ref) ?? '');
+                if (superIri) {
+                    superIris.push(superIri);
+                }
+            }
+            const entry: OmlIndexedClass = {
+                classIri,
+                kind,
+                name: typeof (member as any).name === 'string' ? (member as any).name : undefined,
+                label,
+                prefix: rootPrefix ?? this.prefixByOntologyIri.get(ontologyIri),
+                ontologyIri,
+                modelUri,
+                superIris,
+                location: getSourceLocation(member as any),
+            };
+            this.indexedClassesByIri.set(classIri, entry);
+            modelClassIris.add(classIri);
+        }
+        if (modelClassIris.size > 0) {
+            this.classIrisByModelUri.set(modelUri, modelClassIris);
+        }
+    }
+
+    private removeIndexedClassesForModelUri(modelUri: string): void {
+        const classIris = this.classIrisByModelUri.get(modelUri);
+        if (!classIris) {
+            return;
+        }
+        for (const classIri of classIris) {
+            this.indexedClassesByIri.delete(classIri);
+        }
+        this.classIrisByModelUri.delete(modelUri);
+    }
+
+    private removeUnitsForModelUri(modelUri: string): void {
+        const unitIris = this.unitIrisByModelUri.get(modelUri);
+        if (!unitIris) return;
+        for (const unitIri of unitIris) {
+            const entry = this.indexedUnitsByIri.get(unitIri);
+            if (entry) {
+                const bySymbol = this.unitIrisBySymbol.get(entry.symbol);
+                if (bySymbol) {
+                    bySymbol.delete(unitIri);
+                    if (bySymbol.size === 0) {
+                        this.unitIrisBySymbol.delete(entry.symbol);
+                    }
+                }
+            }
+            this.indexedUnitsByIri.delete(unitIri);
+        }
+        this.unitIrisByModelUri.delete(modelUri);
+    }
+
     private indexTypeHierarchy(root: any, modelUri: string): void {
         const typeSuperIrisByTypeIri = new Map<string, Set<string>>();
         for (const member of collectOntologyMembers(root as any)) {
@@ -506,6 +704,15 @@ export class OmlIndex {
         return namespace;
     }
 
+    private getPrefix(document: LangiumDocument): string | undefined {
+        const root = document.parseResult?.value;
+        if (!isOntology(root)) {
+            return undefined;
+        }
+        const prefix = (root as any).prefix;
+        return typeof prefix === 'string' && prefix.length > 0 ? prefix : undefined;
+    }
+
     private ontologyIriFromNamespace(namespace: string): string {
         return namespace.replace(/[\/#]+$/, '');
     }

package/src/oml/oml-serializer.ts

@@ -845,29 +845,35 @@ const serializeLiteral = (literal: Literal): string => {
         return literal.value ? 'true' : 'false';
     }
     if (isIntegerLiteral(literal)) {
-        return `${literal.value}`;
+        return appendUnitSuffix(`${literal.value}`, literal);
     }
     if (isDecimalLiteral(literal)) {
         const v = literal.value as unknown;
         // Langium parses decimal literals to JS numbers; integer-valued ones (e.g. 567.0→567)
         // must be written with a decimal point to remain valid DECIMAL syntax.
-        if (typeof v === 'number' && Number.isFinite(v) && Number.isInteger(v)) {
-            return `${v}.0`;
-        }
-        return `${literal.value}`;
+        const base = (typeof v === 'number' && Number.isFinite(v) && Number.isInteger(v))
+            ? `${v}.0`
+            : `${literal.value}`;
+        return appendUnitSuffix(base, literal);
     }
     if (isDoubleLiteral(literal)) {
         const v = literal.value as unknown;
         // Langium parses double literals to JS numbers, losing the required e-notation.
         // OML DOUBLE terminal requires e/E; always emit it.
-        if (typeof v === 'number' && Number.isFinite(v)) {
-            return Number.isInteger(v) ? `${v}.0e0` : `${v}e0`;
-        }
-        return `${literal.value}`;
+        const base = (typeof v === 'number' && Number.isFinite(v))
+            ? (Number.isInteger(v) ? `${v}.0e0` : `${v}e0`)
+            : `${literal.value}`;
+        return appendUnitSuffix(base, literal);
     }
     return '';
 };
 
+const appendUnitSuffix = (base: string, literal: any): string => {
+    const unitRef = literal?.unit;
+    const refText = unitRef?.$refText ?? unitRef?.ref?.name;
+    return refText ? `${base}^^${refText}` : base;
+};
+
 const serializeQuotedLiteral = (literal: QuotedLiteral): string => {
     const base = serializeStringLiteral(literal.value ?? '');
     if (literal.type?.$refText) {

package/src/oml/oml-update.ts

@@ -1215,17 +1215,22 @@ async function ensureReferenceImport(shared: any, ontology: any, iri: string): P
         const importedNamespace = normalizeNamespace(String(resolveImportNamespaceRaw(imp) ?? ''));
         return importedNamespace === target.namespace;
     });
+    const importedOntology = await findOntologyByNamespace(shared, target.namespace);
+    const declaredPrefix = typeof importedOntology?.prefix === 'string' ? importedOntology.prefix.trim() : '';
+    const preferredPrefix = declaredPrefix && !usedPrefixes.has(declaredPrefix)
+        ? declaredPrefix
+        : pickImportPrefix(target.namespace, usedPrefixes);
     if (existingImport) {
         // If the existing import has no prefix (e.g., a bundle `includes` added without one),
         // patch it now so that the reference can use the abbreviated form.
         if (!resolveImportPrefix(existingImport)) {
-            existingImport.prefix = pickImportPrefix(target.namespace, usedPrefixes);
+            existingImport.prefix = preferredPrefix;
         }
         return;
     }
-    const prefix = pickImportPrefix(target.namespace, usedPrefixes);
+    const prefix = preferredPrefix;
     const importedRef = `<${target.namespace}${target.separator}>`;
-    const importKind = await resolveImportKind(shared, ontology, target.namespace);
+    const importKind = await resolveImportKind(shared, ontology, target.namespace, importedOntology);
     const importStatement: any = {
         $type: 'Import',
         kind: importKind,
@@ -1418,6 +1423,21 @@ function matchesRefTextFragment(statement: any, fragment: string): boolean {
 }
 
 function asLiteral(ontology: any, value: unknown): any {
+    if (isQuantityLiteralTransport(value)) {
+        const raw = value.value;
+        const num = typeof raw === 'number' ? raw : Number(raw);
+        const $type = !Number.isFinite(num)
+            ? 'DecimalLiteral'
+            : Number.isInteger(num)
+                ? 'IntegerLiteral'
+                : (typeof raw === 'string' && /[eE]/.test(raw) ? 'DoubleLiteral' : 'DecimalLiteral');
+        const literal: Record<string, unknown> = { $type, value: num };
+        const unitIri = literalUnitIriFromTransport(ontology, value);
+        if (unitIri) {
+            literal.unit = { $refText: toRefText(ontology, unitIri) };
+        }
+        return literal;
+    }
     if (isTypedQuotedLiteralTransport(value)) {
         const literalValue = String(value.value ?? '');
         const langTag = literalLanguageTagFromTransport(value);
@@ -1453,14 +1473,18 @@ function asLiteral(ontology: any, value: unknown): any {
 }
 
 async function ensureTypedLiteralDatatypeImport(shared: any, ontology: any, value: unknown): Promise<void> {
-    if (!isTypedQuotedLiteralTransport(value)) {
-        return;
+    if (isTypedQuotedLiteralTransport(value)) {
+        const datatypeIri = literalDatatypeIriFromTransport(ontology, value);
+        if (datatypeIri && !isXsdStringDatatypeIri(ontology, datatypeIri)) {
+            await ensureReferenceImport(shared, ontology, datatypeIri);
+        }
     }
-    const datatypeIri = literalDatatypeIriFromTransport(ontology, value);
-    if (!datatypeIri || isXsdStringDatatypeIri(ontology, datatypeIri)) {
-        return;
+    if (isQuantityLiteralTransport(value)) {
+        const unitIri = literalUnitIriFromTransport(ontology, value);
+        if (unitIri) {
+            await ensureReferenceImport(shared, ontology, unitIri);
+        }
     }
-    await ensureReferenceImport(shared, ontology, datatypeIri);
 }
 
 function isTypedQuotedLiteralTransport(value: unknown): value is {
@@ -1490,6 +1514,43 @@ function isTypedQuotedLiteralTransport(value: unknown): value is {
     ) && 'value' in record;
 }
 
+function isQuantityLiteralTransport(value: unknown): value is {
+    value: number | string;
+    unitIri?: unknown;
+    unitRefText?: unknown;
+    unit?: unknown;
+    $type?: unknown;
+} {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+    const record = value as Record<string, unknown>;
+    const hasUnit = typeof record.unitIri === 'string'
+        || typeof record.unitRefText === 'string'
+        || typeof record.unit === 'string';
+    if (!hasUnit) return false;
+    const v = record.value;
+    return typeof v === 'number' || (typeof v === 'string' && v.length > 0);
+}
+
+function literalUnitIriFromTransport(ontology: any, value: {
+    unitIri?: unknown;
+    unitRefText?: unknown;
+    unit?: unknown;
+}): string {
+    const directIri = typeof value.unitIri === 'string'
+        ? value.unitIri.trim()
+        : (typeof value.unit === 'string' && value.unit.includes('://') ? value.unit.trim() : '');
+    if (directIri) {
+        return normalizeIri(directIri);
+    }
+    const refText = typeof value.unitRefText === 'string'
+        ? value.unitRefText.trim()
+        : (typeof value.unit === 'string' ? value.unit.trim() : '');
+    if (!refText) return '';
+    return normalizeIri(expandRefTextToIri(ontology, refText) ?? refText);
+}
+
 function literalLanguageTag(literal: any): string {
     if (!literal || typeof literal !== 'object') {
         return '';