@oml/language 0.7.0

package/src/oml/oml-utils.ts

@@ -0,0 +1,294 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import {
+    isDescription,
+    isForwardRelation,
+    isMember,
+    isRelationEntity,
+    isReverseRelation,
+    isOntology,
+    isVocabulary,
+} from './generated/ast.js';
+import type { LangiumDocument, LangiumDocuments } from 'langium';
+import type {
+    Description,
+    ForwardRelation,
+    Import,
+    Member,
+    Ontology,
+    ReverseRelation,
+    Vocabulary,
+} from './generated/ast.js';
+import { URI } from 'langium';
+
+export type NamedElement = Member | ForwardRelation | ReverseRelation;
+export type IriOwningElement = NamedElement | Ontology;
+
+type NamedCandidate = { name?: unknown };
+
+function resolveName(candidate: NamedCandidate): string | undefined {
+    const value = candidate?.name;
+    if (typeof value === 'string' && value.length > 0) {
+        return value;
+    }
+    return undefined;
+}
+
+export function getMemberName(member: Member): string | undefined {
+    return resolveName(member);
+}
+
+export function getNamedElementName(element: NamedElement): string | undefined {
+    return resolveName(element);
+}
+
+export function findOwningOntology(member: Member): Vocabulary | Description | undefined {
+    let current: any = (member as any).$container;
+    while (current) {
+        if (isVocabulary(current) || isDescription(current)) {
+            return current;
+        }
+        current = current.$container;
+    }
+    return undefined;
+}
+
+export function findOwningOntologyNode(node: any): Ontology | undefined {
+    let current = node;
+    while (current) {
+        if (isOntology(current)) {
+            return current as Ontology;
+        }
+        current = current.$container;
+    }
+    return undefined;
+}
+
+export function collectOntologyMembers(ontology: Vocabulary | Description): NamedElement[] {
+    const members: NamedElement[] = [];
+    const statements = (ontology as Vocabulary | Description).ownedStatements ?? [];
+    for (const statement of statements) {
+        if (isMember(statement)) {
+            members.push(statement);
+        }
+        if (isRelationEntity(statement)) {
+            if (statement.forwardRelation) {
+                members.push(statement.forwardRelation);
+            }
+            if (statement.reverseRelation) {
+                members.push(statement.reverseRelation);
+            }
+        }
+    }
+    return members;
+}
+
+export const humanizeTypeName = (typeName: string): string =>
+    typeName
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .replace(/_/g, ' ')
+        .toLowerCase();
+
+export interface SourceLocation {
+    startLine: number;
+    startColumn: number;
+    endLine: number;
+    endColumn: number;
+}
+
+export function getSourceLocation(astNode: { $cstNode?: { offset: number; length: number }; $document?: { textDocument?: { positionAt(offset: number): { line: number; character: number } } } } | undefined): SourceLocation | undefined {
+    const cstNode = astNode?.$cstNode;
+    if (!cstNode) return undefined;
+
+    const doc = astNode.$document;
+    if (!doc?.textDocument) return undefined;
+
+    const startPosition = doc.textDocument.positionAt(cstNode.offset);
+    const endPosition = doc.textDocument.positionAt(cstNode.offset + cstNode.length);
+    return {
+        startLine: startPosition.line + 1,
+        startColumn: startPosition.character,
+        endLine: endPosition.line + 1,
+        endColumn: endPosition.character,
+    };
+}
+
+export function deref(node: any): any {
+    if (!node) return undefined;
+    const wrapper = node.ref;
+    if (wrapper) return wrapper.ref ?? wrapper._ref ?? wrapper;
+    return node;
+}
+
+export const normalizeNamespace = (raw: string): string =>
+    raw.replace(/^<|>$/g, '').replace(/[#/]?$/, '');
+
+export const resolveImportNamespace = (imp: Import): string => {
+    const raw =
+        (imp.imported as any)?.$refText ??
+        (imp as any)?.imported ??
+        '';
+    return raw.replace(/^<|>$/g, '');
+};
+
+export const getAllLangiumDocuments = (documents: LangiumDocuments): LangiumDocument[] => {
+    const docs: any = documents;
+    const all = docs.all ?? [];
+    if (Array.isArray(all)) {
+        return all;
+    }
+    if (typeof all?.toArray === 'function') {
+        return all.toArray() as LangiumDocument[];
+    }
+    return Array.from(all as Iterable<LangiumDocument>);
+};
+
+export const getLangiumDocumentUri = (document: LangiumDocument): string => {
+    const anyDoc: any = document;
+    const uri = anyDoc.uri ?? anyDoc.textDocument?.uri;
+    return typeof uri?.toString === 'function' ? uri.toString() : String(uri ?? '');
+};
+
+export const getLangiumDocumentVersion = (document: LangiumDocument): number => {
+    const version = (document as any)?.textDocument?.version;
+    return typeof version === 'number' ? version : 0;
+};
+
+export const getWorkspaceSnapshot = (documents: LangiumDocuments): string =>
+    getAllLangiumDocuments(documents)
+        .map((doc) => `${getLangiumDocumentUri(doc)}@${getLangiumDocumentVersion(doc)}`)
+        .sort()
+        .join('|');
+
+const GITHUB_COPILOT_TRANSIENT_DOCUMENT_SCHEMES = new Set([
+    'chat-editing-text-model',
+    'chat-editing-snapshot-text-model',
+    'vscode-chat-code-block',
+]);
+
+export function isTransientEditorDocumentUri(uri: string): boolean {
+    try {
+        return GITHUB_COPILOT_TRANSIENT_DOCUMENT_SCHEMES.has(URI.parse(uri).scheme);
+    } 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 slashIndex = trimmed.lastIndexOf('/');
+    if (slashIndex >= 0) {
+        return {
+            base: trimmed.slice(0, slashIndex),
+            fragment: trimmed.slice(slashIndex + 1),
+            separator: '/',
+        };
+    }
+    return null;
+};
+
+export const resolveIndent = (text: string, rootOffset: number, insertOffset: number): string => {
+    const slice = text.slice(rootOffset, insertOffset);
+    const lines = slice.split(/\r?\n/);
+    for (let i = lines.length - 1; i >= 0; i -= 1) {
+        const line = lines[i];
+        if (!line || !line.trim() || line.trim() === '}') continue;
+        const match = line.match(/^\s*/);
+        if (match) return match[0];
+    }
+    return '    ';
+};
+
+export const getOntologyMemberNames = (root: Ontology): string[] => {
+    const statements = (root as { ownedStatements?: any[] }).ownedStatements ?? [];
+    return statements
+        .filter((stmt: any) => isMember(stmt) && typeof stmt?.name === 'string')
+        .map((stmt: any) => stmt.name.trim())
+        .filter(Boolean);
+};
+
+export function findOntologyMemberByName(root: Ontology, memberName: string): NamedElement | undefined {
+    const wanted = memberName.trim();
+    if (!wanted) {
+        return undefined;
+    }
+    if (!isVocabulary(root) && !isDescription(root)) {
+        return undefined;
+    }
+    return collectOntologyMembers(root).find((member) => getNamedElementName(member) === wanted);
+}
+
+export function getIriOwningElement(node: any): IriOwningElement | undefined {
+    let current = node;
+    while (current) {
+        if (isMember(current) || isForwardRelation(current) || isReverseRelation(current) || isOntology(current)) {
+            return current as IriOwningElement;
+        }
+        current = current.$container;
+    }
+    return undefined;
+}
+
+export function getNamespaceSeparator(rawNamespace: string | undefined): '#' | '/' {
+    const value = (rawNamespace ?? '').trim();
+    if (value.endsWith('/')) return '/';
+    if (value.endsWith('#')) return '#';
+    return '#';
+}
+
+export function buildMemberIri(namespace: string, memberName: string, separator: '#' | '/'): string {
+    const ns = normalizeNamespace(namespace);
+    return `${ns}${separator}${memberName}`;
+}
+
+export function getIriForNode(node: any): string | undefined {
+    const owner = getIriOwningElement(node);
+    if (!owner) return undefined;
+
+    if (isOntology(owner)) {
+        const namespace = typeof owner.namespace === 'string' ? owner.namespace : '';
+        const normalized = normalizeNamespace(namespace);
+        return normalized || undefined;
+    }
+
+    const name = getNamedElementName(owner);
+    if (!name) return undefined;
+    const ontology = findOwningOntologyNode(owner);
+    if (!ontology || typeof ontology.namespace !== 'string') return undefined;
+    const separator = getNamespaceSeparator(ontology.namespace);
+    return buildMemberIri(ontology.namespace, name, separator);
+}
+
+function getDocumentUriForNode(node: any): string | undefined {
+    let current = node;
+    while (current) {
+        const uri = current?.$document?.uri?.toString?.();
+        if (uri) {
+            return uri;
+        }
+        current = current.$container;
+    }
+    return undefined;
+}
+
+export function getModelIdForNode(
+    node: any,
+    astNodeLocator: { getAstNodePath(node: any): string } | undefined,
+    defaultDocumentUri?: string
+): string | undefined {
+    const docUri = getDocumentUriForNode(node) ?? defaultDocumentUri;
+    if (!docUri) return undefined;
+    if (!astNodeLocator || typeof astNodeLocator.getAstNodePath !== 'function') return undefined;
+    const astPath = astNodeLocator.getAstNodePath(node);
+    if (!astPath) return undefined;
+    return `${docUri}#${astPath}`;
+}