@likec4/language-server 1.47.0 → 1.49.0

package/dist/test/testServices.d.ts

@@ -1,64 +0,0 @@
-import type { LikeC4ProjectJsonConfig } from '@likec4/config';
-import type { ComputedLikeC4ModelData } from '@likec4/core';
-import { type LangiumDocument } from 'langium';
-import type { LiteralUnion } from 'type-fest';
-import { URI } from 'vscode-uri';
-import type { LikeC4LangiumDocument } from '../ast';
-export declare function createTestServices(options?: {
-    workspace?: string;
-    projectConfig?: Partial<LikeC4ProjectJsonConfig>;
-}): {
-    services: import("langium").LangiumGeneratedCoreServices & import("langium").LangiumDefaultCoreServices & import("langium/lsp").LangiumLSPServices & import("../module").LikeC4AddedServices;
-    addDocument: (input: string, uri?: string) => Promise<LikeC4LangiumDocument>;
-    removeDocument: (doc: LangiumDocument | URI) => Promise<void>;
-    parse: (input: string, uri?: string) => Promise<LikeC4LangiumDocument>;
-    validate: (input: string | LikeC4LangiumDocument, uri?: string) => Promise<{
-        document: LikeC4LangiumDocument;
-        diagnostics: (import("vscode-languageserver-types").Diagnostic & import("langium").DiagnosticInfo<import("../ast").LikeC4AstNode>)[];
-        warnings: string[];
-        errors: string[];
-    }>;
-    validateAll: () => Promise<{
-        diagnostics: import("vscode-languageserver-types").Diagnostic[];
-        errors: string[];
-        warnings: string[];
-    }>;
-    buildModel: () => Promise<ComputedLikeC4ModelData>;
-    buildLikeC4Model: () => Promise<import("@likec4/core/model").LikeC4Model<import("@likec4/core").UnknownComputed>>;
-    resetState: () => Promise<void>;
-    format: (input: string | LikeC4LangiumDocument, uri?: string) => Promise<string>;
-};
-/**
- * @example
- * ```ts
- * const { projects } = await createMultiProjectTestServices({
- *   project1: {
- *     doc1: `...`,
- *     doc2: `...`,
- *   },
- *   project2: {
- *     doc1: `...`,
- *   },
- * })
- * ```
- */
-export declare function createMultiProjectTestServices<const Projects extends Record<string, Record<string, string>>>(data: Projects): Promise<{
-    services: import("langium").LangiumGeneratedCoreServices & import("langium").LangiumDefaultCoreServices & import("langium/lsp").LangiumLSPServices & import("../module").LikeC4AddedServices;
-    projects: { readonly [K in keyof Projects]: { readonly [L in keyof Projects[K]]: LikeC4LangiumDocument; }; };
-    projectsManager: import("..").ProjectsManager;
-    addDocument: (uri: string | URI, input: string) => Promise<LikeC4LangiumDocument>;
-    /**
-     * Add document outside of projects
-     */
-    addDocumentOutside: (input: string) => Promise<LikeC4LangiumDocument>;
-    validateAll: () => Promise<{
-        diagnostics: import("vscode-languageserver-types").Diagnostic[];
-        errors: string[];
-        warnings: string[];
-    }>;
-    buildModel: (projectId: LiteralUnion<keyof Projects, string>) => Promise<ComputedLikeC4ModelData<import("@likec4/core").UnknownComputed>>;
-    buildLikeC4Model: (projectId: LiteralUnion<keyof Projects, string>) => Promise<import("@likec4/core/model").LikeC4Model<import("@likec4/core").UnknownComputed>>;
-}>;
-export type TestServices = ReturnType<typeof createTestServices>;
-export type TestParseFn = TestServices['validate'];
-export type TestValidateFn = TestServices['validate'];

package/dist/test/testServices.js

