@likec4/language-server 1.47.0 → 1.48.0

package/dist/views/LikeC4Views.js

@@ -1,216 +0,0 @@
-import { _layout, applyManualLayout, calcDriftsFromSnapshot } from '@likec4/core';
-import { GraphvizLayouter } from '@likec4/layouts';
-import { loggable } from '@likec4/log';
-import { interruptAndCheck } from 'langium';
-import { isTruthy, values } from 'remeda';
-import { logger as rootLogger, logWarnError } from '../logger';
-import { performanceMark } from '../utils';
-const viewsLogger = rootLogger.getChild('views');
-export class DefaultLikeC4Views {
-    services;
-    cache = new WeakMap();
-    /**
-     * Set of viewIds with reported errors
-     * value is `${projectId}-${viewId}`
-     */
-    viewsWithReportedErrors = new Set();
-    ModelBuilder;
-    constructor(services) {
-        this.services = services;
-        this.ModelBuilder = services.likec4.ModelBuilder;
-    }
-    get layouter() {
-        return this.services.likec4.Layouter;
-    }
-    async computedViews(projectId, cancelToken) {
-        const likeC4Model = await this.ModelBuilder.computeModel(projectId, cancelToken);
-        return values(likeC4Model.$data.views);
-    }
-    async _layoutAllViews(likeC4Model, cancelToken) {
-        const views = values(likeC4Model.$data.views);
-        if (views.length === 0) {
-            return [];
-        }
-        const m0 = performanceMark();
-        const projectId = likeC4Model.project.id;
-        const logger = viewsLogger.getChild(projectId);
-        logger.debug `layoutAll: ${views.length} views`;
-        const tasks = [];
-        const styles = likeC4Model.$styles;
-        const results = [];
-        //
-        for (const view of views) {
-            let cached = this.cache.get(view);
-            if (cached) {
-                logger.debug `layout ${view.id} from cache`;
-                results.push(cached);
-                continue;
-            }
-            tasks.push({
-                view,
-                styles,
-            });
-        }
-        if (tasks.length > 0) {
-            await this.layouter.batchLayout({
-                batch: tasks,
-                cancelToken,
-                onSuccess: (task, result) => {
-                    results.push(this.viewSucceed(task.view, likeC4Model, result));
-                },
-                onError: (task, error) => {
-                    logger.warn(`Fail layout view ${task.view.id}`, { error });
-                },
-            });
-        }
-        if (cancelToken && cancelToken.isCancellationRequested) {
-            await interruptAndCheck(cancelToken);
-        }
-        if (results.length !== views.length) {
-            logger.warn `layouted ${results.length} of ${views.length} views in ${m0.pretty}`;
-        }
-        else if (results.length > 0) {
-            logger.debug `layouted all ${results.length} views in ${m0.pretty}`;
-        }
-        return results;
-    }
-    async layoutAllViews(projectId, cancelToken) {
-        const likeC4Model = await this.ModelBuilder.computeModel(projectId, cancelToken);
-        return await this._layoutAllViews(likeC4Model, cancelToken);
-    }
-    async layoutView({ viewId, layoutType, projectId, cancelToken, }) {
-        const model = await this.ModelBuilder.computeModel(projectId, cancelToken);
-        const view = model.findView(viewId)?.$view;
-        projectId = model.project.id;
-        const logger = viewsLogger.getChild(projectId);
-        if (!view) {
-            logger.warn `layoutView ${viewId} not found`;
-            const snapshot = model.findManualLayout(viewId);
-            if (snapshot) {
-                logger.debug `found manual layout for ${viewId}`;
-                let diagram = { ...snapshot };
-                diagram.drifts = [
-                    'not-exists',
-                ];
-                diagram._layout = 'manual';
-                return {
-                    diagram: diagram,
-                    dot: '# manual layout',
-                };
-            }
-            return null;
-        }
-        try {
-            const m0 = performanceMark();
-            const out = this.cache.get(view) ?? await this.layouter.layout({
-                view,
-                styles: model.$styles,
-            });
-            if (this.cache.has(view)) {
-                logger.debug `layout ${viewId} from cache`;
-            }
-            else {
-                this.viewSucceed(view, model, out);
-                logger.debug(`layout {viewId} in ${m0.pretty}`, { viewId });
-            }
-            if (isTruthy(layoutType)) {
-                return {
-                    dot: out.dot,
-                    diagram: this.withLayoutType(out.diagram, model, layoutType),
-                };
-            }
-            return out;
-        }
-        catch (e) {
-            const errMessage = loggable(e);
-            logger.warn(errMessage);
-            this.reportViewError(view, projectId, errMessage);
-            return Promise.reject(e);
-        }
-    }
-    async diagrams(projectId, cancelToken) {
-        const likeC4Model = await this.ModelBuilder.computeModel(projectId, cancelToken);
-        const layouted = await this._layoutAllViews(likeC4Model, cancelToken);
-        return layouted.map(({ diagram }) => {
-            // Apply manual layout if any
-            return this.withLayoutType(diagram, likeC4Model, 'manual');
-        });
-    }
-    async viewsAsGraphvizOut(projectId, cancelToken) {
-        const KEY = 'All-LayoutedViews-DotWithSvg';
-        const cache = this.services.shared.workspace.Cache;
-        if (cache.has(KEY)) {
-            return await Promise.resolve(cache.get(KEY));
-        }
-        const likeC4Model = await this.ModelBuilder.computeModel(projectId, cancelToken);
-        const views = values(likeC4Model.$data.views);
-        if (views.length === 0) {
-            return [];
-        }
-        const tasks = views.map(async (view) => {
-            const { dot, svg } = await this.layouter.svg({
-                view,
-                styles: likeC4Model.$styles,
-            });
-            return {
-                id: view.id,
-                dot,
-                svg,
-            };
-        });
-        const succeed = [];
-        const settledResult = await Promise.allSettled(tasks);
-        for (const result of settledResult) {
-            if (result.status === 'fulfilled') {
-                succeed.push(result.value);
-            }
-            else {
-                logWarnError(result.reason);
-            }
-        }
-        cache.set(KEY, succeed);
-        return succeed;
-    }
-    /**
-     * Open a view in the preview panel.
-     */
-    async openView(viewId, projectId) {
-        await this.services.Rpc.openView({ viewId, projectId });
-    }
-    reportViewError(view, projectId, error) {
-        const key = `${projectId}-${view.id}`;
-        this.cache.delete(view);
-        if (!this.viewsWithReportedErrors.has(key)) {
-            this.services.shared.lsp.Connection?.window.showErrorMessage(`LikeC4: ${error}`);
-            this.viewsWithReportedErrors.add(key);
-        }
-    }
-    /**
-     * Applies manual layout or calculates drifts from snapshot
-     * if layoutType is specified
-     */
-    withLayoutType(layouted, likec4model, layoutType) {
-        if (!layoutType) {
-            return layouted;
-        }
-        const snapshot = likec4model.findManualLayout(layouted.id);
-        if (!snapshot) {
-            return layouted;
-        }
-        if (layoutType === 'manual') {
-            if (layouted[_layout] === 'manual') {
-                viewsLogger.error(`View ${layouted.id} already has manual layout, this should not happen`);
-                return layouted;
-            }
-            return applyManualLayout(layouted, snapshot);
-        }
-        return calcDriftsFromSnapshot(layouted, snapshot);
-    }
-    viewSucceed(view, likec4model, result) {
-        const projectId = likec4model.project.id;
-        const key = `${projectId}-${view.id}`;
-        this.viewsWithReportedErrors.delete(key);
-        this.cache.set(view, result);
-        return result;
-    }
-}

