@likec4/language-server 1.47.0 → 1.49.0

package/dist/validation/view.js

@@ -1,42 +0,0 @@
-import { CstUtils } from 'langium';
-import { ast } from '../ast';
-import { projectIdFrom } from '../utils';
-import { hasManualLayout } from '../view-utils/manual-layout';
-import { RESERVED_WORDS, tryOrLog } from './_shared';
-export const viewChecks = (services) => {
-    const index = services.shared.workspace.IndexManager;
-    return tryOrLog((el, accept) => {
-        const commentNode = CstUtils.findCommentNode(el.$cstNode, ['BLOCK_COMMENT']);
-        if (commentNode && hasManualLayout(commentNode.text)) {
-            accept('warning', `Migrate to the new manual layout snapshots (run LikeC4: Migrate manual layouts)`, {
-                node: el,
-                range: commentNode.range,
-                code: 'manual-layout-v1',
-                // codeDescription: {
-                //   href: 'https://likec4.dev/docs/guides/manual-layout#migrating-from-v1-to-v2-manual-layout',
-                // },
-            });
-        }
-        if (!el.name) {
-            return;
-        }
-        if (RESERVED_WORDS.includes(el.name)) {
-            accept('error', `Reserved word: ${el.name}`, {
-                node: el,
-                property: 'name',
-            });
-        }
-        const projectId = projectIdFrom(el);
-        const anotherViews = index
-            .projectElements(projectId, ast.LikeC4View)
-            .filter(n => n.name === el.name)
-            .limit(2)
-            .count();
-        if (anotherViews > 1) {
-            accept('error', `Duplicate view '${el.name}'`, {
-                node: el,
-                property: 'name',
-            });
-        }
-    });
-};

package/dist/view-utils/assignNavigateTo.d.ts

@@ -1,2 +0,0 @@
-import { type ComputedView } from '@likec4/core';
-export declare function assignNavigateTo<R extends Iterable<ComputedView>>(views: R): R;

package/dist/view-utils/assignNavigateTo.js

@@ -1,27 +0,0 @@
-import { isElementView } from '@likec4/core';
-import { find, isNullish } from 'remeda';
-export function assignNavigateTo(views) {
-    const allElementViews = new Map();
-    for (const v of views) {
-        if (isElementView(v) && v.viewOf && isNullish(v.extends)) {
-            const viewsOf = allElementViews.get(v.viewOf) ?? [];
-            viewsOf.push(v.id);
-            allElementViews.set(v.viewOf, viewsOf);
-        }
-    }
-    // set default navigateTo
-    for (const { id, nodes } of views) {
-        for (const node of nodes) {
-            const modelRef = node.modelRef;
-            if (node.navigateTo || !modelRef) {
-                continue;
-            }
-            // find first element view that is not the current one
-            const navigateTo = find(allElementViews.get(modelRef) ?? [], v => v !== id);
-            if (navigateTo) {
-                node.navigateTo = navigateTo;
-            }
-        }
-    }
-    return views;
-}

package/dist/view-utils/index.d.ts

@@ -1,2 +0,0 @@
-export * from './assignNavigateTo';
-export * from './manual-layout';

package/dist/view-utils/index.js

@@ -1,2 +0,0 @@
-export * from './assignNavigateTo';
-export * from './manual-layout';

package/dist/view-utils/manual-layout.d.ts

@@ -1,13 +0,0 @@
-import type * as c4 from '@likec4/core';
-import { type ViewManualLayout } from '@likec4/core';
-import type { ast } from '../ast';
-export declare function serializeToComment(layout: ViewManualLayout): string;
-export declare function hasManualLayout(comment: string): boolean;
-export declare function deserializeFromComment(comment: string): ViewManualLayout;
-export declare function parseViewManualLayout(node: ast.LikeC4View): c4.ViewManualLayout | undefined;
-/**
- * Applies styles from the latest layout to the manual layout
- * @param manualLayouted
- * @param latest
- */
-export declare function applyStylesToManualLayout<A extends c4.AnyAux>(manualLayouted: NoInfer<c4.LayoutedView<A>>, latest: c4.ComputedView<A> | c4.LayoutedView<A>): c4.LayoutedView<A>;

package/dist/view-utils/manual-layout.js

