@likec4/language-server 1.47.0 → 1.48.0

package/dist/ast.js

@@ -1,264 +0,0 @@
-// SPDX-License-Identifier: MIT
-//
-// Copyright (c) 2023-2025 Denis Davydkov
-// Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-//
-// Portions of this file have been modified by NVIDIA CORPORATION & AFFILIATES.
-import { invariant, MultiMap, nonexhaustive } from '@likec4/core/utils';
-import { AstUtils, DocumentState } from 'langium';
-import { clamp, isNullish, isTruthy } from 'remeda';
-import * as ast from './generated/ast';
-import { LikeC4LanguageMetaData } from './generated/module';
-export { ast };
-const idattr = Symbol.for('idattr');
-export const ViewOps = {
-    writeId(node, id) {
-        node[idattr] = id;
-        return node;
-    },
-    readId(node) {
-        return node[idattr];
-    },
-};
-export const ElementOps = {
-    writeId(node, id) {
-        if (isNullish(id)) {
-            node[idattr] = undefined;
-        }
-        else {
-            node[idattr] = id;
-        }
-        return node;
-    },
-    readId(node) {
-        return node[idattr];
-    },
-};
-export function isLikeC4LangiumDocument(doc) {
-    if (doc.textDocument.languageId === LikeC4LanguageMetaData.languageId) {
-        invariant(isTruthy(doc.likec4ProjectId), `LikeC4Document must have projectId defined: ${doc.uri.fsPath}`);
-        return true;
-    }
-    return false;
-}
-export function isParsedLikeC4LangiumDocument(doc) {
-    return (isLikeC4LangiumDocument(doc)
-        && doc.state == DocumentState.Validated
-        && !!doc.c4Specification
-        && !!doc.c4Elements
-        && !!doc.c4ExtendElements
-        && !!doc.c4ExtendDeployments
-        && !!doc.c4ExtendRelations
-        && !!doc.c4Relations
-        && !!doc.c4Views
-        && !!doc.c4Deployments
-        && !!doc.c4DeploymentRelations
-        && !!doc.c4Imports);
-}
-export function parseMarkdownAsString(node) {
-    return node?.markdown || node?.text;
-}
-export function parseAstPercent(value) {
-    const opacity = parseFloat(value);
-    return isNaN(opacity) ? 100 : clamp(opacity, { min: 0, max: 100 });
-}
-export function parseAstOpacityProperty({ value }) {
-    return parseAstPercent(value);
-}
-export function parseAstSizeValue({ value }) {
-    switch (value) {
-        case 'xs':
-        case 'sm':
-        case 'md':
-        case 'lg':
-        case 'xl':
-            return value;
-        case 'xsmall':
-            return 'xs';
-        case 'small':
-            return 'sm';
-        case 'medium':
-            return 'md';
-        case 'large':
-            return 'lg';
-        case 'xlarge':
-            return 'xl';
-        default:
-            nonexhaustive(value);
-    }
-}
-export function toRelationshipStyle(props, isValid) {
-    const result = {};
-    if (!props || props.length === 0) {
-        return result;
-    }
-    for (const prop of props) {
-        if (!isValid(prop)) {
-            continue;
-        }
-        switch (true) {
-            case ast.isColorProperty(prop): {
-                const color = toColor(prop);
-                if (isTruthy(color)) {
-                    result.color = color;
-                }
-                break;
-            }
-            case ast.isLineProperty(prop): {
-                result.line = prop.value;
-                break;
-            }
-            case ast.isArrowProperty(prop): {
-                switch (prop.key) {
-                    case 'head': {
-                        result.head = prop.value;
-                        break;
-                    }
-                    case 'tail': {
-                        result.tail = prop.value;
-                        break;
-                    }
-                    default: {
-                        nonexhaustive(prop);
-                    }
-                }
-                break;
-            }
-            default: {
-                nonexhaustive(prop);
-            }
-        }
-    }
-    return result;
-}
-export function toColor(astNode) {
-    return astNode?.themeColor ?? astNode?.customColor?.$refText;
-}
-export function toAutoLayout(rule) {
-    const rankSep = rule.rankSep;
-    const nodeSep = rule.nodeSep;
-    let direction;
-    switch (rule.direction) {
-        case 'TopBottom': {
-            direction = 'TB';
-            break;
-        }
-        case 'BottomTop': {
-            direction = 'BT';
-            break;
-        }
-        case 'LeftRight': {
-            direction = 'LR';
-            break;
-        }
-        case 'RightLeft': {
-            direction = 'RL';
-            break;
-        }
-        default:
-            nonexhaustive(rule.direction);
-    }
-    return {
-        direction,
-        ...(nodeSep && { nodeSep }),
-        ...(rankSep && { rankSep }),
-    };
-}
-export function toAstViewLayoutDirection(c4) {
-    switch (c4) {
-        case 'TB': {
-            return 'TopBottom';
-        }
-        case 'BT': {
-            return 'BottomTop';
-        }
-        case 'LR': {
-            return 'LeftRight';
-        }
-        case 'RL': {
-            return 'RightLeft';
-        }
-        default:
-            nonexhaustive(c4);
-    }
-}
-// export function elementExpressionFromPredicate(predicate: ast.ElementPredicate): ast.ElementExpression {
-//   if (ast.isElementExpression(predicate)) {
-//     return predicate
-//   }
-//   if (ast.isElementPredicateWhere(predicate)) {
-//     return predicate.subject
-//   }
-//   if (ast.isElementPredicateWith(predicate)) {
-//     return elementExpressionFromPredicate(predicate.subject)
-//   }
-//   nonexhaustive(predicate)
-// }
-export function getViewRulePredicateContainer(el) {
-    return AstUtils.getContainerOfType(el, (n) => {
-        return ast.isViewRulePredicate(n) || ast.isDeploymentViewRulePredicate(n) || ast.isDynamicViewIncludePredicate(n);
-    });
-}
-const _isModel = (astNode) => {
-    return ast.isModel(astNode) ||
-        ast.isElementBody(astNode) ||
-        ast.isExtendElementBody(astNode) ||
-        ast.isElementViewBody(astNode) ||
-        ast.isDynamicViewBody(astNode) ||
-        ast.isElementRef(astNode);
-};
-const _isDeployment = (astNode) => {
-    return ast.isModelDeployments(astNode) ||
-        ast.isDeploymentViewBody(astNode) ||
-        ast.isDeploymentNodeBody(astNode) ||
-        ast.isExtendDeploymentBody(astNode) ||
-        ast.isDeployedInstanceBody(astNode);
-};
-export function isFqnRefInsideGlobals(astNode) {
-    while (true) {
-        if (_isDeployment(astNode) || _isModel(astNode)) {
-            return false;
-        }
-        if (ast.isGlobals(astNode) || ast.isModelViews(astNode)) {
-            return true;
-        }
-        if (astNode.$container) {
-            astNode = astNode.$container;
-        }
-        else {
-            return false;
-        }
-    }
-}
-export function isFqnRefInsideModel(astNode) {
-    while (true) {
-        if (_isDeployment(astNode)) {
-            return false;
-        }
-        if (_isModel(astNode)) {
-            return true;
-        }
-        if (astNode.$container) {
-            astNode = astNode.$container;
-        }
-        else {
-            return false;
-        }
-    }
-}
-export function isFqnRefInsideDeployment(astNode) {
-    while (true) {
-        if (_isModel(astNode)) {
-            return false;
-        }
-        if (_isDeployment(astNode)) {
-            return true;
-        }
-        if (astNode.$container) {
-            astNode = astNode.$container;
-        }
-        else {
-            return false;
-        }
-    }
-}