package/dist/views/index.d.ts

@@ -1,4 +0,0 @@
-import type { LikeC4ManualLayouts, LikeC4ManualLayoutsModuleContext } from './LikeC4ManualLayouts';
-export { DefaultLikeC4Views, type LikeC4Views } from './LikeC4Views';
-export type { LikeC4ManualLayouts, LikeC4ManualLayoutsModuleContext };
-export declare const NoopLikeC4ManualLayouts: LikeC4ManualLayoutsModuleContext;

package/dist/views/index.js

@@ -1,11 +0,0 @@
-export { DefaultLikeC4Views } from './LikeC4Views';
-export const NoopLikeC4ManualLayouts = {
-    manualLayouts: () => {
-        return {
-            read: () => Promise.resolve(null),
-            write: () => Promise.reject(new Error('NoopLikeC4ManualLayouts: write operation is not supported')),
-            remove: () => Promise.resolve(null),
-            clearCaches: () => { },
-        };
-    },
-};

package/dist/workspace/AstNodeDescriptionProvider.d.ts

@@ -1,7 +0,0 @@
-import { type AstNode, type AstNodeDescription, type LangiumDocument, DefaultAstNodeDescriptionProvider } from 'langium';
-import type { LikeC4Services } from '../module';
-export declare class AstNodeDescriptionProvider extends DefaultAstNodeDescriptionProvider {
-    protected services: LikeC4Services;
-    constructor(services: LikeC4Services);
-    createDescription(node: AstNode, name: string | undefined, document?: LangiumDocument): AstNodeDescription;
-}