@@ -1,210 +0,0 @@
-import { DocumentState, TextDocument, UriUtils } from 'langium';
-import * as assert from 'node:assert';
-import { entries } from 'remeda';
-import stripIndent from 'strip-indent';
-import { DiagnosticSeverity } from 'vscode-languageserver-types';
-import { URI, Utils } from 'vscode-uri';
-import { NoopFileSystem } from '../filesystem';
-import { createLanguageServices } from '../module';
-export function createTestServices(options) {
-    const workspace = options?.workspace ?? 'file:///test/workspace';
-    const projectConfig = options?.projectConfig;
-    const services = createLanguageServices(NoopFileSystem).likec4;
-    const metaData = services.LanguageMetaData;
-    const langiumDocuments = services.shared.workspace.LangiumDocuments;
-    const documentBuilder = services.shared.workspace.DocumentBuilder;
-    const modelBuilder = services.likec4.ModelBuilder;
-    const workspaceUri = URI.parse(workspace);
-    const formatter = services.lsp.Formatter;
-    const workspaceFolder = {
-        name: projectConfig?.name || 'test-project',
-        uri: workspaceUri.toString(),
-    };
-    let isInitialized = false;
-    let documentIndex = 1;
-    async function initialize() {
-        if (isInitialized)
-            return;
-        isInitialized = true;
-        services.shared.workspace.ConfigurationProvider.updateConfiguration({
-            settings: { likec4: { formatting: { quoteStyle: 'single' } } },
-        });
-        services.shared.workspace.WorkspaceManager.initialize({
-            capabilities: {},
-            processId: null,
-            rootUri: workspaceFolder.uri,
-            workspaceFolders: [workspaceFolder],
-        });
-        await services.shared.workspace.WorkspaceManager.initializeWorkspace([workspaceFolder]);
-        // Register project with config if provided...
-        if (projectConfig) {
-            const projectFolderUri = Utils.resolvePath(workspaceUri, 'src');
-            await services.shared.workspace.ProjectsManager.registerProject({
-                config: {
-                    name: projectConfig?.name || 'test-project',
-                    title: projectConfig?.title || 'Test Project',
-                    contactPerson: projectConfig?.contactPerson || 'Unknown',
-                    imageAliases: projectConfig?.imageAliases || {},
-                    exclude: projectConfig?.exclude || ['node_modules'],
-                },
-                folderUri: projectFolderUri,
-            });
-        }
-    }
-    const addDocument = async (input, uri) => {
-        await initialize();
-        const docUri = Utils.resolvePath(workspaceUri, './src/', uri ?? `${documentIndex++}${metaData.fileExtensions[0]}`);
-        const document = services.shared.workspace.LangiumDocumentFactory.fromString(stripIndent(input), docUri);
-        langiumDocuments.addDocument(document);
-        return document;
-    };
-    const removeDocument = async (doc) => {
-        const uri = doc instanceof URI ? doc : doc.uri;
-        await documentBuilder.update([], [uri]);
-    };
-    const parse = async (input, uri) => {
-        const document = await addDocument(input, uri);
-        await documentBuilder.build([document], { validation: false });
-        return document;
-    };
-    const validate = async (input, uri) => {
-        const document = typeof input === 'string' ? await addDocument(input, uri) : input;
-        await documentBuilder.build([document], { validation: true });
-        const diagnostics = document.diagnostics ?? [];
-        const warnings = diagnostics.flatMap(d => d.severity === DiagnosticSeverity.Warning ? d.message : []);
-        const errors = diagnostics.flatMap(d => d.severity === DiagnosticSeverity.Error ? d.message : []);
-        return {
-            document,
-            diagnostics,
-            warnings,
-            errors,
-        };
-    };
-    const format = async (input, uri) => {
-        const document = typeof input === 'string' ? await parse(stripIndent(input), uri) : input;
-        await documentBuilder.build([document], { validation: true });
-        const edits = await formatter?.formatDocument(document, {
-            options: { tabSize: 2, insertSpaces: true },
-            textDocument: { uri: document.uri.toString() },
-        });
-        return TextDocument.applyEdits(document.textDocument, edits ?? []);
-    };
-    const validateAll = async () => {
-        const docs = langiumDocuments.all.toArray();
-        assert.ok(docs.length > 0, 'no documents to validate');
-        await documentBuilder.build(docs, { validation: true });
-        const diagnostics = docs.flatMap(doc => doc.diagnostics ?? []);
-        const warnings = diagnostics.flatMap(d => d.severity === DiagnosticSeverity.Warning ? d.message : []);
-        const errors = diagnostics.flatMap(d => d.severity === DiagnosticSeverity.Error ? d.message : []);
-        return {
-            diagnostics,
-            errors,
-            warnings,
-        };
-    };
-    const buildModel = async () => {
-        if (langiumDocuments.all.some(doc => doc.state < DocumentState.Validated)) {
-            await validateAll();
-        }
-        const likec4model = await modelBuilder.computeModel();
-        if (!likec4model)
-            throw new Error('No model found');
-        return likec4model.$data;
-    };
-    const buildLikeC4Model = async () => {
-        if (langiumDocuments.all.some(doc => doc.state < DocumentState.Validated)) {
-            await validateAll();
-        }
-        const likec4model = await modelBuilder.computeModel();
-        if (!likec4model)
-            throw new Error('No model found');
-        return likec4model;
-    };
-    /**
-     * This will clear all documents
-     */
-    const resetState = async () => {
-        await services.shared.workspace.WorkspaceLock.write(async (cancelToken) => {
-            const docs = langiumDocuments.allExcludingBuiltin.toArray().map(doc => doc.uri);
-            await documentBuilder.update([], docs, cancelToken);
-        });
-    };
-    return {
-        services,
-        addDocument,
-        removeDocument,
-        parse,
-        validate,
-        validateAll,
-        buildModel,
-        buildLikeC4Model,
-        resetState,
-        format,
-    };
-}
-/**
- * @example
- * ```ts
- * const { projects } = await createMultiProjectTestServices({
- *   project1: {
- *     doc1: `...`,
- *     doc2: `...`,
- *   },
- *   project2: {
- *     doc1: `...`,
- *   },
- * })
- * ```
- */
-export async function createMultiProjectTestServices(data) {
-    const workspace = 'file:///test/workspace';
-    const { services, addDocument, validateAll, } = createTestServices({ workspace });
-    const projects = {};
-    for (const [name, files] of entries(data)) {
-        const folderUri = UriUtils.joinPath(URI.parse(workspace), 'src', name);
-        await services.shared.workspace.ProjectsManager.registerProject({
-            config: {
-                name,
-                exclude: ['node_modules'],
-            },
-            folderUri,
-        });
-        // @ts-ignore
-        projects[name] = {};
-        for (let [docName, content] of entries(files)) {
-            const fileName = docName.endsWith('.c4') ? docName : `${docName}.c4`;
-            // @ts-ignore
-            projects[name][docName] = await addDocument(content, `${name}/${fileName}`);
-        }
-    }
-    async function buildLikeC4Model(projectId) {
-        if (services.shared.workspace.LangiumDocuments.all.some(doc => doc.state < DocumentState.Validated)) {
-            await validateAll();
-        }
-        const likec4model = await services.likec4.ModelBuilder.computeModel(projectId);
-        if (!likec4model)
-            throw new Error('No model found');
-        return likec4model;
-    }
-    async function buildModel(projectId) {
-        const model = await buildLikeC4Model(projectId);
-        return model.$data;
-    }
-    return {
-        services,
-        projects,
-        projectsManager: services.shared.workspace.ProjectsManager,
-        addDocument: async (uri, input) => {
-            return await addDocument(input, uri.toString());
-        },
-        /**
-         * Add document outside of projects
-         */
-        addDocumentOutside: async (input) => {
-            return await addDocument(input);
-        },
-        validateAll,
-        buildModel,
-        buildLikeC4Model,
-    };
-}

