@likec4/language-server 1.46.4 → 1.48.0

package/dist/model-change/ModelChanges.js

@@ -1,129 +0,0 @@
-import { invariant, nonexhaustive } from '@likec4/core';
-import { loggable, wrapError } from '@likec4/log';
-import { Range, TextEdit } from 'vscode-languageserver-types';
-import { logger as mainLogger } from '../logger';
-import { changeElementStyle } from './changeElementStyle';
-import { changeViewLayout } from './changeViewLayout';
-import { removeManualLayoutV1 } from './removeManualLayoutV1';
-const logger = mainLogger.getChild('model-changes');
-export class LikeC4ModelChanges {
-    services;
-    locator;
-    constructor(services) {
-        this.services = services;
-        this.locator = services.likec4.ModelLocator;
-    }
-    async applyChange(changeView) {
-        const lspConnection = this.services.shared.lsp.Connection;
-        try {
-            let { viewId, projectId: _projectId, change } = changeView;
-            const project = this.services.shared.workspace.ProjectsManager.ensureProject(_projectId);
-            logger.debug `Applying model change ${change.op} to view ${viewId} in project ${project.id}`;
-            const lookup = this.locator.locateViewAst(viewId, project.id);
-            if (!lookup) {
-                throw new Error(`View ${viewId} not found in project ${project.id}`);
-            }
-            const textDocument = {
-                uri: lookup.doc.textDocument.uri,
-                version: lookup.doc.textDocument.version,
-            };
-            // TODO refactor to use separate methods for save/reset operations
-            if (change.op === 'save-view-snapshot') {
-                invariant(viewId === change.layout.id, 'View ID does not match, expected ' + viewId + ', got ' + change.layout.id);
-                // If there is an existing manual layout v1
-                if (lookup.view.manualLayout) {
-                    // We clean it up
-                    await removeManualLayoutV1(this.services, { lookup }).catch(err => {
-                        logger.warn(`Failed to remove manual layout v1 for view ${viewId} in project ${project.id}`, { err });
-                    });
-                }
-                const location = await this.services.likec4.ManualLayouts.write(project, change.layout);
-                return {
-                    success: true,
-                    location,
-                };
-            }
-            if (change.op === 'reset-manual-layout') {
-                // If there is an existing manual layout v1
-                if (lookup.view.manualLayout) {
-                    // We clean it up
-                    await removeManualLayoutV1(this.services, { lookup }).catch(err => {
-                        logger.warn(`Failed to remove manual layout v1 for view ${viewId} in project ${project.id}`, { err });
-                    });
-                }
-                const location = await this.services.likec4.ManualLayouts.remove(project, viewId);
-                return {
-                    success: true,
-                    location,
-                };
-            }
-            invariant(lspConnection, 'This change only supported in IDE (running as Extension)');
-            const { edits, modifiedRange } = this.convertToTextEdit({
-                lookup,
-                change,
-            });
-            if (!edits.length) {
-                return {
-                    success: false,
-                    error: 'No changes to apply',
-                };
-            }
-            const applyResult = await lspConnection.workspace.applyEdit({
-                label: `LikeC4 - change view ${changeView.viewId}`,
-                edit: {
-                    changes: {
-                        [textDocument.uri]: edits,
-                    },
-                },
-            });
-            if (!applyResult.applied) {
-                lspConnection.window.showErrorMessage(`Failed to apply changes ${applyResult.failureReason}`);
-                return {
-                    success: false,
-                    error: `Failed to apply changes ${applyResult.failureReason}`,
-                };
-            }
-            return {
-                success: true,
-                location: {
-                    uri: textDocument.uri,
-                    range: modifiedRange,
-                },
-            };
-        }
-        catch (err) {
-            const error = loggable(wrapError(err, `Failed to apply change ${changeView.change.op} ${changeView.viewId}`));
-            logger.error(error);
-            return {
-                success: false,
-                error,
-            };
-        }
-        finally {
-            this.services.likec4.ModelBuilder.clearCache();
-        }
-    }
-    convertToTextEdit({ lookup, change }) {
-        switch (change.op) {
-            case 'change-element-style': {
-                return changeElementStyle(this.services, {
-                    ...lookup,
-                    targets: change.targets,
-                    style: change.style,
-                });
-            }
-            case 'change-autolayout': {
-                const edit = changeViewLayout(this.services, {
-                    ...lookup,
-                    layout: change.layout,
-                });
-                return {
-                    modifiedRange: edit.range,
-                    edits: [edit],
-                };
-            }
-            default:
-                nonexhaustive(change);
-        }
-    }
-}