@@ -1,149 +0,0 @@
-import { exact, isAutoLayoutDirection } from '@likec4/core';
-import { decode, encode } from '@msgpack/msgpack';
-import { fromBase64, toBase64 } from '@smithy/util-base64';
-import { shallowEqual } from 'fast-equals';
-import { AstUtils, CstUtils } from 'langium';
-import { find, mapValues } from 'remeda';
-import { logger, logWarnError } from '../logger';
-const { getDocument } = AstUtils;
-function pack({ nodes, edges, ...rest }) {
-    return {
-        ...rest,
-        nodes: mapValues(nodes, ({ x, y, width, height, isCompound, ...n }) => ({
-            ...n,
-            b: [x, y, width, height],
-            c: isCompound,
-        })),
-        edges: mapValues(edges, ({ points, controlPoints, labelBBox, ...e }) => ({
-            ...!!controlPoints && { cp: controlPoints },
-            ...!!labelBBox && { l: labelBBox },
-            ...e,
-            p: points,
-        })),
-    };
-}
-function unpack({ nodes, edges, autoLayout, ...rest }) {
-    return {
-        ...rest,
-        /// Try to parse the old format for backward compatibility
-        autoLayout: isAutoLayoutDirection(autoLayout) ? { direction: autoLayout } : autoLayout,
-        nodes: mapValues(nodes, ({ b, c, ...n }) => ({
-            x: b[0],
-            y: b[1],
-            width: b[2],
-            height: b[3],
-            isCompound: c,
-            ...n,
-        })),
-        edges: mapValues(edges, ({ p, cp, l, ...e }) => ({
-            ...!!cp && { controlPoints: cp },
-            ...!!l && { labelBBox: l },
-            ...e,
-            points: p,
-        })),
-    };
-}
-const MAX_LINE_LENGTH = 500;
-export function serializeToComment(layout) {
-    const bytes = encode(pack(layout));
-    const base64 = toBase64(bytes);
-    const lines = [];
-    let offset = 0;
-    while (offset < base64.length) {
-        lines.push(' * ' + base64.slice(offset, Math.min(offset + MAX_LINE_LENGTH, base64.length)));
-        offset += MAX_LINE_LENGTH;
-    }
-    lines.unshift('/**', ' * @likec4-generated(v1)');
-    lines.push(' */');
-    return lines.join('\n');
-}
-export function hasManualLayout(comment) {
-    return comment.includes('@likec4-generated');
-}
-export function deserializeFromComment(comment) {
-    if (!hasManualLayout(comment)) {
-        throw new Error(`Not a likec4-generated comment: ${comment}`);
-    }
-    const b64 = comment
-        .trim()
-        .split('\n')
-        .filter(l => !l.includes('**') && !l.includes('@likec4-') && !l.includes('*/'))
-        .map(l => l.replaceAll('*', '').trim())
-        .join('');
-    const decodedb64 = fromBase64(b64);
-    return unpack(decode(decodedb64));
-}
-export function parseViewManualLayout(node) {
-    const commentNode = CstUtils.findCommentNode(node.$cstNode, ['BLOCK_COMMENT']);
-    if (!commentNode || !hasManualLayout(commentNode.text)) {
-        return undefined;
-    }
-    try {
-        return deserializeFromComment(commentNode.text);
-    }
-    catch (e) {
-        const doc = getDocument(node);
-        logWarnError(e);
-        logger.warn(`Ignoring manual layout of "${node.name ?? 'unnamed'}" at ${doc.uri.fsPath}:${1 + (commentNode.range.start.line || 0)}`);
-        return undefined;
-    }
-}
-/**
- * Applies styles from the latest layout to the manual layout
- * @param manualLayouted
- * @param latest
- */
-export function applyStylesToManualLayout(manualLayouted, latest) {
-    const nodes = manualLayouted.nodes.map(n => {
-        const latestNode = find(latest.nodes, l => l.id === n.id);
-        if (!latestNode) {
-            return n;
-        }
-        const color = latestNode.color;
-        if (color !== n.color) {
-            n = {
-                ...n,
-                color,
-            };
-        }
-        const { opacity, border } = latestNode.style;
-        if (opacity !== n.style.opacity || border !== n.style.border) {
-            n = {
-                ...n,
-                style: exact({
-                    ...n.style,
-                    opacity,
-                    border,
-                }),
-            };
-        }
-        return n;
-    });
-    const edges = manualLayouted.edges.map(e => {
-        const latestEdge = find(latest.edges, l => l.id === e.id);
-        if (!latestEdge) {
-            return e;
-        }
-        if (latestEdge.color !== e.color) {
-            e = {
-                ...e,
-                color: latestEdge.color,
-            };
-        }
-        if (latestEdge.line !== e.line) {
-            e = {
-                ...e,
-                line: latestEdge.line,
-            };
-        }
-        return e;
-    });
-    if (!shallowEqual(manualLayouted.nodes, nodes) || !shallowEqual(manualLayouted.edges, edges)) {
-        return {
-            ...manualLayouted,
-            nodes,
-            edges,
-        };
-    }
-    return manualLayouted;
-}