package/dist/utils/disposable.d.ts

@@ -1,8 +0,0 @@
-import type { Disposable } from 'langium';
-export declare abstract class ADisposable implements Disposable {
-    protected toDispose: Disposable[];
-    protected isDisposed: boolean;
-    onDispose(...disposable: Disposable[]): void;
-    dispose(): void;
-    protected throwIfDisposed(): void;
-}

package/dist/utils/disposable.js

@@ -1,26 +0,0 @@
-import { logWarnError } from '../logger';
-export class ADisposable {
-    toDispose = [];
-    isDisposed = false;
-    onDispose(...disposable) {
-        this.toDispose.push(...disposable);
-    }
-    dispose() {
-        this.throwIfDisposed();
-        this.isDisposed = true;
-        let item;
-        while ((item = this.toDispose.pop())) {
-            try {
-                item.dispose();
-            }
-            catch (e) {
-                logWarnError(e);
-            }
-        }
-    }
-    throwIfDisposed() {
-        if (this.isDisposed) {
-            throw new Error('This has already been disposed');
-        }
-    }
-}

package/dist/utils/elementRef.d.ts

@@ -1,11 +0,0 @@
-import type * as c4 from '@likec4/core';
-import { ast } from '../ast';
-/**
- * Returns referenced AST Element
- */
-export declare function elementRef(node: ast.ElementRef | ast.StrictFqnElementRef): ast.Element | undefined;
-/**
- * Returns FQN of StrictFqnElementRef
- * a.b.c.d - for c node returns a.b.c
- */
-export declare function readStrictFqn(node: ast.StrictFqnElementRef | ast.StrictFqnRef): c4.Fqn;