package/dist/model-change/changeElementStyle.d.ts

@@ -1,16 +0,0 @@
-import { type DeploymentFqn, type Fqn, type NonEmptyArray, type ViewChange } from '@likec4/core';
-import { type Range, TextEdit } from 'vscode-languageserver-types';
-import { type ParsedAstView, type ParsedLikeC4LangiumDocument, ast } from '../ast';
-import type { LikeC4Services } from '../module';
-type ChangeElementStyleArg = {
-    view: ParsedAstView;
-    doc: ParsedLikeC4LangiumDocument;
-    viewAst: ast.LikeC4View;
-    targets: NonEmptyArray<Fqn | DeploymentFqn>;
-    style: ViewChange.ChangeElementStyle['style'];
-};
-export declare function changeElementStyle(services: LikeC4Services, { view, viewAst, targets, style, }: ChangeElementStyleArg): {
-    modifiedRange: Range;
-    edits: TextEdit[];
-};
-export {};

package/dist/model-change/changeElementStyle.js

@@ -1,134 +0,0 @@
-import { _type, invariant, isAncestor, } from '@likec4/core';
-import { GrammarUtils } from 'langium';
-import { entries, filter, findLast, isTruthy, last } from 'remeda';
-import { TextEdit } from 'vscode-languageserver-types';
-import { ast } from '../ast';
-const { findNodeForKeyword } = GrammarUtils;
-const asViewStyleRule = (target, style, indent = 0) => {
-    const indentStr = indent > 0 ? ' '.repeat(indent) : '';
-    return [
-        indentStr + `style ${target} {`,
-        ...entries(style).map(([key, value]) => indentStr + `  ${key} ${key === 'opacity' ? value.toString() + '%' : value}`),
-        indentStr + `}`,
-    ];
-};
-/**
- * - is ViewRuleStyle
- * - has exactly one target
- * - the target is an ElementRef to the given fqn
- */
-const isMatchingViewRule = (fqn, index) => (rule) => {
-    if (!ast.isViewRuleStyle(rule) && !ast.isDeploymentViewRuleStyle(rule)) {
-        return false;
-    }
-    const target = rule.targets.value;
-    if (!target || isTruthy(rule.targets.prev) || target.$type !== 'FqnRefExpr' || isTruthy(target.selector)) {
-        return false;
-    }
-    const ref = target.ref?.value?.ref;
-    const _fqn = ref ? index.resolve(ref) : null;
-    return _fqn === fqn;
-};
-export function changeElementStyle(services, { view, viewAst, targets, style, }) {
-    // Should never happen
-    invariant(viewAst.body, `View ${view.id} has no body`);
-    const viewCstNode = viewAst.$cstNode;
-    invariant(viewCstNode, 'viewCstNode');
-    const insertPos = last(viewAst.body.rules)?.$cstNode?.range.end
-        ?? viewAst.body.$cstNode?.range.end;
-    invariant(insertPos, 'insertPos is not defined');
-    const indent = viewCstNode.range.start.character + 2;
-    const fqnIndex = services.likec4.FqnIndex;
-    const styleRules = filter(viewAst.body.rules, (r) => ast.isViewRuleStyle(r) || ast.isDeploymentViewRuleStyle(r));
-    const viewOf = view[_type] === 'element' ? view.viewOf ?? null : null;
-    // Find existing rules
-    const existing = [];
-    const insert = [];
-    // const existingRules = [] as Array<{ fqn: Fqn, rule: ast.ViewRuleStyle }>
-    targets.forEach(target => {
-        const rule = findLast(styleRules, isMatchingViewRule(target, fqnIndex));
-        // remove viewOf from the target to shorten the fqn
-        const fqn = (viewOf && isAncestor(viewOf, target) ? target.substring(viewOf.length + 1) : target);
-        if (rule) {
-            existing.push({ fqn, rule });
-        }
-        else {
-            insert.push({ fqn });
-        }
-    });
-    const modifiedRange = {
-        start: insertPos,
-        end: insertPos,
-    };
-    const includeRange = (range) => {
-        if (range.start.line <= modifiedRange.start.line) {
-            if (range.start.line == modifiedRange.start.line) {
-                modifiedRange.start.character = Math.min(range.start.character, modifiedRange.start.character);
-            }
-            else {
-                modifiedRange.start = range.start;
-            }
-        }
-        if (range.end.line >= modifiedRange.end.line) {
-            if (range.end.line == modifiedRange.end.line) {
-                modifiedRange.end.character = Math.max(range.end.character, modifiedRange.end.character);
-            }
-            else {
-                modifiedRange.end = range.end;
-            }
-        }
-    };
-    const edits = [];
-    if (insert.length > 0) {
-        const linesToInsert = insert.flatMap(({ fqn }) => asViewStyleRule(fqn, style, indent));
-        edits.push(TextEdit.insert(insertPos, '\n' + linesToInsert.join('\n')));
-        modifiedRange.start = {
-            line: insertPos.line + 1,
-            character: indent,
-        };
-        modifiedRange.end = {
-            line: insertPos.line + linesToInsert.length,
-            character: (last(linesToInsert)?.length ?? 0),
-        };
-    }
-    if (existing.length > 0) {
-        for (const { rule } of existing) {
-            const ruleCstNode = rule.$cstNode;
-            invariant(ruleCstNode, 'RuleCstNode not found');
-            for (const [key, _value] of entries(style)) {
-                const value = key === 'opacity' ? _value.toString() + '%' : _value;
-                const ruleProp = rule.props.find(p => p.key === key);
-                // replace existing  property
-                if (ruleProp && ruleProp.$cstNode) {
-                    const { range: { start, end } } = ruleProp.$cstNode;
-                    includeRange({
-                        start,
-                        end,
-                    });
-                    edits.push(TextEdit.replace({ start, end }, key + ' ' + value));
-                    continue;
-                }
-                // insert new style property right after the opening brace
-                const insertPos = findNodeForKeyword(ruleCstNode, '{')?.range.end;
-                invariant(insertPos, 'Opening brace not found');
-                const indentStr = ' '.repeat(ruleCstNode.range.start.character) + '\t';
-                const insertKeyValue = indentStr + key + ' ' + value;
-                edits.push(TextEdit.insert(insertPos, '\n' + insertKeyValue));
-                includeRange({
-                    start: {
-                        line: insertPos.line + 1,
-                        character: indentStr.length,
-                    },
-                    end: {
-                        line: insertPos.line + 1,
-                        character: insertKeyValue.length,
-                    },
-                });
-            }
-        }
-    }
-    return {
-        modifiedRange,
-        edits,
-    };
-}

