@oml/language 0.9.0 → 0.11.0

package/src/oml/oml-candidates.ts

@@ -1,16 +1,32 @@
 // Copyright (c) 2026 Modelware. All rights reserved.
 
 import { URI, stream, type AstNodeDescription, type AstNodeLocator, type IndexManager, type LangiumDocuments, type Stream } from 'langium';
-import { isConceptInstance, isMember, isRelationInstance } from './generated/ast.js';
+import {
+    isAspect,
+    isBooleanLiteral,
+    isConcept,
+    isConceptInstance,
+    isDecimalLiteral,
+    isDoubleLiteral,
+    isIntegerLiteral,
+    isMember,
+    isQuotedLiteral,
+    isRelationEntity,
+    isRelationInstance,
+    isScalar,
+} from './generated/ast.js';
+import { getOntologyModelIndex, type OmlIndex } from './oml-index.js';
 import { getIriForNode, getWorkspaceSnapshot } from './oml-utils.js';
 
-export const OmlCandidatesRequest = 'oml/candidates';
+export const OmlCompletionRequest = 'oml/completion';
 
-export interface OmlCandidatesParams {
-    referenceType: string;
+export interface OmlCompletionParams {
+    instanceIri?: string;
+    propertyIri?: string;
+    typeIri?: string;
 }
 
-export interface OmlCandidatesResult {
+export interface OmlCompletionResult {
     candidates: string[];
 }
 
@@ -18,14 +34,14 @@ const MaxReferenceTypeCaches = 64;
 const workspacePreloadState = new WeakMap<object, { completed: boolean; promise?: Promise<void> }>();
 
 type ConnectionLike = {
-    onRequest: (type: string, handler: (params: OmlCandidatesParams) => OmlCandidatesResult | Promise<OmlCandidatesResult>) => void;
+    onRequest: (type: string, handler: (params: OmlCompletionParams) => OmlCompletionResult | Promise<OmlCompletionResult>) => void;
 };
 
 export class OmlCandidates {
     private readonly referenceCandidatesCache = new Map<string, { snapshot: string; candidates: AstNodeDescription[] }>();
-    private readonly workspaceCandidateIrisCache = new Map<string, { snapshot: string; candidates: string[] }>();
 
     constructor(
+        private readonly ontologyIndex: OmlIndex,
         private readonly indexManager: IndexManager,
         private readonly langiumDocuments: LangiumDocuments,
         private readonly astNodeLocator: AstNodeLocator,
@@ -41,12 +57,7 @@ export class OmlCandidates {
         if (!normalizedReferenceType) {
             return [];
         }
-        const snapshot = getWorkspaceSnapshot(this.langiumDocuments);
-        const cached = this.workspaceCandidateIrisCache.get(normalizedReferenceType);
-        if (cached && cached.snapshot === snapshot) {
-            return cached.candidates;
-        }
-        const workspace = this.getWorkspaceCandidates(normalizedReferenceType);
+        const workspace = this.indexManager.allElements(normalizedReferenceType).toArray();
         const iris: string[] = [];
         for (const description of workspace) {
             const node = this.resolveDescriptionNode(description);
@@ -55,10 +66,39 @@ export class OmlCandidates {
                 iris.push(iri);
             }
         }
-        const candidates = [...new Set(iris)];
-        this.workspaceCandidateIrisCache.set(normalizedReferenceType, { snapshot, candidates });
-        this.pruneCache(this.workspaceCandidateIrisCache, MaxReferenceTypeCaches);
-        return candidates;
+        return [...new Set(iris)];
+    }
+
+    getCompletionCandidateIris(params: OmlCompletionParams): string[] {
+        const typeIri = (params.typeIri ?? '').trim();
+        if (!typeIri) {
+            return this.ontologyIndex.getAllDescriptionInstanceIris();
+        }
+        const typeNode = this.resolveTypeNodeByIri(typeIri);
+        if (!typeNode) {
+            return [];
+        }
+        if (isScalar(typeNode)) {
+            const literals = typeNode.ownedEnumeration?.literals ?? [];
+            const values = literals
+                .map((literal) => this.serializeLiteralCandidate(literal))
+                .filter((value): value is string => typeof value === 'string' && value.length > 0);
+            return [...new Set(values)];
+        }
+        if (isConcept(typeNode)) {
+            const enumeration = typeNode.ownedEnumeration;
+            if (enumeration?.instances?.length) {
+                const values = enumeration.instances
+                    .map((reference) => this.resolveNamedInstanceReferenceIri(reference))
+                    .filter((value): value is string => typeof value === 'string' && value.length > 0);
+                return [...new Set(values)];
+            }
+        }
+        if (isAspect(typeNode) || isConcept(typeNode) || isRelationEntity(typeNode)) {
+            const iris = this.ontologyIndex.getTypeMemberIris(typeIri);
+            return iris;
+        }
+        return [];
     }
 
     private getWorkspaceCandidates(referenceType: string): AstNodeDescription[] {
@@ -89,6 +129,89 @@ export class OmlCandidates {
         return undefined;
     }
 
+    private normalizeIri(iri: string): string {
+        return iri.replace(/^<|>$/g, '').trim();
+    }
+
+    private resolveTypeNodeByIri(typeIri: string): unknown {
+        const normalized = this.normalizeIri(typeIri);
+        if (!normalized) {
+            return undefined;
+        }
+        for (const referenceType of ['Scalar', 'Concept', 'Aspect', 'RelationEntity']) {
+            for (const description of this.indexManager.allElements(referenceType).toArray()) {
+                const node = this.resolveDescriptionNode(description);
+                const iri = this.normalizeIri(getIriForNode(node) ?? '');
+                if (iri === normalized) {
+                    return node;
+                }
+            }
+        }
+        return undefined;
+    }
+
+    private resolveNamedInstanceReferenceIri(reference: any): string | undefined {
+        const resolved = reference?.ref;
+        const resolvedIri = resolved ? this.normalizeIri(getIriForNode(resolved) ?? '') : '';
+        if (resolvedIri) {
+            return resolvedIri;
+        }
+        const refText = reference?.$refText;
+        if (typeof refText === 'string' && refText.trim().length > 0) {
+            return this.normalizeIri(refText);
+        }
+        return undefined;
+    }
+
+    private serializeLiteralCandidate(literal: any): string {
+        if (isQuotedLiteral(literal)) {
+            return this.serializeQuotedLiteralCandidate(literal);
+        }
+        if (isBooleanLiteral(literal)) {
+            return literal.value ? 'true' : 'false';
+        }
+        if (isIntegerLiteral(literal) || isDecimalLiteral(literal) || isDoubleLiteral(literal)) {
+            return `${literal.value}`;
+        }
+        return '';
+    }
+
+    private serializeQuotedLiteralCandidate(literal: any): string {
+        const base = this.serializeStringLiteral(literal.value ?? '');
+        if (literal.type?.ref) {
+            const datatypeIri = this.normalizeIri(getIriForNode(literal.type.ref) ?? literal.type.$refText ?? '');
+            if (datatypeIri) {
+                return `${base}^^${datatypeIri}`;
+            }
+        }
+        if (typeof literal.langTag === 'string' && literal.langTag.trim().length > 0) {
+            return `${base}$${literal.langTag.trim()}`;
+        }
+        return base;
+    }
+
+    private serializeStringLiteral(value: string): string {
+        const raw = value ?? '';
+        if (raw.includes('\n') || raw.includes('\r')) {
+            if (!raw.includes('"""')) {
+                return `"""${raw}"""`;
+            }
+            if (!raw.includes("'''")) {
+                return `'''${raw}'''`;
+            }
+        }
+        if (!raw.includes('"')) {
+            return `"${raw}"`;
+        }
+        if (!raw.includes("'")) {
+            return `'${raw}'`;
+        }
+        if (!raw.includes('"""')) {
+            return `"""${raw}"""`;
+        }
+        return `'''${raw}'''`;
+    }
+
     private resolveDescriptionNode(description: AstNodeDescription): unknown {
         if (description.node) {
             return description.node;
@@ -118,18 +241,16 @@ export class OmlCandidates {
 }
 
 export function registerOmlCandidatesRequests(connection: ConnectionLike, shared: any): void {
+    const ontologyIndex = getOntologyModelIndex(shared);
     const candidates = new OmlCandidates(
+        ontologyIndex,
         shared.workspace.IndexManager,
         shared.workspace.LangiumDocuments,
         shared.workspace.AstNodeLocator
     );
-    connection.onRequest(OmlCandidatesRequest, async (params: OmlCandidatesParams): Promise<OmlCandidatesResult> => {
+    connection.onRequest(OmlCompletionRequest, async (params: OmlCompletionParams): Promise<OmlCompletionResult> => {
         await ensureWorkspaceIndexed(shared);
-        const referenceType = (params?.referenceType ?? '').trim();
-        if (!referenceType) {
-            return { candidates: [] };
-        }
-        return { candidates: candidates.getWorkspaceCandidateIris(referenceType) };
+        return { candidates: candidates.getCompletionCandidateIris(params) };
     });
 }
 

package/src/oml/oml-completion.ts

@@ -4,6 +4,7 @@ import type { AstNodeDescription, ReferenceInfo, Stream, LangiumDocuments, AstNo
 import type { CompletionItem, TextEdit } from 'vscode-languageserver-types';
 import { DefaultCompletionProvider, type CompletionContext, type CompletionValueItem, type LangiumServices } from 'langium/lsp';
 import { Element, isDescription, isDescriptionBox, isMember, isOntology, isVocabulary, isVocabularyBundle, Member, Ontology } from './generated/ast.js';
+import { getOntologyModelIndex } from './oml-index.js';
 import { getLangiumDocumentVersion } from './oml-utils.js';
 import { OmlCandidates } from './oml-candidates.js';
 
@@ -32,7 +33,7 @@ export class OmlCompletionProvider extends DefaultCompletionProvider {
         this.indexManager = services.shared.workspace.IndexManager;
         this.langiumDocuments = services.shared.workspace.LangiumDocuments;
         this.astNodeLocator = services.workspace.AstNodeLocator;
-        this.candidates = new OmlCandidates(this.indexManager, this.langiumDocuments, this.astNodeLocator);
+        this.candidates = new OmlCandidates(getOntologyModelIndex(services.shared), this.indexManager, this.langiumDocuments, this.astNodeLocator);
     }
 
     /**

package/src/oml/oml-document.ts

@@ -1,24 +1,64 @@
 // Copyright (c) 2026 Modelware. All rights reserved.
 
+import { URI } from 'langium';
 import { DefaultDocumentUpdateHandler } from 'langium/lsp';
 import type { LangiumSharedServices } from 'langium/lsp';
-import type { TextDocumentChangeEvent } from 'vscode-languageserver';
-import type { TextDocument } from 'vscode-languageserver-textdocument';
+import { FileChangeType, type DidChangeWatchedFilesParams } from 'vscode-languageserver';
+import { getOntologyModelIndex } from './oml-index.js';
 
 export class OmlDocumentUpdateHandler extends DefaultDocumentUpdateHandler {
-    private readonly lastProcessedVersionByUri = new Map<string, number>();
+    private readonly services: LangiumSharedServices;
 
     constructor(services: LangiumSharedServices) {
         super(services);
+        this.services = services;
     }
 
-    override didChangeContent(change: TextDocumentChangeEvent<TextDocument>): void {
-        const nextVersion = change.document.version;
-        const previousVersion = this.lastProcessedVersionByUri.get(change.document.uri);
-        if (previousVersion === nextVersion) {
+    override didChangeWatchedFiles(params: DidChangeWatchedFilesParams): void {
+        this.cleanDeletedOntologyDocuments(params);
+        super.didChangeWatchedFiles(params);
+    }
+
+    private cleanDeletedOntologyDocuments(params: DidChangeWatchedFilesParams): void {
+        const deletedUris = new Set(
+            params.changes
+                .filter((change) => change.type === FileChangeType.Deleted)
+                .map((change) => change.uri)
+        );
+        if (deletedUris.size === 0) {
             return;
         }
-        this.lastProcessedVersionByUri.set(change.document.uri, nextVersion);
-        super.didChangeContent(change);
+
+        const ontologyIndex = getOntologyModelIndex(this.services);
+        const documents = this.services.workspace.LangiumDocuments.all.toArray();
+        for (const document of documents) {
+            if (!matchesDeletedUri(document.uri.toString(), deletedUris)) {
+                continue;
+            }
+            ontologyIndex.removeDocument(document);
+            const language = this.services.ServiceRegistry.getServices(document.uri) as any;
+            language?.reasoning?.ReasoningService?.onDocumentDeleted?.(document);
+        }
     }
 }
+
+function matchesDeletedUri(candidateUri: string, deletedUris: ReadonlySet<string>): boolean {
+    for (const deletedUri of deletedUris) {
+        const deleted = URI.parse(deletedUri);
+        const candidate = URI.parse(candidateUri);
+        if (candidate.scheme !== deleted.scheme || (candidate.authority ?? '') !== (deleted.authority ?? '')) {
+            continue;
+        }
+        const deletedPath = normalizeUriPath(deleted.path);
+        const candidatePath = normalizeUriPath(candidate.path);
+        if (candidatePath === deletedPath || candidatePath.startsWith(`${deletedPath}/`)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+function normalizeUriPath(path: string): string {
+    const normalized = path.replace(/\/+$/, '');
+    return normalized || '/';
+}