package/dist/utils/elementRef.js

@@ -1,33 +0,0 @@
-import { ast } from '../ast';
-/**
- * Returns referenced AST Element
- */
-export function elementRef(node) {
-    try {
-        let el = ast.isStrictFqnElementRef(node) ? node.el.ref : node.modelElement.value.ref;
-        if (el?.$type === 'Imported') {
-            el = el.imported.ref;
-        }
-        return el?.$type === 'Element' ? el : undefined;
-    }
-    catch {
-        // ignore reference errors
-        return undefined;
-    }
-}
-/**
- * Returns FQN of StrictFqnElementRef
- * a.b.c.d - for c node returns a.b.c
- */
-export function readStrictFqn(node) {
-    const name = [node.$type === 'StrictFqnRef' ? node.value.$refText : node.el.$refText];
-    let parent = node.parent;
-    while (parent) {
-        name.push(parent.$type === 'StrictFqnRef' ? parent.value.$refText : parent.el.$refText);
-        parent = parent.parent;
-    }
-    if (name.length === 1) {
-        return name[0];
-    }
-    return name.reverse().join('.');
-}

package/dist/utils/fqnRef.d.ts

@@ -1,11 +0,0 @@
-import { ast } from '../ast';
-export declare function referenceableParent(node: ast.FqnRef): ast.Referenceable | null;
-export declare function instanceRef(deploymentRef: ast.FqnRef): ast.DeployedInstance | null;
-export declare function deploymentNodeRef(deploymentRef: ast.FqnRef): ast.DeploymentNode | null;
-export declare function importsRef(node: ast.FqnRef): ast.Imported | null;
-export declare function isImportsRef(node: ast.FqnRef): boolean;
-export declare function isReferenceToLogicalModel(node: ast.FqnRef): boolean;
-/**
- * Returns true if node references deployment model
- */
-export declare function isReferenceToDeploymentModel(node: ast.FqnRef): boolean;

package/dist/utils/fqnRef.js