package/dist/model-change/changeViewLayout.d.ts

@@ -1,12 +0,0 @@
-import { type ViewChange } from '@likec4/core';
-import { TextEdit } from 'vscode-languageserver-types';
-import { type ParsedAstView, type ParsedLikeC4LangiumDocument, ast } from '../ast';
-import type { LikeC4Services } from '../module';
-type ChangeViewLayoutArg = {
-    view: ParsedAstView;
-    doc: ParsedLikeC4LangiumDocument;
-    viewAst: ast.LikeC4View;
-    layout: ViewChange.ChangeAutoLayout['layout'];
-};
-export declare function changeViewLayout(_services: LikeC4Services, { view, viewAst, layout, }: ChangeViewLayoutArg): TextEdit;
-export {};

package/dist/model-change/changeViewLayout.js

@@ -1,28 +0,0 @@
-import { invariant } from '@likec4/core';
-import { GrammarUtils } from 'langium';
-import { findLast, isNumber } from 'remeda';
-import { TextEdit } from 'vscode-languageserver-types';
-import { ast, toAstViewLayoutDirection } from '../ast';
-const { findNodeForKeyword } = GrammarUtils;
-export function changeViewLayout(_services, { view, viewAst, layout, }) {
-    // Should never happen
-    invariant(viewAst.body, `View ${view.id} has no body`);
-    const viewCstNode = viewAst.$cstNode;
-    invariant(viewCstNode, 'viewCstNode');
-    const newdirection = toAstViewLayoutDirection(layout.direction);
-    const existingRule = findLast(viewAst.body.rules, ast.isViewRuleAutoLayout);
-    let newRule = `autoLayout ${newdirection}`;
-    if (isNumber(layout.rankSep)) {
-        newRule += ` ${layout.rankSep}`;
-        if (isNumber(layout.nodeSep)) {
-            newRule += ` ${layout.nodeSep}`;
-        }
-    }
-    if (existingRule && existingRule.$cstNode) {
-        return TextEdit.replace(existingRule.$cstNode.range, newRule);
-    }
-    const insertPos = findNodeForKeyword(viewAst.body.$cstNode, '}')?.range.start;
-    invariant(insertPos, 'Closing brace not found');
-    const insert = `\t${newRule}\n\t`;
-    return TextEdit.insert(insertPos, insert);
-}