package/dist/views/ConfigurableLayouter.d.ts

@@ -1,7 +0,0 @@
-import { QueueGraphvizLayoter } from '@likec4/layouts';
-import type { LikeC4Services } from '../module';
-export declare const ConfigurableLayouter: {
-    likec4: {
-        Layouter(services: LikeC4Services): QueueGraphvizLayoter;
-    };
-};

package/dist/views/ConfigurableLayouter.js

@@ -1,51 +0,0 @@
-import { GraphvizWasmAdapter, QueueGraphvizLayoter } from '@likec4/layouts';
-import { GraphvizBinaryAdapter } from '@likec4/layouts/graphviz/binary';
-import { isEmpty } from 'remeda';
-import which from 'which';
-import { logger } from '../logger';
-function graphvizBinPath() {
-    try {
-        return which.sync('dot');
-    }
-    catch (error) {
-        logger.error('Error checking for native Graphviz:', { error });
-        return null;
-    }
-}
-export const ConfigurableLayouter = {
-    likec4: {
-        Layouter(services) {
-            logger.debug('Creating ConfigurableLayouter');
-            const layouter = new QueueGraphvizLayoter();
-            services.shared.workspace.ConfigurationProvider.onConfigurationSectionUpdate((update) => {
-                logger.debug('Configuration update: {update}', { update });
-                if (update.section !== services.LanguageMetaData.languageId) {
-                    logger.debug(`Ignoring configuration update as it is not for ${services.LanguageMetaData.languageId}`);
-                    return;
-                }
-                try {
-                    const { mode, path } = update.configuration.graphviz ?? {
-                        mode: 'wasm',
-                        path: '',
-                    };
-                    if (mode !== 'wasm') {
-                        let binaryPath = isEmpty(path) ? graphvizBinPath() : path;
-                        if (!isEmpty(binaryPath)) {
-                            layouter.changePort(new GraphvizBinaryAdapter(binaryPath));
-                            logger.info `use graphviz binary: ${binaryPath}`;
-                            return;
-                        }
-                        logger.warn(`No Graphviz binaries found on PATH, use graphviz wasm`);
-                        services.shared.lsp.Connection?.window.showWarningMessage('No Graphviz binaries found on PATH, set path to binaries in settings.');
-                    }
-                    layouter.changePort(new GraphvizWasmAdapter());
-                    logger.info('use graphviz wasm');
-                }
-                catch (error) {
-                    logger.error('Failed to update configuration', { error });
-                }
-            });
-            return layouter;
-        },
-    },
-};

package/dist/views/LikeC4ManualLayouts.d.ts