@@ -1,63 +0,0 @@
-import { AstUtils } from 'langium';
-import { isNullish } from 'remeda';
-import { ast } from '../ast';
-export function referenceableParent(node) {
-    // iterate up the root parent
-    while (node.parent) {
-        node = node.parent;
-    }
-    return node.value.ref ?? null;
-}
-export function instanceRef(deploymentRef) {
-    let referenceable;
-    while ((referenceable = deploymentRef.value?.ref)) {
-        if (ast.isDeploymentNode(referenceable)) {
-            return null;
-        }
-        if (ast.isDeployedInstance(referenceable)) {
-            return referenceable;
-        }
-        if (isNullish(deploymentRef.parent)) {
-            return null;
-        }
-        deploymentRef = deploymentRef.parent;
-    }
-    return null;
-}
-export function deploymentNodeRef(deploymentRef) {
-    let referenceable = deploymentRef.value.ref ?? null;
-    if (!referenceable || ast.isDeploymentNode(referenceable)) {
-        return referenceable;
-    }
-    const artifact = instanceRef(deploymentRef);
-    // Because path in deploymentRef may be omitted,
-    // we find artifact first and then its container
-    return artifact ? AstUtils.getContainerOfType(artifact, ast.isDeploymentNode) ?? null : null;
-}
-export function importsRef(node) {
-    const referenceable = referenceableParent(node);
-    return referenceable?.$type === 'Imported' ? referenceable : null;
-}
-export function isImportsRef(node) {
-    return !!importsRef(node);
-}
-export function isReferenceToLogicalModel(node) {
-    const referenceable = referenceableParent(node);
-    return referenceable?.$type === 'Element';
-}
-/**
- * Returns true if node references deployment model
- */
-export function isReferenceToDeploymentModel(node) {
-    let referenceable;
-    while ((referenceable = node.value?.ref)) {
-        if (ast.isDeploymentElement(referenceable)) {
-            return true;
-        }
-        if (isNullish(node.parent)) {
-            return false;
-        }
-        node = node.parent;
-    }
-    return false;
-}

package/dist/utils/index.d.ts

@@ -1,11 +0,0 @@
-export * from './disposable';
-export * from './elementRef';
-export * from './fqnRef';
-export * from './projectId';
-export * from './stringHash';
-export declare function safeCall<T>(fn: () => T): T | undefined;
-export declare function performanceNow(): number;
-export declare function performanceMark(): {
-    readonly ms: number;
-    readonly pretty: string;
-};

package/dist/utils/index.js

@@ -1,35 +0,0 @@
-import prettyMs from 'pretty-ms';
-import { logger } from '../logger';
-export * from './disposable';
-export * from './elementRef';
-export * from './fqnRef';
-export * from './projectId';
-export * from './stringHash';
-export function safeCall(fn) {
-    try {
-        return fn();
-    }
-    catch (e) {
-        logger.debug(`Safe call failed`, { error: e });
-        return undefined;
-    }
-}
-export function performanceNow() {
-    try {
-        return performance.now();
-    }
-    catch {
-        return Date.now();
-    }
-}
-export function performanceMark() {
-    const t0 = performanceNow();
-    return {
-        get ms() {
-            return performanceNow() - t0;
-        },
-        get pretty() {
-            return prettyMs(performanceNow() - t0);
-        },
-    };
-}

package/dist/utils/printDocs.d.ts

@@ -1,2 +0,0 @@
-import type { LangiumDocument } from 'langium';
-export declare const printDocs: (docs: LangiumDocument[]) => string;

package/dist/utils/printDocs.js

@@ -1 +0,0 @@
-export const printDocs = (docs) => docs.map(d => '  - ' + d.uri.toString(true)).join('\n');

package/dist/utils/projectId.d.ts

@@ -1,4 +0,0 @@
-import { type ProjectId } from '@likec4/core';
-import { type AstNode, type LangiumDocument } from 'langium';
-import { ast } from '../ast';
-export declare function projectIdFrom(value: AstNode | LangiumDocument | ast.ImportsFromPoject | ast.Imported): ProjectId;

package/dist/utils/projectId.js

@@ -1,16 +0,0 @@
-import { invariant, nonNullable } from '@likec4/core';
-import { AstUtils, isAstNode } from 'langium';
-import { ast } from '../ast';
-export function projectIdFrom(value) {
-    if (ast.isImported(value)) {
-        while (value.$type === 'Imported' && value.$container) {
-            value = value.$container;
-        }
-        invariant(ast.isImportsFromPoject(value));
-    }
-    if (ast.isImportsFromPoject(value)) {
-        return value.project;
-    }
-    const doc = isAstNode(value) ? AstUtils.getDocument(value) : value;
-    return nonNullable(doc.likec4ProjectId, () => `Invalid state, document ${doc.uri} has no project ID assigned`);
-}