package/dist/model-change/removeManualLayoutV1.d.ts

@@ -1,7 +0,0 @@
-import type { ViewLocateResult } from '../model/model-locator';
-import type { LikeC4Services } from '../module';
-type RemoveManualLayoutV1Args = {
-    lookup: ViewLocateResult;
-};
-export declare function removeManualLayoutV1(services: LikeC4Services, { lookup, }: RemoveManualLayoutV1Args): Promise<boolean>;
-export {};

package/dist/model-change/removeManualLayoutV1.js

@@ -1,27 +0,0 @@
-import { invariant } from '@likec4/core';
-import { CstUtils } from 'langium';
-import { TextEdit } from 'vscode-languageserver-types';
-import { hasManualLayout } from '../view-utils/manual-layout';
-export async function removeManualLayoutV1(services, { lookup, }) {
-    // No manual layout v1 present
-    if (!lookup.view.manualLayout) {
-        return false;
-    }
-    const cstnode = lookup.viewAst.$cstNode;
-    invariant(cstnode, 'invalid view.$cstNode');
-    const lspConnection = services.shared.lsp.Connection;
-    invariant(lspConnection, 'LSP Connection not available');
-    const commentCst = CstUtils.findCommentNode(cstnode, ['BLOCK_COMMENT']);
-    if (commentCst && hasManualLayout(commentCst.text)) {
-        const edit = await lspConnection.workspace.applyEdit({
-            label: `LikeC4 - remove manual layout v1 for ${lookup.view.id}`,
-            edit: {
-                changes: {
-                    [lookup.doc.textDocument.uri]: [TextEdit.del(commentCst.range)],
-                },
-            },
-        });
-        return edit.applied;
-    }
-    return false;
-}

package/dist/module.d.ts