@@ -1,42 +0,0 @@
-import type { LayoutedView, ProjectId, ViewId } from '@likec4/core';
-import { URI, WorkspaceCache } from 'langium';
-import { type Location } from 'vscode-languageserver-types';
-import type { LikeC4Services } from '../module';
-import type { Project } from '../workspace/ProjectsManager';
-/**
- * @todo sync with vscode extension watchers
- *       (search for ".likec4.snap" references)
- */
-export declare const isManualLayoutFile: (path: string) => boolean;
-export interface LikeC4ManualLayouts {
-    read(project: Project): Promise<Record<ViewId, LayoutedView> | null>;
-    write(project: Project, layouted: LayoutedView): Promise<Location>;
-    remove(project: Project, view: ViewId): Promise<Location | null>;
-    clearCaches(): void;
-}
-export interface LikeC4ManualLayoutsModuleContext {
-    manualLayouts: (services: LikeC4Services) => LikeC4ManualLayouts;
-}
-export declare const WithLikeC4ManualLayouts: LikeC4ManualLayoutsModuleContext;
-export declare class DefaultLikeC4ManualLayouts implements LikeC4ManualLayouts {
-    private services;
-    protected cache: WorkspaceCache<ProjectId, Promise<Record<ViewId, LayoutedView> | null>>;
-    constructor(services: LikeC4Services);
-    read(project: Project): Promise<Record<ViewId, LayoutedView> | null>;
-    write(project: Project, layouted: LayoutedView): Promise<Location>;
-    remove(project: Project, view: ViewId): Promise<Location | null>;
-    clearCaches(): void;
-    /**
-     * When we save snapshot - it may contain fullpath to icons on the machine it was created,
-     * that is wrong when opened on another.
-     *
-     * Prepares a snapshot for writing by converting absolute icon paths to relative paths.
-     * Absolute paths starting with 'file://' are converted to relative paths prefixed with 'file://./'
-     */
-    protected normalizeIconPathsForWrite(layouted: LayoutedView, projectUri: URI): LayoutedView;
-    /**
-     * Postprocesses a snapshot after reading by converting relative icon paths back to absolute paths.
-     * Relative paths prefixed with 'file://./' are converted to absolute paths based on project folder.
-     */
-    protected resolveIconPathsAfterRead(layouted: LayoutedView, projectUri: URI): LayoutedView;
-}

package/dist/views/LikeC4ManualLayouts.js