package/dist/utils/stringHash.d.ts

@@ -1 +0,0 @@
-export declare function stringHash(...str: [string, ...string[]]): string;

package/dist/utils/stringHash.js

@@ -1,5 +0,0 @@
-import { stringHash as hash } from '@likec4/core/utils';
-export function stringHash(...str) {
-    var s = str.length > 1 ? str.join(':::') : str[0];
-    return hash(s);
-}

package/dist/validation/DocumentValidator.d.ts

@@ -1,11 +0,0 @@
-import { type LangiumDocument, type ValidationOptions, Cancellation, DefaultDocumentValidator } from 'langium';
-import type { Diagnostic } from 'vscode-languageserver-types';
-import type { LikeC4Services } from '../module';
-export declare class LikeC4DocumentValidator extends DefaultDocumentValidator {
-    protected services: LikeC4Services;
-    constructor(services: LikeC4Services);
-    /**
-     * If the document is excluded, then we skip validation and return an empty array of diagnostics.
-     */
-    validateDocument(document: LangiumDocument, options?: ValidationOptions, cancelToken?: Cancellation.CancellationToken): Promise<Diagnostic[]>;
-}

package/dist/validation/DocumentValidator.js

@@ -1,17 +0,0 @@
-import { Cancellation, DefaultDocumentValidator } from 'langium';
-export class LikeC4DocumentValidator extends DefaultDocumentValidator {
-    services;
-    constructor(services) {
-        super(services);
-        this.services = services;
-    }
-    /**
-     * If the document is excluded, then we skip validation and return an empty array of diagnostics.
-     */
-    async validateDocument(document, options, cancelToken) {
-        if (this.services.shared.workspace.ProjectsManager.isExcluded(document)) {
-            return [];
-        }
-        return await super.validateDocument(document, options, cancelToken);
-    }
-}

package/dist/validation/_shared.d.ts

@@ -1,3 +0,0 @@
-import type { AstNode, ValidationCheck } from 'langium';
-export declare const RESERVED_WORDS: string[];
-export declare function tryOrLog<T extends AstNode>(fn: ValidationCheck<T>): ValidationCheck<T>;

package/dist/validation/_shared.js

@@ -1,26 +0,0 @@
-import { isPromise } from 'remeda';
-import { logger } from '../logger';
-export const RESERVED_WORDS = [
-    'this',
-    'it',
-    'self',
-    'super',
-    'likec4lib',
-    'global',
-];
-export function tryOrLog(fn) {
-    return async function tryOrLogFn(node, accept, cancelToken) {
-        try {
-            const result = fn(node, accept, cancelToken);
-            if (isPromise(result)) {
-                await result;
-            }
-            return;
-        }
-        catch (e) {
-            const message = e instanceof Error ? e.message : String(e);
-            accept('error', `Validation failed: ${message}`, { node });
-            logger.debug(`Validation failed: ${message}`, { error: e });
-        }
-    };
-}

package/dist/validation/deployment-checks.d.ts

@@ -1,7 +0,0 @@
-import { type ValidationCheck } from 'langium';
-import { ast } from '../ast';
-import type { LikeC4Services } from '../module';
-export declare const deploymentNodeChecks: (services: LikeC4Services) => ValidationCheck<ast.DeploymentNode>;
-export declare const deployedInstanceChecks: (services: LikeC4Services) => ValidationCheck<ast.DeployedInstance>;
-export declare const deploymentRelationChecks: (services: LikeC4Services) => ValidationCheck<ast.DeploymentRelation>;
-export declare const extendDeploymentChecks: (_services: LikeC4Services) => ValidationCheck<ast.ExtendDeployment>;