@oml/language 0.14.16 → 0.15.0

package/src/oml/oml-utils.ts

@@ -120,15 +120,72 @@ export function deref(node: any): any {
     return node;
 }
 
+export const normalizeIri = (value: string): string =>
+    String(value ?? '').trim().replace(/^<|>$/g, '');
+
 export const normalizeNamespace = (raw: string): string =>
-    raw.replace(/^<|>$/g, '').replace(/[#/]?$/, '');
+    normalizeIri(raw).replace(/[#/]?$/, '');
+
+export const withNamespaceSeparator = (rawNamespace: string): string => {
+    const trimmed = normalizeIri(rawNamespace);
+    if (!trimmed) {
+        return trimmed;
+    }
+    return /[#/]$/.test(trimmed) ? trimmed : `${trimmed}#`;
+};
+
+export function resolveImportPrefix(imp: Import): string | undefined {
+    const explicitPrefix = typeof imp?.prefix === 'string' ? imp.prefix.trim() : '';
+    if (explicitPrefix) {
+        return explicitPrefix;
+    }
+    const resolvedPrefix = typeof (imp as any)?.imported?.ref?.prefix === 'string'
+        ? (imp as any).imported.ref.prefix.trim()
+        : '';
+    return resolvedPrefix || undefined;
+}
+
+export function resolveImportNamespaceRaw(imp: Import): string | undefined {
+    const resolvedNamespace = typeof (imp as any)?.imported?.ref?.namespace === 'string'
+        ? (imp as any).imported.ref.namespace
+        : '';
+    if (resolvedNamespace.trim().length > 0) {
+        return resolvedNamespace.trim();
+    }
+    const refText = typeof (imp as any)?.imported?.$refText === 'string'
+        ? (imp as any).imported.$refText.trim()
+        : '';
+    return refText || undefined;
+}
 
 export const resolveImportNamespace = (imp: Import): string => {
-    const raw =
-        (imp.imported as any)?.$refText ??
-        (imp as any)?.imported ??
-        '';
-    return raw.replace(/^<|>$/g, '');
+    return resolveImportNamespaceRaw(imp) ?? '';
+};
+
+export type IriParts = { namespace: string; fragment: string; separator: '#' | '/' };
+
+export const parseIriParts = (iri: string): IriParts | undefined => {
+    const normalized = normalizeIri(iri);
+    if (!normalized) {
+        return undefined;
+    }
+    const hashIndex = normalized.lastIndexOf('#');
+    if (hashIndex > 0 && hashIndex < normalized.length - 1) {
+        return {
+            namespace: normalizeNamespace(normalized.slice(0, hashIndex)),
+            fragment: normalized.slice(hashIndex + 1),
+            separator: '#',
+        };
+    }
+    const slashIndex = normalized.lastIndexOf('/');
+    if (slashIndex > 0 && slashIndex < normalized.length - 1) {
+        return {
+            namespace: normalizeNamespace(normalized.slice(0, slashIndex)),
+            fragment: normalized.slice(slashIndex + 1),
+            separator: '/',
+        };
+    }
+    return undefined;
 };
 
 export const getAllLangiumDocuments = (documents: LangiumDocuments): LangiumDocument[] => {
@@ -164,37 +221,153 @@ const OML_LS_IGNORED_DOCUMENT_SCHEMES = new Set([
     'chat-editing-text-model',
     'chat-editing-snapshot-text-model',
     'vscode-chat-code-block',
+    'copilot-chat-code-block',
+    'claude-code-chat-code-block',
 ]);
 
 export function isIgnoredByOmlLsDocumentUri(uri: string): boolean {
     try {
-        return OML_LS_IGNORED_DOCUMENT_SCHEMES.has(URI.parse(uri).scheme);
+        const scheme = URI.parse(uri).scheme.toLowerCase();
+        if (OML_LS_IGNORED_DOCUMENT_SCHEMES.has(scheme)) {
+            return true;
+        }
+        return scheme.includes('chat') || scheme.includes('copilot') || scheme.includes('claude');
     } catch {
         return false;
     }
 }
 
 export const splitIri = (iri: string): { base: string; fragment: string; separator: string } | null => {
-    const trimmed = iri.trim();
-    if (!trimmed) return null;
-    const hashIndex = trimmed.lastIndexOf('#');
-    if (hashIndex >= 0) {
-        return {
-            base: trimmed.slice(0, hashIndex),
-            fragment: trimmed.slice(hashIndex + 1),
-            separator: '#',
-        };
+    const parts = parseIriParts(iri);
+    return parts
+        ? { base: parts.namespace, fragment: parts.fragment, separator: parts.separator }
+        : null;
+};
+
+export function getRefText(ref: any): string | undefined {
+    if (typeof ref === 'string') {
+        return ref;
     }
-    const slashIndex = trimmed.lastIndexOf('/');
-    if (slashIndex >= 0) {
-        return {
-            base: trimmed.slice(0, slashIndex),
-            fragment: trimmed.slice(slashIndex + 1),
-            separator: '/',
-        };
+    if (typeof ref?.$refText === 'string') {
+        return ref.$refText;
     }
-    return null;
-};
+    if (typeof ref?.$refNode?.text === 'string') {
+        return ref.$refNode.text;
+    }
+    return undefined;
+}
+
+export function getLocalNameForNamespace(iri: string, rawNamespace: string | undefined): string | undefined {
+    const namespace = normalizeNamespace(String(rawNamespace ?? ''));
+    if (!namespace) {
+        return undefined;
+    }
+    const parts = parseIriParts(iri);
+    return parts?.namespace === namespace ? parts.fragment : undefined;
+}
+
+export function expandLocalRefText(rawNamespace: string | undefined, localName: string): string | undefined {
+    const local = String(localName ?? '').trim();
+    const namespace = withNamespaceSeparator(String(rawNamespace ?? ''));
+    if (!namespace || !local) {
+        return undefined;
+    }
+    return `${namespace}${local}`;
+}
+
+export function expandRefTextToIri(ontology: any, refText: string): string | undefined {
+    const trimmed = String(refText ?? '').trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    if (trimmed === 'a') {
+        return 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
+    }
+    if (trimmed.startsWith('<') && trimmed.endsWith('>')) {
+        return normalizeIri(trimmed);
+    }
+    if (trimmed.includes('://')) {
+        return normalizeIri(trimmed);
+    }
+    const localInCurrentOntology = expandLocalRefText(ontology?.namespace, trimmed);
+    if (localInCurrentOntology) {
+        return localInCurrentOntology;
+    }
+    const separatorIndex = trimmed.indexOf(':');
+    if (separatorIndex <= 0) {
+        return undefined;
+    }
+    const prefix = trimmed.slice(0, separatorIndex);
+    const local = trimmed.slice(separatorIndex + 1);
+    if (!local) {
+        return undefined;
+    }
+    if (typeof ontology?.prefix === 'string' && ontology.prefix.trim() === prefix) {
+        return expandLocalRefText(ontology.namespace, local);
+    }
+    const imports = Array.isArray(ontology?.ownedImports) ? ontology.ownedImports : [];
+    for (const imp of imports) {
+        if (resolveImportPrefix(imp) !== prefix) {
+            continue;
+        }
+        return expandLocalRefText(resolveImportNamespaceRaw(imp), local);
+    }
+    return undefined;
+}
+
+export function localNameFromRefText(refText: string): string | undefined {
+    const trimmed = normalizeIri(refText);
+    if (!trimmed) {
+        return undefined;
+    }
+    const iriParts = parseIriParts(trimmed);
+    if (iriParts) {
+        return iriParts.fragment;
+    }
+    const colonIndex = trimmed.indexOf(':');
+    if (colonIndex > 0 && colonIndex < trimmed.length - 1) {
+        return trimmed.slice(colonIndex + 1);
+    }
+    return trimmed;
+}
+
+export function isSameIriTarget(left: string, right: string): boolean {
+    const leftNorm = normalizeIri(left);
+    const rightNorm = normalizeIri(right);
+    if (leftNorm === rightNorm) {
+        return true;
+    }
+    const leftParts = parseIriParts(leftNorm);
+    const rightParts = parseIriParts(rightNorm);
+    if (!leftParts || !rightParts) {
+        return false;
+    }
+    return leftParts.namespace === rightParts.namespace
+        && leftParts.fragment === rightParts.fragment;
+}
+
+export function pickImportPrefix(namespace: string, usedPrefixes: ReadonlySet<string>): string {
+    const normalizedNamespace = normalizeNamespace(namespace);
+    const pieces = normalizedNamespace.split('/').filter((piece) => piece.length > 0);
+    const tail = (pieces[pieces.length - 1] ?? normalizedNamespace)
+        .replace(/[^A-Za-z0-9_]/g, '')
+        .toLowerCase();
+    const base = /^[A-Za-z_]/.test(tail) ? tail : `ns${tail}`;
+    const candidateBase = (base || 'ns').slice(0, 32);
+    if (!usedPrefixes.has(candidateBase)) {
+        return candidateBase;
+    }
+    let suffix = 1;
+    while (usedPrefixes.has(`${candidateBase}${suffix}`)) {
+        suffix += 1;
+    }
+    return `${candidateBase}${suffix}`;
+}
+
+export function normalizeUriPath(path: string): string {
+    const normalized = path.replace(/\/+$/, '');
+    return normalized || '/';
+}
 
 export const resolveIndent = (text: string, rootOffset: number, insertOffset: number): string => {
     const slice = text.slice(rootOffset, insertOffset);
@@ -239,7 +412,7 @@ export function getIriOwningElement(node: any): IriOwningElement | undefined {
 }
 
 export function getNamespaceSeparator(rawNamespace: string | undefined): '#' | '/' {
-    const value = (rawNamespace ?? '').trim();
+    const value = normalizeIri(rawNamespace ?? '');
     if (value.endsWith('/')) return '/';
     if (value.endsWith('#')) return '#';
     return '#';

package/src/oml/oml-workspace.ts

@@ -3,6 +3,7 @@
 import { URI, type LangiumSharedCoreServices } from 'langium';
 import { DefaultWorkspaceManager } from 'langium';
 import type { Connection } from 'vscode-languageserver';
+import { normalizeUriPath } from './oml-utils.js';
 
 // LSP request name — must match the handler registered in node-client.ts
 const GET_WORKSPACE_FOLDERS_REQUEST = 'oml/fs/getWorkspaceFolders';
@@ -75,7 +76,3 @@ function isUriPathWithinWorkspace(candidate: URI, workspace: URI): boolean {
     return candidatePath === workspacePath || candidatePath.startsWith(`${workspacePath}/`);
 }
 
-function normalizeUriPath(path: string): string {
-    const normalized = path.replace(/\/+$/, '');
-    return normalized || '/';
-}