package/dist/workspace/AstNodeDescriptionProvider.js

@@ -1,18 +0,0 @@
-import { AstUtils, DefaultAstNodeDescriptionProvider, } from 'langium';
-import { isLikeC4Builtin } from '../likec4lib';
-export class AstNodeDescriptionProvider extends DefaultAstNodeDescriptionProvider {
-    services;
-    constructor(services) {
-        super(services);
-        this.services = services;
-    }
-    createDescription(node, name, document) {
-        document ??= AstUtils.getDocument(node);
-        const description = super.createDescription(node, name, document);
-        if (!isLikeC4Builtin(document.uri)) {
-            document.likec4ProjectId ??= this.services.shared.workspace.ProjectsManager.belongsTo(document);
-            description.likec4ProjectId = document.likec4ProjectId;
-        }
-        return description;
-    }
-}

package/dist/workspace/IndexManager.d.ts

@@ -1,10 +0,0 @@
-import type { ProjectId } from '@likec4/core';
-import { type AstNodeDescription, type LangiumDocument, type Stream, DefaultIndexManager } from 'langium';
-import type { CancellationToken } from 'vscode-languageserver';
-import type { LikeC4SharedServices } from '../module';
-export declare class IndexManager extends DefaultIndexManager {
-    protected services: LikeC4SharedServices;
-    constructor(services: LikeC4SharedServices);
-    updateContent(document: LangiumDocument, cancelToken?: CancellationToken): Promise<void>;
-    projectElements(projectId: ProjectId, nodeType?: string, uris?: Set<string>): Stream<AstNodeDescription>;
-}

package/dist/workspace/IndexManager.js

@@ -1,26 +0,0 @@
-import { DefaultIndexManager, stream } from 'langium';
-export class IndexManager extends DefaultIndexManager {
-    services;
-    constructor(services) {
-        super(services);
-        this.services = services;
-    }
-    async updateContent(document, cancelToken) {
-        const projects = this.services.workspace.ProjectsManager;
-        // Ensure the document is assigned to a project
-        document.likec4ProjectId = projects.belongsTo(document);
-        await super.updateContent(document, cancelToken);
-    }
-    projectElements(projectId, nodeType, uris) {
-        const projects = this.services.workspace.ProjectsManager;
-        let documentUris = stream(this.symbolIndex.keys());
-        return documentUris
-            .filter(uri => {
-            if (uris && !uris.has(uri)) {
-                return false;
-            }
-            return projects.isIncluded(projectId, uri);
-        })
-            .flatMap(uri => this.getFileDescriptions(uri, nodeType));
-    }
-}

package/dist/workspace/LangiumDocuments.d.ts

@@ -1,29 +0,0 @@
-import type { NonEmptyArray, ProjectId } from '@likec4/core';
-import type { LangiumDocument, Stream, URI } from 'langium';
-import { DefaultLangiumDocuments } from 'langium';
-import { type LikeC4LangiumDocument } from '../ast';
-import type { LikeC4SharedServices } from '../module';
-export declare class LangiumDocuments extends DefaultLangiumDocuments {
-    protected services: LikeC4SharedServices;
-    constructor(services: LikeC4SharedServices);
-    addDocument(document: LangiumDocument): void;
-    getDocument(uri: URI): LikeC4LangiumDocument | undefined;
-    /**
-     * Returns all known documents, without any filtering.
-     */
-    get allKnownDocuments(): Stream<LangiumDocument>;
-    get all(): Stream<LikeC4LangiumDocument>;
-    /**
-     * Returns all documents, excluding built-in documents and documents excluded by ProjectsManager.
-     */
-    get allExcludingBuiltin(): Stream<LikeC4LangiumDocument>;
-    /**
-     * Returns all documents for a project, including both project documents and documents included by the project.
-     */
-    projectDocuments(projectId: ProjectId): Stream<LikeC4LangiumDocument>;
-    groupedByProject(): Record<ProjectId, NonEmptyArray<LikeC4LangiumDocument>>;
-    /**
-     * Reset the project IDs of all documents.
-     */
-    resetProjectIds(): void;
-}

package/dist/workspace/LangiumDocuments.js