@@ -1,209 +0,0 @@
-import JSON5 from 'json5';
-import { DocumentState, URI, UriUtils, WorkspaceCache } from 'langium';
-import { indexBy, prop } from 'remeda';
-import { Position, Range, } from 'vscode-languageserver-types';
-import { logger as rootLogger } from '../logger';
-const layoutsLogger = rootLogger.getChild('manual-layouts');
-/**
- * @todo sync with vscode extension watchers
- *       (search for ".likec4.snap" references)
- */
-export const isManualLayoutFile = (path) => path.endsWith('.likec4.snap');
-function fileName(view) {
-    return `${view}.likec4.snap`;
-}
-function getManualLayoutsOutDir(project) {
-    return UriUtils.resolvePath(project.folderUri, project.config.manualLayouts?.outDir ?? '.likec4');
-}
-export const WithLikeC4ManualLayouts = {
-    manualLayouts: (services) => new DefaultLikeC4ManualLayouts(services),
-};
-const RELATIVE_PATH_PREFIX = 'file://./';
-export class DefaultLikeC4ManualLayouts {
-    services;
-    cache;
-    constructor(services) {
-        this.services = services;
-        this.cache = new WorkspaceCache(services.shared, DocumentState.Validated);
-    }
-    async read(project) {
-        return await this.cache.get(project.id, async () => {
-            const logger = layoutsLogger.getChild(project.id);
-            const fs = this.services.shared.workspace.FileSystemProvider;
-            const outDir = getManualLayoutsOutDir(project);
-            const manualLayouts = [];
-            try {
-                const files = await fs.scanDirectory(outDir, isManualLayoutFile);
-                if (files.length === 0) {
-                    return null;
-                }
-                for (const file of files) {
-                    if (file.isFile) {
-                        try {
-                            const content = await fs.readFile(file.uri);
-                            const parsed = JSON5.parse(content);
-                            const resolved = this.resolveIconPathsAfterRead(parsed, project.folderUri);
-                            manualLayouts.push({
-                                ...resolved,
-                                _layout: 'manual',
-                            });
-                        }
-                        catch (err) {
-                            logger.warn(`Failed to read view snapshot ${file.uri.fsPath}`, { err });
-                        }
-                    }
-                }
-                if (manualLayouts.length) {
-                    logger.debug `read manual layouts for ${project.id}, found ${manualLayouts.length}`;
-                }
-            }
-            catch (err) {
-                logger.warn(`Failed to read manual layouts for ${project.folderUri.fsPath}`, { err });
-            }
-            if (manualLayouts.length === 0) {
-                return null;
-            }
-            return indexBy(manualLayouts, prop('id'));
-        });
-    }
-    async write(project, layouted) {
-        const logger = layoutsLogger.getChild(project.id);
-        const outDir = getManualLayoutsOutDir(project);
-        const file = UriUtils.joinPath(outDir, fileName(layouted.id));
-        // Ensure the manualLayout field is omitted (may exist in migration)
-        if ('manualLayout' in layouted) {
-            const { manualLayout: _, ...rest } = layouted;
-            layouted = rest;
-        }
-        const content = JSON5.stringify(
-        // Normalize icon paths before writing
-        this.normalizeIconPathsForWrite(layouted, project.folderUri), {
-            space: 2,
-            quote: '\'',
-        });
-        const location = {
-            uri: file.toString(),
-            range: Range.create(Position.create(0, 0), Position.create(content.split('\n').length - 1, 1)),
-        };
-        logger.debug `write snapshot of ${layouted.id} in project ${project.id} to ${file.fsPath}`;
-        const fs = this.services.shared.workspace.FileSystemProvider;
-        try {
-            await fs.writeFile(file, content + '\n');
-        }
-        catch (err) {
-            logger.warn(`Failed to write snapshot ${layouted.id} to ${file.fsPath}`, { err });
-        }
-        const projectCachesPromise = this.cache.get(project.id);
-        if (projectCachesPromise) {
-            const projectCaches = await projectCachesPromise;
-            if (projectCaches) {
-                logger.debug `update snapshot cache of ${layouted.id} in project ${project.id}`;
-                projectCaches[layouted.id] = layouted;
-            }
-            else {
-                logger.debug `clean cache of project ${project.id}`;
-                // Cache was null, remove it entirely
-                this.cache.delete(project.id);
-            }
-        }
-        this.services.likec4.ModelBuilder.clearCache();
-        return location;
-    }
-    async remove(project, view) {
-        const logger = layoutsLogger.getChild(project.id);
-        const outDir = getManualLayoutsOutDir(project);
-        const file = UriUtils.joinPath(outDir, fileName(view));
-        logger.debug `delete snapshot of ${view} in project ${project.id}. File: ${file.fsPath}`;
-        const location = {
-            uri: file.toString(),
-            range: Range.create(0, 0, 0, 0),
-        };
-        try {
-            const fs = this.services.shared.workspace.FileSystemProvider;
-            if (!(await fs.deleteFile(file))) {
-                logger.warn `Snapshot ${view} did not exist at ${file.fsPath}`;
-                return null;
-            }
-        }
-        catch (err) {
-            logger.warn(`Failed to delete snapshot ${view} from ${file.fsPath}`, { err });
-        }
-        const projectCachesPromise = this.cache.get(project.id);
-        if (projectCachesPromise) {
-            const projectCaches = await projectCachesPromise;
-            if (projectCaches) {
-                logger.debug `clean cached view ${view} in project ${project.id}`;
-                delete projectCaches[view];
-            }
-            else {
-                logger.debug `reset empty cache of project ${project.id}`;
-                // Cache was null, remove it entirely
-                this.cache.delete(project.id);
-            }
-        }
-        this.services.likec4.ModelBuilder.clearCache();
-        return location;
-    }
-    clearCaches() {
-        this.cache.clear();
-    }
-    /**
-     * When we save snapshot - it may contain fullpath to icons on the machine it was created,
-     * that is wrong when opened on another.
-     *
-     * Prepares a snapshot for writing by converting absolute icon paths to relative paths.
-     * Absolute paths starting with 'file://' are converted to relative paths prefixed with 'file://./'
-     */
-    normalizeIconPathsForWrite(layouted, projectUri) {
-        const nodes = layouted.nodes.map((node) => {
-            if (!node.icon || typeof node.icon !== 'string') {
-                return node;
-            }
-            // Check if icon is an absolute file path
-            if (node.icon.startsWith('file://')) {
-                const iconUri = URI.parse(node.icon);
-                // Get relative path from project folder to icon
-                const relativePath = UriUtils.relative(projectUri, iconUri);
-                // If icon is outside of project folder - leave it as is,
-                // to avoid security issues on reading snapshots on another machine
-                if (relativePath.startsWith('..')) {
-                    return node;
-                }
-                return {
-                    ...node,
-                    icon: `${RELATIVE_PATH_PREFIX}${relativePath}`,
-                };
-            }
-            return node;
-        });
-        return {
-            ...layouted,
-            nodes: nodes,
-        };
-    }
-    /**
-     * Postprocesses a snapshot after reading by converting relative icon paths back to absolute paths.
-     * Relative paths prefixed with 'file://./' are converted to absolute paths based on project folder.
-     */
-    resolveIconPathsAfterRead(layouted, projectUri) {
-        const nodes = layouted.nodes.map((node) => {
-            if (!node.icon || typeof node.icon !== 'string') {
-                return node;
-            }
-            // Check if icon is a relative file path
-            if (node.icon.startsWith(RELATIVE_PATH_PREFIX)) {
-                const relativePath = node.icon.substring(RELATIVE_PATH_PREFIX.length);
-                const absoluteUri = UriUtils.joinPath(projectUri, relativePath);
-                return {
-                    ...node,
-                    icon: absoluteUri.toString(),
-                };
-            }
-            return node;
-        });
-        return {
-            ...layouted,
-            nodes: nodes,
-        };
-    }
-}

