@likec4/language-server 1.43.0 → 1.45.0

package/dist/documentation/documentation-provider.js

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

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

package/dist/empty.js

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

package/dist/filesystem/ChokidarWatcher.d.ts

@@ -7,8 +7,10 @@ export declare const chokidarFileSystemWatcher: FileSystemWatcherModuleContext;
 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;
 }

package/dist/filesystem/ChokidarWatcher.js

@@ -0,0 +1,108 @@
+import { isLikeC4Config } from '@likec4/config/node';
+import { loggable } from '@likec4/log';
+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) {
+            this.watcher.add(folder);
+        }
+        else {
+            this.watcher = this.createWatcher(folder);
+        }
+        logger.debug `watching folder: ${folder}`;
+    }
+    async dispose() {
+        if (this.watcher) {
+            const watcher = this.watcher;
+            this.watcher = undefined;
+            await watcher.close();
+        }
+        return;
+    }
+    createWatcher(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) => {
+            this.enqueueFileOp('addOrChange: ' + path, async () => {
+                if (isLikeC4Config(path)) {
+                    logger.debug `project file changed: ${path}`;
+                    await this.services.workspace.ProjectsManager.reloadProjects();
+                }
+                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}`;
+                    // TODO: optimize to only reload manual layouts instead of all projects
+                    await this.services.workspace.ProjectsManager.reloadProjects();
+                }
+                else {
+                    logger.warn `Unknown file change: ${path}`;
+                }
+            });
+        };
+        const onRemove = (path) => {
+            this.enqueueFileOp('remove: ' + path, async () => {
+                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}`;
+                }
+            });
+        };
+        watcher.on('add', onAddOrChange)
+            .on('change', onAddOrChange)
+            .on('unlink', onRemove);
+        return watcher;
+    }
+    enqueueFileOp(fileop, fn) {
+        this.queue.add(async () => {
+            try {
+                await fn();
+            }
+            catch (error) {
+                logger.warn(`Failed on ${fileop}`, { error });
+            }
+        }).catch(error => {
+            logger.error(loggable(error));
+        });
+    }
+}

package/dist/filesystem/FileSystemWatcher.js

@@ -0,0 +1,14 @@
+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,4 +1,3 @@
 import type { FileSystemModuleContext } from './index';
 export declare const LikeC4FileSystem: (ehableWatcher?: boolean) => FileSystemModuleContext;
-export declare const isLikeC4File: (path: string) => any;
-export declare const isAnyLikeC4File: (path: string) => any;
+export declare const isLikeC4File: (path: string) => boolean;

package/dist/filesystem/LikeC4FileSystem.js

@@ -0,0 +1,126 @@
+import { isLikeC4Config, loadConfig } from '@likec4/config/node';
+import { fdir } from 'fdir';
+import { URI } from 'langium';
+import { NodeFileSystemProvider } from 'langium/node';
+import { mkdirSync } from 'node:fs';
+import { stat, unlink, writeFile } from 'node:fs/promises';
+import { basename, dirname } from 'node:path';
+import { LikeC4LanguageMetaData } from '../generated/module';
+import { Content, isLikeC4Builtin } from '../likec4lib';
+import { logger as rootLogger } from '../logger';
+import { chokidarFileSystemWatcher } from './ChokidarWatcher';
+import { noopFileSystemWatcher } from './FileSystemWatcher';
+const logger = rootLogger.getChild('filesystem');
+export const LikeC4FileSystem = (ehableWatcher = true) => ({
+    fileSystemProvider: () => new SymLinkTraversingFileSystemProvider(),
+    ...ehableWatcher ? chokidarFileSystemWatcher : noopFileSystemWatcher,
+});
+export const isLikeC4File = (path) => LikeC4LanguageMetaData.fileExtensions.some((ext) => path.endsWith(ext));
+/**
+ * A file system provider that follows symbolic links.
+ * @see https://github.com/likec4/likec4/pull/1213
+ */
+class SymLinkTraversingFileSystemProvider extends NodeFileSystemProvider {
+    async readFile(uri) {
+        if (isLikeC4Builtin(uri)) {
+            return Promise.resolve(Content);
+        }
+        try {
+            return await super.readFile(uri);
+        }
+        catch (error) {
+            logger.warn(`Failed to read file ${uri.fsPath}`, { error });
+            return '';
+        }
+    }
+    async readDirectory(folderPath, opts) {
+        const recursive = opts?.recursive ?? true;
+        const entries = [];
+        try {
+            let crawler = new fdir()
+                .withSymlinks({ resolvePaths: false })
+                .withFullPaths()
+                .filter(isLikeC4File);
+            if (!recursive) {
+                crawler = crawler.withMaxDepth(1);
+            }
+            const crawled = await crawler
+                .crawl(folderPath.fsPath)
+                .withPromise();
+            for (const path of crawled) {
+                entries.push({
+                    isFile: true,
+                    isDirectory: false,
+                    uri: URI.file(path),
+                });
+            }
+        }
+        catch (error) {
+            logger.warn(`Failed to read directory ${folderPath.fsPath}`, { error });
+        }
+        return entries;
+    }
+    async scanProjectFiles(folderUri) {
+        return await this.scanDirectory(folderUri, isLikeC4Config);
+    }
+    async scanDirectory(directory, filter) {
+        const entries = [];
+        try {
+            const crawled = await new fdir()
+                .withSymlinks({ resolvePaths: false })
+                .withFullPaths()
+                .filter(filter)
+                .crawl(directory.fsPath)
+                .withPromise();
+            for (const path of crawled) {
+                entries.push({
+                    isFile: true,
+                    isDirectory: false,
+                    uri: URI.file(path),
+                });
+            }
+        }
+        catch (error) {
+            logger.warn(`Failed to scan directory ${directory.fsPath}`, { error });
+        }
+        return entries;
+    }
+    async loadProjectConfig(filepath) {
+        return await loadConfig(filepath);
+    }
+    async writeFile(uri, content) {
+        const dir = dirname(uri.fsPath);
+        const exists = await stat(dir).catch(() => null);
+        if (exists?.isFile()) {
+            throw new Error(`Cannot create directory ${dir} because a file with the same name exists.`);
+        }
+        if (!exists) {
+            logger.debug('creating directory {path}', { path: dir });
+            // Create the directory synchronously on purpose
+            // to prevent watchers from picking up the change too early
+            mkdirSync(dir, { recursive: true });
+        }
+        logger.debug('writing file {path}', { path: uri.fsPath });
+        return await writeFile(uri.fsPath, content, {
+            encoding: 'utf-8',
+        });
+    }
+    async deleteFile(uri) {
+        try {
+            const path = uri.fsPath;
+            const exists = await stat(path);
+            if (exists.isFile() || exists.isSymbolicLink()) {
+                await unlink(path);
+                logger.debug('deleted file {path}', { path });
+                return true;
+            }
+            else {
+                logger.warn('deleteFile failed: {path} does not exist, or is not a file', { path });
+            }
+        }
+        catch (error) {
+            logger.warn(`Failed to delete file ${uri.fsPath}`, { error });
+        }
+        return false;
+    }
+}