@@ -1,104 +0,0 @@
-import { compareNaturalHierarchically } from '@likec4/core/utils';
-import { DefaultLangiumDocuments, stream } from 'langium';
-import { hasAtLeast } from 'remeda';
-import { isLikeC4LangiumDocument } from '../ast';
-import { LikeC4LanguageMetaData } from '../generated/module';
-import { isLikeC4Builtin } from '../likec4lib';
-/**
- * Compare function for document paths to ensure consistent order
- */
-const compare = compareNaturalHierarchically('/', true);
-const ensureOrder = (a, b) => compare(a.uri.path, b.uri.path);
-const exclude = (doc) => {
-    return doc.textDocument.languageId !== LikeC4LanguageMetaData.languageId || isLikeC4Builtin(doc.uri);
-};
-export class LangiumDocuments extends DefaultLangiumDocuments {
-    services;
-    constructor(services) {
-        super(services);
-        this.services = services;
-    }
-    addDocument(document) {
-        const uriString = document.uri.toString();
-        if (this.documentMap.has(uriString)) {
-            throw new Error(`A document with the URI '${uriString}' is already present.`);
-        }
-        const docs = [...this.documentMap.values(), document].sort(ensureOrder);
-        // Clear and re-add documents to ensure consistent order
-        this.documentMap.clear();
-        for (const doc of docs) {
-            this.documentMap.set(doc.uri.toString(), doc);
-        }
-    }
-    getDocument(uri) {
-        const doc = super.getDocument(uri);
-        if (doc && !isLikeC4LangiumDocument(doc)) {
-            throw new Error(`Document ${doc.uri.path} is not a LikeC4 document`);
-        }
-        if (doc && !exclude(doc)) {
-            doc.likec4ProjectId = this.services.workspace.ProjectsManager.belongsTo(doc);
-        }
-        return doc;
-    }
-    /**
-     * Returns all known documents, without any filtering.
-     */
-    get allKnownDocuments() {
-        return stream(this.documentMap.values());
-    }
-    get all() {
-        return this.allKnownDocuments
-            .filter((doc) => {
-            if (doc.textDocument.languageId === LikeC4LanguageMetaData.languageId) {
-                if (!isLikeC4Builtin(doc.uri)) {
-                    doc.likec4ProjectId = this.services.workspace.ProjectsManager.belongsTo(doc);
-                }
-                return true;
-            }
-            return false;
-        });
-    }
-    /**
-     * Returns all documents, excluding built-in documents and documents excluded by ProjectsManager.
-     */
-    get allExcludingBuiltin() {
-        const projects = this.services.workspace.ProjectsManager;
-        return this.all.filter((doc) => {
-            return !(isLikeC4Builtin(doc.uri) || projects.isExcluded(doc));
-        });
-    }
-    /**
-     * Returns all documents for a project, including both project documents and documents included by the project.
-     */
-    projectDocuments(projectId) {
-        const projects = this.services.workspace.ProjectsManager;
-        return this.all.filter(doc => {
-            if (isLikeC4Builtin(doc.uri)) {
-                return false;
-            }
-            return projects.isIncluded(projectId, doc.uri);
-        });
-    }
-    groupedByProject() {
-        return this.services.workspace.ProjectsManager
-            .all
-            .reduce((acc, projectId) => {
-            const docs = this.projectDocuments(projectId).toArray();
-            if (hasAtLeast(docs, 1)) {
-                acc[projectId] = docs;
-            }
-            return acc;
-        }, {});
-    }
-    /**
-     * Reset the project IDs of all documents.
-     */
-    resetProjectIds() {
-        this.allKnownDocuments.forEach(doc => {
-            if (exclude(doc)) {
-                return;
-            }
-            delete doc.likec4ProjectId;
-        });
-    }
-}

package/dist/workspace/ProjectsManager.d.ts