package/dist/views/LikeC4Views.d.ts

@@ -1,89 +0,0 @@
-import type { ComputedView, DiagramView, LayoutedView, LayoutType, ProjectId, ViewId } from '@likec4/core';
-import { type QueueGraphvizLayoter, GraphvizLayouter } from '@likec4/layouts';
-import type { CancellationToken } from 'vscode-languageserver';
-import type { LikeC4Services } from '../module';
-export type GraphvizOut = {
-    readonly dot: string;
-    readonly diagram: LayoutedView;
-};
-type GraphvizSvgOut = {
-    readonly id: ViewId;
-    readonly dot: string;
-    readonly svg: string;
-};
-type LayoutViewParams = {
-    viewId: ViewId;
-    /**
-     * Type of layout to apply
-     * - 'manual' - applies manual layout if any
-     * - 'auto' - returns latest version with drifts from manual layout if any
-     * - undefined - returns latest layout as is
-     */
-    layoutType?: LayoutType | undefined;
-    projectId?: ProjectId | undefined;
-    cancelToken?: CancellationToken | undefined;
-};
-export interface LikeC4Views {
-    readonly layouter: GraphvizLayouter;
-    /**
-     * Returns computed views (i.e. views with predicates computed)
-     */
-    computedViews(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<ComputedView[]>;
-    /**
-     * Layouts all views (ignoring any manual snapshots)
-     */
-    layoutAllViews(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<GraphvizOut[]>;
-    /**
-     * Layouts a view.
-     * If layoutType is 'manual' - applies manual layout if any.
-     * If layoutType is 'auto' - returns latest version with drifts from manual layout if any
-     * If not specified - returns latest layout as is
-     *
-     * If view not found in model, but there is a snapshot - it will be returned (with empty DOT)
-     */
-    layoutView(params: LayoutViewParams): Promise<GraphvizOut | null>;
-    /**
-     * Returns diagrams.
-     * If diagram has manual layout, it will be used.
-     */
-    diagrams(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<Array<DiagramView>>;
-    /**
-     * Returns all layouted views as Graphviz output (i.e. views with layout computed)
-     */
-    viewsAsGraphvizOut(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<Array<GraphvizSvgOut>>;
-    /**
-     * Open view in the preview panel.
-     * (works only if running as a vscode extension)
-     */
-    openView(viewId: ViewId, projectId?: ProjectId | undefined): Promise<void>;
-}
-export declare class DefaultLikeC4Views implements LikeC4Views {
-    private services;
-    private cache;
-    /**
-     * Set of viewIds with reported errors
-     * value is `${projectId}-${viewId}`
-     */
-    private viewsWithReportedErrors;
-    private ModelBuilder;
-    constructor(services: LikeC4Services);
-    get layouter(): QueueGraphvizLayoter;
-    computedViews(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<ComputedView[]>;
-    private _layoutAllViews;
-    layoutAllViews(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<GraphvizOut[]>;
-    layoutView({ viewId, layoutType, projectId, cancelToken, }: LayoutViewParams): Promise<GraphvizOut | null>;
-    diagrams(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<Array<LayoutedView>>;
-    viewsAsGraphvizOut(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<Array<GraphvizSvgOut>>;
-    /**
-     * Open a view in the preview panel.
-     */
-    openView(viewId: ViewId, projectId: ProjectId): Promise<void>;
-    private reportViewError;
-    /**
-     * Applies manual layout or calculates drifts from snapshot
-     * if layoutType is specified
-     */
-    private withLayoutType;
-    private viewSucceed;
-}
-export {};