@likec4/language-server 1.46.4 → 1.48.0

package/dist/filesystem/LikeC4FileSystem.js

@@ -1,130 +0,0 @@
-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 { 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 maxDepth = opts?.maxDepth ?? Infinity;
-        const entries = [];
-        try {
-            let crawler = new fdir()
-                .withSymlinks({ resolvePaths: false })
-                .withFullPaths()
-                .filter(isLikeC4File);
-            if (!recursive) {
-                crawler = crawler.withMaxDepth(1);
-            }
-            else if (maxDepth !== Infinity) {
-                crawler = crawler.withMaxDepth(maxDepth);
-            }
-            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

@@ -1,55 +0,0 @@
-import type { LikeC4ProjectConfig } from '@likec4/config';
-import type { FileSystemNode, FileSystemProvider as LangiumFileSystemProvider, LangiumSharedCoreServices } from 'langium';
-import { URI } from 'vscode-uri';
-import { type FileSystemWatcherModuleContext } from './FileSystemWatcher';
-export type { FileSystemWatcher } from './FileSystemWatcher';
-export interface FileSystemProvider extends LangiumFileSystemProvider {
-    /**
-     * Scans the project files for the given URI.
-     * @returns The list of file system entries that are contained within the specified directory.
-     */
-    scanProjectFiles(folderUri: URI): Promise<FileSystemNode[]>;
-    /**
-     * Loads the project config from the given file.
-     * @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,
-     * @param options.maxDepth Maximum depth to traverse when recursive is true (default: Infinity)
-     * @default true
-     */
-    readDirectory(uri: URI, options?: {
-        recursive?: boolean;
-        maxDepth?: number;
-    }): 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

@@ -1,29 +0,0 @@
-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,
-};

package/dist/formatting/LikeC4Formatter.d.ts

@@ -1,59 +0,0 @@
-import { type AstNode, type LangiumDocument } from 'langium';
-import { AbstractFormatter, FormattingRegion } from 'langium/lsp';
-import type { FormattingOptions as LSFormattingOptions, Range, TextEdit } from 'vscode-languageserver-types';
-import type { LikeC4Services } from '../module';
-type QuoteStyle = 'single' | 'double' | 'ignore' | 'auto';
-interface LikeC4FormatterOptions {
-    quoteStyle: QuoteStyle;
-}
-type ExtendedFormattingCommandType = 'normalizeQuotes';
-interface ExtendedFormattingCommand {
-    type: ExtendedFormattingCommandType;
-    region: FormattingRegion;
-}
-export declare class LikeC4Formatter extends AbstractFormatter {
-    protected options: LikeC4FormatterOptions;
-    extendedFormattingCommands: ExtendedFormattingCommand[];
-    constructor(services: LikeC4Services);
-    protected doDocumentFormat(document: LangiumDocument, options: LSFormattingOptions, range?: Range): TextEdit[];
-    protected format(node: AstNode): void;
-    protected formatTags(node: AstNode): void;
-    protected formatDeploymentRelation(node: AstNode): void;
-    protected formatExtendDeployment(node: AstNode): void;
-    protected formatRelation(node: AstNode): void;
-    protected removeIndentFromTopLevelStatements(node: AstNode): void;
-    protected indentContentInBraces(node: AstNode): void;
-    protected appendKeywordsWithSpace(node: AstNode): void;
-    protected formatView(node: AstNode): void;
-    protected formatLeafProperty(node: AstNode): void;
-    protected formatLinkProperty(node: AstNode): void;
-    protected formatNavigateToProperty(node: AstNode): void;
-    protected formatAutolayoutProperty(node: AstNode): void;
-    protected formatMetadataProperty(node: AstNode): void;
-    protected formatElementDeclaration(node: AstNode): void;
-    protected formatExtendElement(node: AstNode): void;
-    protected formatGlobals(node: AstNode): void;
-    protected formatImports(node: AstNode): void;
-    protected formatSpecificationRule(node: AstNode): void;
-    protected formatWithPredicate(node: AstNode): void;
-    protected formatDeploymentNodeDeclaration(node: AstNode): void;
-    protected formatDeployedInstance(node: AstNode): void;
-    protected formatViewRuleGlobalStyle(node: AstNode): void;
-    protected formatViewRuleGlobalPredicate(node: AstNode): void;
-    protected formatViewRuleGroup(node: AstNode): void;
-    protected formatViewRuleStyle(node: AstNode): void;
-    protected formatWhereExpression(node: AstNode): void;
-    protected formatWhereRelationExpression(node: AstNode): void;
-    protected formatWhereElementExpression(node: AstNode): void;
-    protected formatIncludeExcludeExpressions(node: AstNode): void;
-    protected formatRelationExpression(node: AstNode): void;
-    private findPredicateExpressionRoot;
-    private on;
-    private doExtendedFormatting;
-    protected normalizeQuotes(node: AstNode): void;
-    private quotesNormalizerFactory;
-    private escapeQuotesInternalQuotes;
-    private getAutoQuoteStyle;
-    private onConfigurationUpdate;
-}
-export {};