@likec4/language-server 1.42.1 → 1.44.0

package/dist/ast.js

@@ -0,0 +1,253 @@
+import { 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) {
+    return doc.textDocument.languageId === LikeC4LanguageMetaData.languageId;
+}
+export function isParsedLikeC4LangiumDocument(doc) {
+    return (isLikeC4LangiumDocument(doc)
+        && doc.state == DocumentState.Validated
+        && !!doc.c4Specification
+        && !!doc.c4Elements
+        && !!doc.c4ExtendElements
+        && !!doc.c4ExtendDeployments
+        && !!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.js

@@ -0,0 +1,4 @@
+// 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.js

@@ -0,0 +1,35 @@
+import { configureLogger, getAnsiColorFormatter, getConsoleSink } from '@likec4/log';
+import { startLanguageServer as startLanguim } from 'langium/lsp';
+import { BrowserMessageReader, BrowserMessageWriter, createConnection } from 'vscode-languageserver/browser';
+import { createLanguageServices } from './module';
+export { logger as lspLogger } from './logger';
+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: getAnsiColorFormatter({
+                    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.js

@@ -0,0 +1,42 @@
+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';
+/**
+ * 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'),
+    }, ConfigurableLayouter);
+    // Start the language server with the shared services
+    startLanguim(services.shared);
+    return services;
+}