package/dist/browser-worker.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/browser-worker.js

@@ -1,4 +0,0 @@
-// This is an example copied as is from here:
-// https://github.com/microsoft/vscode-extension-samples/blob/main/lsp-web-extension-sample/server/src/browserServerMain.ts
-import { startLanguageServer } from './browser';
-startLanguageServer(self);

package/dist/browser.d.ts

@@ -1,10 +0,0 @@
-import { type LikeC4Services, type LikeC4SharedServices } from './module';
-export type { DocumentParser, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from './model';
-export type { LikeC4LanguageServices } from './LikeC4LanguageServices';
-export { createLanguageServices } from './module';
-export type { LikeC4Services, LikeC4SharedServices } from './module';
-export type { LikeC4Views } from './views';
-export declare function startLanguageServer(port: MessagePort | DedicatedWorkerGlobalScope): {
-    shared: LikeC4SharedServices;
-    likec4: LikeC4Services;
-};

package/dist/browser.js

@@ -1,34 +0,0 @@
-import { configureLogger, getConsoleSink, getTextFormatter } from '@likec4/log';
-import { startLanguageServer as startLanguim } from 'langium/lsp';
-import { BrowserMessageReader, BrowserMessageWriter, createConnection } from 'vscode-languageserver/browser';
-import { createLanguageServices } from './module';
-export { createLanguageServices } from './module';
-export function startLanguageServer(port) {
-    /* browser specific setup code */
-    const messageReader = new BrowserMessageReader(port);
-    const messageWriter = new BrowserMessageWriter(port);
-    const connection = createConnection(messageReader, messageWriter);
-    configureLogger({
-        sinks: {
-            console: getConsoleSink({
-                formatter: getTextFormatter({
-                    format: ({ level, category, message }) => {
-                        return `${level} ${category} ${message}`;
-                    },
-                }),
-            }),
-        },
-        loggers: [
-            {
-                category: 'likec4',
-                sinks: ['console'],
-                lowestLevel: 'debug',
-            },
-        ],
-    });
-    // Inject the shared services and language-specific services
-    const services = createLanguageServices({ connection });
-    // Start the language server with the shared services
-    startLanguim(services.shared);
-    return services;
-}

package/dist/bundled.d.ts

@@ -1,8 +0,0 @@
-import { type LikeC4Services, type LikeC4SharedServices } from './module';
-/**
- * This is used as `bin` entry point to start the language server.
- */
-export declare function startLanguageServer(): {
-    shared: LikeC4SharedServices;
-    likec4: LikeC4Services;
-};

package/dist/bundled.js

@@ -1,44 +0,0 @@
-import { configureLogger, getConsoleStderrSink } from '@likec4/log';
-import { startLanguageServer as startLanguim } from 'langium/lsp';
-import { createConnection, ProposedFeatures } from 'vscode-languageserver/node';
-import { LikeC4FileSystem } from './filesystem/LikeC4FileSystem';
-import { getLspConnectionSink, logger } from './logger';
-import { WithMCPServer } from './mcp/server/WithMCPServer';
-import { createLanguageServices } from './module';
-import { ConfigurableLayouter } from './views/ConfigurableLayouter';
-import { WithLikeC4ManualLayouts } from './views/LikeC4ManualLayouts';
-/**
- * This is used as `bin` entry point to start the language server.
- */
-export function startLanguageServer() {
-    const connection = createConnection(ProposedFeatures.all);
-    configureLogger({
-        sinks: {
-            // Name it as console to override internal logger
-            lsp: getLspConnectionSink(connection),
-            console: getConsoleStderrSink(),
-        },
-        loggers: [
-            {
-                category: ['likec4'],
-                sinks: ['console', 'lsp'],
-            },
-        ],
-    });
-    process.on('uncaughtException', (err) => {
-        logger.error('uncaughtException', { err });
-    });
-    process.on('unhandledRejection', (err) => {
-        logger.error('unhandledRejection', { err });
-    });
-    // Inject the shared services and language-specific services
-    const services = createLanguageServices({
-        connection,
-        ...LikeC4FileSystem(false),
-        ...WithMCPServer('sse'),
-        ...WithLikeC4ManualLayouts,
-    }, ConfigurableLayouter);
-    // Start the language server with the shared services
-    startLanguim(services.shared);
-    return services;
-}

package/dist/documentation/documentation-provider.d.ts

@@ -1,8 +0,0 @@
-import { type AstNode, type DocumentationProvider } from 'langium';
-import type { LikeC4Services } from '../module';
-export declare class LikeC4DocumentationProvider implements DocumentationProvider {
-    private parser;
-    private locator;
-    constructor(services: LikeC4Services);
-    getDocumentation(node: AstNode): string | undefined;
-}

package/dist/documentation/documentation-provider.js

@@ -1,51 +0,0 @@
-import { FqnRef } from '@likec4/core';
-import { AstUtils } from 'langium';
-import { ast } from '../ast';
-import { logWarnError } from '../logger';
-export class LikeC4DocumentationProvider {
-    parser;
-    locator;
-    constructor(services) {
-        this.parser = services.likec4.ModelParser;
-        this.locator = services.likec4.ModelLocator;
-    }
-    getDocumentation(node) {
-        try {
-            if (ast.isDeploymentNode(node)) {
-                const doc = AstUtils.getDocument(node);
-                const el = this.parser.forDocument(doc).parseDeploymentNode(node);
-                const lines = [el.id];
-                if (el.title !== node.name) {
-                    lines.push(' ', `**${el.title}**`);
-                }
-                return lines.join('  \n');
-            }
-            if (ast.isDeployedInstance(node)) {
-                const doc = AstUtils.getDocument(node);
-                const instance = this.parser.forDocument(doc).parseDeployedInstance(node);
-                const [projectId, fqn] = FqnRef.isImportRef(instance.element)
-                    ? [instance.element.project, instance.element.model]
-                    : [doc.likec4ProjectId, instance.element.model];
-                const el = projectId ? this.locator.getParsedElement(fqn, projectId) : this.locator.getParsedElement(fqn);
-                const lines = [instance.id, `_instance of_ ${fqn}`];
-                if (el) {
-                    lines.push(' ', `**${el.title}**`);
-                }
-                return lines.join('  \n');
-            }
-            if (ast.isElement(node)) {
-                const doc = AstUtils.getDocument(node);
-                const el = this.parser.forDocument(doc).parseElement(node);
-                if (!el) {
-                    return;
-                }
-                const lines = [el.id, ' ', `**${el.title}**`];
-                return lines.join('  \n');
-            }
-        }
-        catch (e) {
-            logWarnError(e);
-        }
-        return;
-    }
-}

package/dist/documentation/index.d.ts

@@ -1 +0,0 @@
-export { LikeC4DocumentationProvider } from './documentation-provider';

package/dist/documentation/index.js

@@ -1 +0,0 @@
-export { LikeC4DocumentationProvider } from './documentation-provider';

package/dist/empty.d.ts

@@ -1,2 +0,0 @@
-declare const _default: {};
-export default _default;

package/dist/empty.js

@@ -1,2 +0,0 @@
-// Just an empty placeholder to reduce bundle size (see build.config.ts)
-export default {};

package/dist/filesystem/ChokidarWatcher.d.ts

@@ -1,19 +0,0 @@
-import type { LikeC4SharedServices } from '../module';
-import type { FileSystemWatcher, FileSystemWatcherModuleContext } from './FileSystemWatcher';
-export declare const chokidarFileSystemWatcher: FileSystemWatcherModuleContext;
-/**
- * A no-op file system watcher.
- */
-export declare class ChokidarFileSystemWatcher implements FileSystemWatcher {
-    protected services: LikeC4SharedServices;
-    private watcher?;
-    private queue;
-    constructor(services: LikeC4SharedServices);
-    watch(folder: string): void;
-    dispose(): Promise<void>;
-    private createWatcher;
-    private enqueueFileOp;
-    private onAddOrChange;
-    private onRemove;
-    private onRemoveDir;
-}

package/dist/filesystem/ChokidarWatcher.js

@@ -1,133 +0,0 @@
-import { isLikeC4Config } from '@likec4/config/node';
-import chokidar from 'chokidar';
-import { URI } from 'langium';
-import PQueue from 'p-queue';
-import { logger as mainLogger } from '../logger';
-import { isManualLayoutFile } from '../views/LikeC4ManualLayouts';
-import { isLikeC4File } from './LikeC4FileSystem';
-const logger = mainLogger.getChild('chokidar');
-export const chokidarFileSystemWatcher = {
-    fileSystemWatcher: (services) => new ChokidarFileSystemWatcher(services),
-};
-const isAnyLikeC4File = (path) => isLikeC4File(path) || isLikeC4Config(path) || isManualLayoutFile(path);
-/**
- * A no-op file system watcher.
- */
-export class ChokidarFileSystemWatcher {
-    services;
-    watcher;
-    queue = new PQueue({ concurrency: 1, timeout: 5000 });
-    constructor(services) {
-        this.services = services;
-    }
-    watch(folder) {
-        if (this.watcher) {
-            logger.debug `add watching folder: ${folder}`;
-            this.watcher.add(folder);
-            return;
-        }
-        this.watcher = this.createWatcher(folder);
-    }
-    async dispose() {
-        if (this.watcher) {
-            const watcher = this.watcher;
-            this.watcher = undefined;
-            await watcher.close();
-        }
-        return;
-    }
-    createWatcher(folder) {
-        logger.debug `create watcher for folder: ${folder}`;
-        let watcher = chokidar.watch(folder, {
-            ignored: [
-                path => path.includes('node_modules') || path.includes('.git'),
-                (path, stats) => (!!stats && stats.isFile() && !isAnyLikeC4File(path)),
-            ],
-            followSymlinks: true,
-            ignoreInitial: true,
-        });
-        const onAddOrChange = (path, stats) => {
-            if (stats?.isDirectory()) {
-                return;
-            }
-            this.enqueueFileOp('addOrChange: ' + path, async () => {
-                await this.onAddOrChange(path);
-            });
-        };
-        const onRemove = (path, stats) => {
-            if (stats?.isDirectory()) {
-                return;
-            }
-            this.enqueueFileOp('remove: ' + path, async () => {
-                await this.onRemove(path);
-            });
-        };
-        watcher.on('add', onAddOrChange)
-            .on('change', onAddOrChange)
-            .on('unlink', onRemove)
-            .on('unlinkDir', (path) => {
-            this.enqueueFileOp('removeDir: ' + path, async () => {
-                await this.onRemoveDir(path);
-            });
-        });
-        return watcher;
-    }
-    enqueueFileOp(fileop, fn) {
-        this.queue.add(async () => {
-            try {
-                await fn();
-            }
-            catch (error) {
-                logger.warn(`Failed on ${fileop}`, { error });
-            }
-        }).catch(error => {
-            logger.error(`Error on ${fileop}`, { error });
-        });
-    }
-    async onAddOrChange(path) {
-        const pm = this.services.workspace.ProjectsManager;
-        if (isLikeC4Config(path)) {
-            logger.debug `project file changed: ${path}`;
-            await pm.registerConfigFile(URI.file(path));
-        }
-        else if (isLikeC4File(path)) {
-            logger.debug `file changed: ${path}`;
-            await this.services.workspace.DocumentBuilder.update([URI.file(path)], []);
-        }
-        else if (isManualLayoutFile(path)) {
-            logger.debug `manual layout file changed: ${path}`;
-            const projectId = pm.belongsTo(URI.file(path));
-            await pm.rebuidProject(projectId);
-        }
-        else {
-            logger.warn `Unknown file change: ${path}`;
-        }
-    }
-    async onRemove(path) {
-        const pm = this.services.workspace.ProjectsManager;
-        if (isLikeC4Config(path)) {
-            logger.debug `project file removed: ${path}`;
-            await pm.reloadProjects();
-        }
-        else if (isLikeC4File(path)) {
-            logger.debug `file removed: ${path}`;
-            await this.services.workspace.DocumentBuilder.update([], [URI.file(path)]);
-        }
-        else if (isManualLayoutFile(path)) {
-            logger.debug `manual layout file removed: ${path}`;
-            const project = pm.belongsTo(path);
-            await pm.rebuidProject(project);
-        }
-        else {
-            logger.warn `Unknown file removal: ${path}`;
-        }
-    }
-    async onRemoveDir(path) {
-        logger.debug `directory removed: ${path}`;
-        const pm = this.services.workspace.ProjectsManager;
-        const projects = pm.findAllProjectsByFolder(path);
-        if (projects.length > 0) {
-            await pm.reloadProjects();
-        }
-    }
-}

package/dist/filesystem/FileSystemWatcher.d.ts

@@ -1,19 +0,0 @@
-import type { AsyncDisposable } from 'langium';
-import type { LikeC4SharedServices } from '../module';
-export interface FileSystemWatcherModuleContext {
-    fileSystemWatcher: (services: LikeC4SharedServices) => FileSystemWatcher;
-}
-export declare const noopFileSystemWatcher: FileSystemWatcherModuleContext;
-export interface FileSystemWatcher extends AsyncDisposable {
-    /**
-     * Watches a folder for changes and triggers a reload of the documents and projects.
-     */
-    watch(folder: string): void;
-}
-/**
- * A no-op file system watcher.
- */
-export declare class NoopFileSystemWatcher implements FileSystemWatcher {
-    watch(): void;
-    dispose(): Promise<void>;
-}

package/dist/filesystem/FileSystemWatcher.js

@@ -1,14 +0,0 @@
-export const noopFileSystemWatcher = {
-    fileSystemWatcher: () => new NoopFileSystemWatcher(),
-};
-/**
- * A no-op file system watcher.
- */
-export class NoopFileSystemWatcher {
-    watch() {
-        return;
-    }
-    dispose() {
-        return Promise.resolve();
-    }
-}

package/dist/filesystem/LikeC4FileSystem.d.ts

@@ -1,3 +0,0 @@
-import type { FileSystemModuleContext } from './index';
-export declare const LikeC4FileSystem: (ehableWatcher?: boolean) => FileSystemModuleContext;
-export declare const isLikeC4File: (path: string, isDirectory?: boolean) => boolean;