package/dist/filesystem/index.d.ts

@@ -14,14 +14,40 @@ export interface FileSystemProvider extends LangiumFileSystemProvider {
      * @returns The project config.
      */
     loadProjectConfig(filepath: URI): Promise<LikeC4ProjectConfig>;
+    /**
+     * Reads the directory information for the given URI.
+     * @param options.recursive If true, recursively reads the directory,
+     * @default true
+     */
+    readDirectory(uri: URI, options?: {
+        recursive?: boolean;
+    }): Promise<FileSystemNode[]>;
+    /**
+     * Finds all files in the given directory, matching the given filter.
+     */
+    scanDirectory(directory: URI, filter: (filepath: string) => boolean): Promise<FileSystemNode[]>;
+    /**
+     * Writes the content to the file system.
+     * Used by manual layouts.
+     */
+    writeFile(uri: URI, content: string): Promise<void>;
+    /**
+     * Deletes the file from the file system.
+     * Used by manual layouts.
+     * @return true if the file was deleted, false if the file did not exist.
+     */
+    deleteFile(uri: URI): Promise<boolean>;
 }
 export interface FileSystemModuleContext extends FileSystemWatcherModuleContext {
     fileSystemProvider: (services: LangiumSharedCoreServices) => FileSystemProvider;
 }
 export declare class NoopFileSystemProvider implements FileSystemProvider {
     scanProjectFiles(): Promise<FileSystemNode[]>;
+    scanDirectory(): Promise<FileSystemNode[]>;
     readFile(): Promise<string>;
     readDirectory(): Promise<FileSystemNode[]>;
     loadProjectConfig(): Promise<LikeC4ProjectConfig>;
+    writeFile(): Promise<void>;
+    deleteFile(): Promise<boolean>;
 }
 export declare const NoopFileSystem: FileSystemModuleContext;

package/dist/filesystem/index.js

@@ -0,0 +1,29 @@
+import { URI } from 'vscode-uri';
+import { noopFileSystemWatcher } from './FileSystemWatcher';
+export class NoopFileSystemProvider {
+    scanProjectFiles() {
+        return Promise.resolve([]);
+    }
+    scanDirectory() {
+        return Promise.resolve([]);
+    }
+    readFile() {
+        throw new Error('No file system is available.');
+    }
+    readDirectory() {
+        return Promise.resolve([]);
+    }
+    loadProjectConfig() {
+        throw new Error('No file system is available.');
+    }
+    writeFile() {
+        throw new Error('No file system is available.');
+    }
+    deleteFile() {
+        throw new Error('No file system is available.');
+    }
+}
+export const NoopFileSystem = {
+    fileSystemProvider: () => new NoopFileSystemProvider(),
+    ...noopFileSystemWatcher,
+};