@@ -1,92 +0,0 @@
-import { QueueGraphvizLayoter } from '@likec4/layouts';
-import { type Module, WorkspaceCache } from 'langium';
-import { type DefaultSharedModuleContext, type LangiumServices, type LangiumSharedServices, type PartialLangiumServices } from 'langium/lsp';
-import { LikeC4DocumentationProvider } from './documentation';
-import { type FileSystemModuleContext, type FileSystemProvider, type FileSystemWatcher } from './filesystem';
-import { LikeC4Formatter } from './formatting/LikeC4Formatter';
-import { type LikeC4LanguageServices } from './LikeC4LanguageServices';
-import { LikeC4CodeActionProvider, LikeC4CodeLensProvider, LikeC4CompletionProvider, LikeC4DocumentHighlightProvider, LikeC4DocumentLinkProvider, LikeC4DocumentSymbolProvider, LikeC4HoverProvider, LikeC4SemanticTokenProvider } from './lsp';
-import { type LikeC4MCPServer, type LikeC4MCPServerModuleContext } from './mcp/interfaces';
-import { LikeC4MCPServerFactory } from './mcp/MCPServerFactory';
-import { type LikeC4ModelBuilder, DeploymentsIndex, FqnIndex, LikeC4ModelLocator, LikeC4ModelParser, LikeC4ValueConverter } from './model';
-import { LikeC4ModelChanges } from './model-change/ModelChanges';
-import { LikeC4NameProvider, LikeC4ScopeComputation, LikeC4ScopeProvider } from './references';
-import { Rpc } from './Rpc';
-import { NodeKindProvider, WorkspaceSymbolProvider } from './shared';
-import { LikeC4DocumentValidator } from './validation';
-import { type LikeC4ManualLayouts, type LikeC4Views } from './views';
-import type { LikeC4ManualLayoutsModuleContext } from './views/LikeC4ManualLayouts';
-import { IndexManager, LangiumDocuments, LikeC4WorkspaceManager, ProjectsManager } from './workspace';
-export type LanguageServicesContext = Omit<DefaultSharedModuleContext, 'fileSystemProvider'> & FileSystemModuleContext & LikeC4MCPServerModuleContext & LikeC4ManualLayoutsModuleContext;
-interface LikeC4AddedSharedServices {
-    lsp: {
-        NodeKindProvider: NodeKindProvider;
-        WorkspaceSymbolProvider: WorkspaceSymbolProvider;
-    };
-    workspace: {
-        Cache: WorkspaceCache<string, any>;
-        ProjectsManager: ProjectsManager;
-        IndexManager: IndexManager;
-        LangiumDocuments: LangiumDocuments;
-        WorkspaceManager: LikeC4WorkspaceManager;
-        FileSystemProvider: FileSystemProvider;
-        FileSystemWatcher: FileSystemWatcher;
-    };
-}
-export type LikeC4SharedServices = LangiumSharedServices & LikeC4AddedSharedServices;
-/**
- * Declaration of custom services - add your own service classes here.
- */
-export interface LikeC4AddedServices {
-    documentation: {
-        DocumentationProvider: LikeC4DocumentationProvider;
-    };
-    validation: {
-        DocumentValidator: LikeC4DocumentValidator;
-    };
-    Rpc: Rpc;
-    mcp: {
-        Server: LikeC4MCPServer;
-        ServerFactory: LikeC4MCPServerFactory;
-    };
-    likec4: {
-        LanguageServices: LikeC4LanguageServices;
-        Views: LikeC4Views;
-        ManualLayouts: LikeC4ManualLayouts;
-        Layouter: QueueGraphvizLayoter;
-        DeploymentsIndex: DeploymentsIndex;
-        FqnIndex: FqnIndex;
-        ModelParser: LikeC4ModelParser;
-        ModelBuilder: LikeC4ModelBuilder;
-        ModelLocator: LikeC4ModelLocator;
-        ModelChanges: LikeC4ModelChanges;
-    };
-    lsp: {
-        CompletionProvider: LikeC4CompletionProvider;
-        DocumentHighlightProvider: LikeC4DocumentHighlightProvider;
-        DocumentSymbolProvider: LikeC4DocumentSymbolProvider;
-        SemanticTokenProvider: LikeC4SemanticTokenProvider;
-        HoverProvider: LikeC4HoverProvider;
-        CodeLensProvider: LikeC4CodeLensProvider;
-        DocumentLinkProvider: LikeC4DocumentLinkProvider;
-        Formatter: LikeC4Formatter;
-        CodeActionProvider: LikeC4CodeActionProvider;
-    };
-    references: {
-        NameProvider: LikeC4NameProvider;
-        ScopeComputation: LikeC4ScopeComputation;
-        ScopeProvider: LikeC4ScopeProvider;
-    };
-    shared?: LikeC4SharedServices;
-    parser: {
-        ValueConverter: LikeC4ValueConverter;
-    };
-}
-export type LikeC4Services = LangiumServices & LikeC4AddedServices;
-export declare const createLikeC4Module: (context: LikeC4MCPServerModuleContext & LikeC4ManualLayoutsModuleContext) => Module<LikeC4Services, PartialLangiumServices & LikeC4AddedServices>;
-export declare function createLanguageServices<I1, I2, I3, I extends I1 & I2 & I3 & LikeC4Services>(context: Partial<LanguageServicesContext>, module?: Module<I, I1>, module2?: Module<I, I2>, module3?: Module<I, I3>): {
-    shared: LikeC4SharedServices;
-    likec4: I;
-};
-export declare function createSharedServices(context?: Partial<LanguageServicesContext>): LikeC4SharedServices;
-export {};