@@ -1,134 +0,0 @@
-import { type IncludeConfig, type LikeC4ProjectConfig, type LikeC4ProjectConfigInput } from '@likec4/config';
-import type { NonEmptyArray, NonEmptyReadonlyArray } from '@likec4/core';
-import type { ProjectId, scalar } from '@likec4/core/types';
-import { type Cancellation, type LangiumDocument, URI, WorkspaceCache } from 'langium';
-import picomatch from 'picomatch';
-import type { Tagged } from 'type-fest';
-import type { LikeC4SharedServices } from '../module';
-/**
- * A tagged string that represents a project folder URI
- * Always has trailing slash.
- */
-export type ProjectFolder = Tagged<string, 'ProjectFolder'>;
-export declare function ProjectFolder(folder: URI | string): ProjectFolder;
-interface ProjectData {
-    id: scalar.ProjectId;
-    config: LikeC4ProjectConfig;
-    folder: ProjectFolder;
-    folderUri: URI;
-    exclude?: picomatch.Matcher;
-    /**
-     * Resolved include paths with both URI and folder string representations.
-     * These are additional directories that are part of this project.
-     */
-    includePaths?: NonEmptyArray<{
-        uri: URI;
-        folder: ProjectFolder;
-    }>;
-    /**
-     * Normalized include configuration (paths, maxDepth, fileThreshold).
-     */
-    includeConfig: IncludeConfig;
-}
-export interface Project {
-    id: scalar.ProjectId;
-    folderUri: URI;
-    config: LikeC4ProjectConfig;
-    /**
-     * Resolved include paths as URIs (if configured).
-     */
-    includePaths?: NonEmptyReadonlyArray<URI>;
-}
-export declare class ProjectsManager {
-    #private;
-    protected services: LikeC4SharedServices;
-    /**
-     * The global project ID used for all documents
-     * that are not part of a specific project.
-     */
-    static readonly DefaultProjectId: ProjectId<string>;
-    constructor(services: LikeC4SharedServices);
-    /**
-     * Returns:
-     *  - configured default project ID if set
-     *  - the default project ID if there are no projects.
-     *  - the ID of the only project
-     *  - undefined if there are multiple projects.
-     */
-    get defaultProjectId(): scalar.ProjectId | undefined;
-    set defaultProjectId(id: string | scalar.ProjectId | undefined);
-    get default(): ProjectData;
-    get all(): NonEmptyReadonlyArray<scalar.ProjectId>;
-    getProject(arg: scalar.ProjectId | LangiumDocument): Project;
-    /**
-     * Returns all projects that include the specified folder, or inside the folder.
-     */
-    findAllProjectsByFolder(folder: URI | string): ProjectData[];
-    /**
-     * Validates and ensures the project ID.
-     * If no project ID is specified, returns default project ID
-     * If there are multiple projects and default project is not set, throws an error
-     */
-    ensureProjectId(projectId?: scalar.ProjectId | undefined): scalar.ProjectId;
-    /**
-     * Validates and ensures the project.
-     */
-    ensureProject(projectId?: scalar.ProjectId | undefined): Project;
-    hasMultipleProjects(): boolean;
-    /**
-     * Checks if the specified document should be excluded from processing.
-     */
-    isExcluded(document: LangiumDocument | URI | string): boolean;
-    /**
-     * Checks if the specified document is included by the project:
-     * - if the document belongs to the project and is not excluded
-     * - if the document is included by the project
-     */
-    isIncluded(projectId: ProjectId, document: LangiumDocument | URI | string): boolean;
-    /**
-     * Checks if it is a config file and it is not excluded by default exclude pattern
-     *
-     * @param entry The file system entry to check
-     */
-    isConfigFile(entry: URI): boolean;
-    /**
-     * Registers likec4 project by config file.
-     */
-    registerConfigFile(configFile: URI, cancelToken?: Cancellation.CancellationToken): Promise<ProjectData>;
-    /**
-     * Registers (or reloads) likec4 project by config file or config object.
-     * If there is some project registered at same folder, it will be reloaded.
-     */
-    registerProject(opts: {
-        config: LikeC4ProjectConfig | LikeC4ProjectConfigInput;
-        folderUri: URI | string;
-    }, cancelToken?: Cancellation.CancellationToken): Promise<ProjectData>;
-    /**
-     * Determines which project the given document belongs to.
-     * If the document does not belong to any project, returns the default project ID.
-     */
-    belongsTo(document: LangiumDocument | URI | string): scalar.ProjectId;
-    reloadProjects(cancelToken?: Cancellation.CancellationToken): Promise<void>;
-    protected _reloadProjects(cancelToken?: Cancellation.CancellationToken): Promise<void>;
-    protected uniqueProjectId(name: string): scalar.ProjectId;
-    protected reset(): void;
-    rebuidProject(projectId: ProjectId, cancelToken?: Cancellation.CancellationToken): Promise<void>;
-    protected findProjectForDocument(documentUri: string): ProjectData;
-    protected get mappingsToProject(): WorkspaceCache<string, ProjectData>;
-    /**
-     * The mapping between documents and projects they belong to.
-     * Lazy-created due to initialization order of the LanguageServer
-     */
-    protected get documentBelongsTo(): WorkspaceCache<LangiumDocument, ProjectData>;
-    /**
-     * Returns all include paths from all projects.
-     * Used by WorkspaceManager to scan additional directories for C4 files.
-     */
-    getAllIncludePaths(): Array<{
-        projectId: scalar.ProjectId;
-        includePath: URI;
-        includeConfig: IncludeConfig;
-    }>;
-    private getWorkspaceFolder;
-}
-export {};