package/dist/module.js

@@ -1,143 +0,0 @@
-import { onNextTick } from '@likec4/core/utils';
-import { GraphvizWasmAdapter, QueueGraphvizLayoter } from '@likec4/layouts';
-import { DocumentState, inject, WorkspaceCache, } from 'langium';
-import { createDefaultModule, createDefaultSharedModule, } from 'langium/lsp';
-import { LikeC4DocumentationProvider } from './documentation';
-import { NoopFileSystem, } from './filesystem';
-import { LikeC4Formatter } from './formatting/LikeC4Formatter';
-import { LikeC4GeneratedModule, LikeC4GeneratedSharedModule, } from './generated/module';
-import { DefaultLikeC4LanguageServices } from './LikeC4LanguageServices';
-import { LikeC4CodeActionProvider, LikeC4CodeLensProvider, LikeC4CompletionProvider, LikeC4DocumentHighlightProvider, LikeC4DocumentLinkProvider, LikeC4DocumentSymbolProvider, LikeC4HoverProvider, LikeC4SemanticTokenProvider, } from './lsp';
-import { NoMCPServer, } from './mcp/interfaces';
-import { LikeC4MCPServerFactory } from './mcp/MCPServerFactory';
-import { DefaultLikeC4ModelBuilder, DeploymentsIndex, FqnIndex, LikeC4ModelLocator, LikeC4ModelParser, LikeC4ValueConverter, } from './model';
-import { LikeC4ModelChanges } from './model-change/ModelChanges';
-import { LikeC4NameProvider, LikeC4ScopeComputation, LikeC4ScopeProvider, } from './references';
-import { Rpc } from './Rpc';
-import { NodeKindProvider, WorkspaceSymbolProvider, } from './shared';
-import { LikeC4DocumentValidator, registerValidationChecks } from './validation';
-import { DefaultLikeC4Views, NoopLikeC4ManualLayouts } from './views';
-import { AstNodeDescriptionProvider, IndexManager, LangiumDocuments, LikeC4WorkspaceManager, ProjectsManager, } from './workspace';
-const createLikeC4SharedModule = (context) => ({
-    lsp: {
-        NodeKindProvider: services => new NodeKindProvider(services),
-        WorkspaceSymbolProvider: services => new WorkspaceSymbolProvider(services),
-    },
-    workspace: {
-        Cache: services => new WorkspaceCache(services, DocumentState.Validated),
-        IndexManager: services => new IndexManager(services),
-        LangiumDocuments: services => new LangiumDocuments(services),
-        ProjectsManager: services => new ProjectsManager(services),
-        WorkspaceManager: services => new LikeC4WorkspaceManager(services),
-        FileSystemProvider: services => context.fileSystemProvider(services),
-        FileSystemWatcher: services => context.fileSystemWatcher(services),
-    },
-});
-function bind(Type) {
-    return (services) => new Type(services);
-}
-export const createLikeC4Module = (context) => ({
-    documentation: {
-        DocumentationProvider: bind(LikeC4DocumentationProvider),
-    },
-    validation: {
-        DocumentValidator: bind(LikeC4DocumentValidator),
-    },
-    Rpc: bind(Rpc),
-    mcp: {
-        Server: (services) => context.mcpServer(services),
-        ServerFactory: bind(LikeC4MCPServerFactory),
-    },
-    likec4: {
-        LanguageServices: bind(DefaultLikeC4LanguageServices),
-        Layouter: (_services) => {
-            return new QueueGraphvizLayoter({
-                graphviz: new GraphvizWasmAdapter(),
-            });
-        },
-        Views: bind(DefaultLikeC4Views),
-        ManualLayouts: (services) => context.manualLayouts(services),
-        DeploymentsIndex: bind(DeploymentsIndex),
-        ModelChanges: bind(LikeC4ModelChanges),
-        FqnIndex: bind(FqnIndex),
-        ModelParser: bind(LikeC4ModelParser),
-        ModelBuilder: bind(DefaultLikeC4ModelBuilder),
-        ModelLocator: bind(LikeC4ModelLocator),
-    },
-    lsp: {
-        // RenameProvider: bind(LikeC4RenameProvider),
-        CompletionProvider: bind(LikeC4CompletionProvider),
-        DocumentHighlightProvider: bind(LikeC4DocumentHighlightProvider),
-        DocumentSymbolProvider: bind(LikeC4DocumentSymbolProvider),
-        SemanticTokenProvider: bind(LikeC4SemanticTokenProvider),
-        HoverProvider: bind(LikeC4HoverProvider),
-        CodeLensProvider: bind(LikeC4CodeLensProvider),
-        DocumentLinkProvider: bind(LikeC4DocumentLinkProvider),
-        Formatter: bind(LikeC4Formatter),
-        CodeActionProvider: bind(LikeC4CodeActionProvider),
-    },
-    workspace: {
-        AstNodeDescriptionProvider: bind(AstNodeDescriptionProvider),
-    },
-    references: {
-        NameProvider: bind(LikeC4NameProvider),
-        ScopeComputation: bind(LikeC4ScopeComputation),
-        ScopeProvider: bind(LikeC4ScopeProvider),
-    },
-    parser: {
-        ValueConverter: bind(LikeC4ValueConverter),
-    },
-});
-export function createLanguageServices(context, module, module2, module3) {
-    const shared = createSharedServices(context);
-    const modules = [
-        createDefaultModule({ shared }),
-        LikeC4GeneratedModule,
-        createLikeC4Module({
-            ...NoMCPServer,
-            ...NoopLikeC4ManualLayouts,
-            ...context,
-        }),
-        module,
-        module2,
-        module3,
-    ].reduce(_merge, {});
-    const likec4 = inject(modules);
-    shared.ServiceRegistry.register(likec4);
-    registerValidationChecks(likec4);
-    if (!context.connection) {
-        // We don't run inside a language server
-        // Therefore, initialize the configuration provider instantly
-        void shared.workspace.ConfigurationProvider.initialized({});
-    }
-    else {
-        onNextTick(() => likec4.Rpc.init());
-    }
-    return { shared, likec4 };
-}
-export function createSharedServices(context = {}) {
-    const moduleContext = {
-        ...NoMCPServer,
-        ...NoopFileSystem,
-        ...NoopLikeC4ManualLayouts,
-        ...context,
-    };
-    return inject(createDefaultSharedModule(moduleContext), LikeC4GeneratedSharedModule, createLikeC4SharedModule(moduleContext));
-}
-// Copied from langium/src/dependency-injection.ts as it is not exported
-function _merge(target, source) {
-    if (source) {
-        for (const [key, value2] of Object.entries(source)) {
-            if (value2 !== undefined) {
-                const value1 = target[key];
-                if (value1 !== null && value2 !== null && typeof value1 === 'object' && typeof value2 === 'object') {
-                    target[key] = _merge(value1, value2);
-                }
-                else {
-                    target[key] = value2;
-                }
-            }
-        }
-    }
-    return target;
-}