@likec4/language-server 0.6.2 → 0.8.0

package/dist/test/testServices.js

@@ -0,0 +1,58 @@
+import { createLanguageServices } from '../module';
+import { EmptyFileSystem } from 'langium';
+import { URI } from 'vscode-uri';
+export function createTestServices() {
+    const services = createLanguageServices(EmptyFileSystem).likec4;
+    const metaData = services.LanguageMetaData;
+    const langiumDocuments = services.shared.workspace.LangiumDocuments;
+    const documentBuilder = services.shared.workspace.DocumentBuilder;
+    const modelBuilder = services.likec4.ModelBuilder;
+    const initPromise = services.shared.workspace.WorkspaceManager.initializeWorkspace([]);
+    let documentIndex = 1;
+    const parse = async (input, uri) => {
+        await initPromise;
+        uri = uri ?? `${documentIndex++}${metaData.fileExtensions[0]}`;
+        const document = services.shared.workspace.LangiumDocumentFactory.fromString(input, URI.file(uri));
+        langiumDocuments.addDocument(document);
+        await documentBuilder.build([document], { validationChecks: 'none' });
+        return document;
+    };
+    const validate = async (input) => {
+        await initPromise;
+        const document = typeof input === 'string' ? await parse(input) : input;
+        await documentBuilder.build([document], { validationChecks: 'all' });
+        const diagnostics = document.diagnostics ?? [];
+        const errors = diagnostics.map(d => d.message);
+        return {
+            document,
+            diagnostics,
+            errors
+        };
+    };
+    const validateAll = async () => {
+        await initPromise;
+        const docs = langiumDocuments.all.toArray();
+        await documentBuilder.build(docs, { validationChecks: 'all' });
+        const diagnostics = docs.flatMap(doc => doc.diagnostics ?? []);
+        const errors = diagnostics.map(d => d.message);
+        return {
+            diagnostics,
+            errors
+        };
+    };
+    const buildModel = async () => {
+        await validateAll();
+        const model = modelBuilder.buildModel();
+        if (!model)
+            throw new Error('No model found');
+        return model;
+    };
+    return {
+        services,
+        parse,
+        validate,
+        validateAll,
+        buildModel
+    };
+}
+//# sourceMappingURL=testServices.js.map

package/dist/utils.d.ts

@@ -0,0 +1,3 @@
+export declare function failExpectedNever(arg: never): never;
+export declare function ignoreNeverInRuntime(arg: never): void;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.js

@@ -0,0 +1,8 @@
+export function failExpectedNever(arg) {
+    throw new Error(`Unexpected value: ${JSON.stringify(arg)}`);
+}
+export function ignoreNeverInRuntime(arg) {
+    console.warn(`Unexpected and ignored value: ${JSON.stringify(arg)}`);
+    // throw new Error(`Unexpected value: ${arg}`);
+}
+//# sourceMappingURL=utils.js.map

package/dist/validation/element.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import type { ValidationCheck } from 'langium';
+import type { ast } from '../ast';
+import type { LikeC4Services } from '../module';
+export declare const elementChecks: (services: LikeC4Services) => ValidationCheck<ast.Element>;
+//# sourceMappingURL=element.d.ts.map

package/dist/validation/element.js

@@ -0,0 +1,21 @@
+export const elementChecks = (services) => {
+    const fqnIndex = services.likec4.FqnIndex;
+    return (el, accept) => {
+        const fqn = fqnIndex.get(el);
+        if (!fqn) {
+            accept('error', 'Not indexed', {
+                node: el,
+                property: 'name'
+            });
+            return;
+        }
+        const withSameFqn = fqnIndex.byFqn(fqn).limit(2).count();
+        if (withSameFqn > 1) {
+            accept('error', `Duplicate element name ${el.name !== fqn ? el.name + ' (' + fqn + ')' : el.name}`, {
+                node: el,
+                property: 'name'
+            });
+        }
+    };
+};
+//# sourceMappingURL=element.js.map

package/dist/validation/index.d.ts

@@ -0,0 +1,3 @@
+import type { LikeC4Services } from '../module';
+export declare function registerValidationChecks(services: LikeC4Services): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/validation/index.js

@@ -0,0 +1,23 @@
+import { elementChecks } from './element';
+import { relationChecks } from './relation';
+import { elementKindChecks, tagChecks } from './specification';
+import { viewChecks } from './view';
+export function registerValidationChecks(services) {
+    const registry = services.validation.ValidationRegistry;
+    // const checks: ValidationChecks = {
+    // Element: validator.checkElementNameDuplicates,
+    // Tag: validator.checkTagDuplicates,
+    // ElementKind: elementKindChecks(services),
+    // ElementStyleProperty: validator.checkElementStyleProperty,
+    // View: validator.checkViewNameDuplicates,
+    // ColorStyleProperty: validator.checkColorStyleProperty,
+    // }
+    registry.register({
+        ElementView: viewChecks(services),
+        Element: elementChecks(services),
+        ElementKind: elementKindChecks(services),
+        Relation: relationChecks(services),
+        Tag: tagChecks(services)
+    });
+}
+//# sourceMappingURL=index.js.map

package/dist/validation/relation.d.ts

@@ -0,0 +1,5 @@
+import type { ValidationCheck } from 'langium';
+import type { ast } from '../ast';
+import type { LikeC4Services } from '../module';
+export declare const relationChecks: (services: LikeC4Services) => ValidationCheck<ast.Relation>;
+//# sourceMappingURL=relation.d.ts.map

package/dist/validation/relation.js

@@ -0,0 +1,54 @@
+import { resolveRelationPoints } from '../ast';
+import { isSameHierarchy } from '@likec4/core/utils';
+export const relationChecks = (services) => {
+    const fqnIndex = services.likec4.FqnIndex;
+    return (el, accept) => {
+        try {
+            const coupling = resolveRelationPoints(el);
+            const target = fqnIndex.get(coupling.target);
+            if (!target) {
+                return accept('error', 'Invalid target', {
+                    node: el,
+                    property: 'target'
+                });
+            }
+            const source = fqnIndex.get(coupling.source);
+            if (!source) {
+                return accept('error', 'Invalid source', {
+                    node: el
+                });
+            }
+            if (isSameHierarchy(source, target)) {
+                return accept('error', 'Invalid relation (same hierarchy)', {
+                    node: el
+                });
+            }
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                return accept('error', e.message, {
+                    node: el
+                });
+            }
+            accept('error', 'Invalid relation', {
+                node: el
+            });
+        }
+        // const fqn = fqnIndex.get(el)
+        // if (!fqn) {
+        //   accept('error', 'Not indexed', {
+        //     node: el,
+        //     property: 'name',
+        //   })
+        //   return
+        // }
+        // const withSameFqn = fqnIndex.byFqn(fqn)
+        // if (withSameFqn.length > 1) {
+        //   accept('error', `Duplicate element name ${el.name !== fqn ? el.name +' (' + fqn + ')' : el.name}`, {
+        //     node: el,
+        //     property: 'name',
+        //   })
+        // }
+    };
+};
+//# sourceMappingURL=relation.js.map

package/dist/validation/specification.d.ts

@@ -0,0 +1,6 @@
+import type { ValidationCheck } from 'langium';
+import { ast } from '../ast';
+import type { LikeC4Services } from '../module';
+export declare const elementKindChecks: (services: LikeC4Services) => ValidationCheck<ast.ElementKind>;
+export declare const tagChecks: (services: LikeC4Services) => ValidationCheck<ast.Tag>;
+//# sourceMappingURL=specification.d.ts.map

package/dist/validation/specification.js

@@ -0,0 +1,34 @@
+import { ast } from '../ast';
+export const elementKindChecks = (services) => {
+    const index = services.shared.workspace.IndexManager;
+    return (node, accept) => {
+        const sameKinds = index
+            .allElements(ast.ElementKind)
+            .filter(n => n.name === node.name)
+            .limit(2)
+            .count();
+        if (sameKinds > 1) {
+            accept('error', `Duplicate element kind '${node.name}'`, {
+                node: node,
+                property: 'name'
+            });
+        }
+    };
+};
+export const tagChecks = (services) => {
+    const index = services.shared.workspace.IndexManager;
+    return (node, accept) => {
+        const sameKinds = index
+            .allElements(ast.Tag)
+            .filter(n => n.name === node.name)
+            .limit(2)
+            .count();
+        if (sameKinds > 1) {
+            accept('error', `Duplicate tag '${node.name}'`, {
+                node: node,
+                property: 'name'
+            });
+        }
+    };
+};
+//# sourceMappingURL=specification.js.map

package/dist/validation/view.d.ts

@@ -0,0 +1,5 @@
+import type { ValidationCheck } from 'langium';
+import { ast } from '../ast';
+import type { LikeC4Services } from '../module';
+export declare const viewChecks: (services: LikeC4Services) => ValidationCheck<ast.ElementView>;
+//# sourceMappingURL=view.d.ts.map

package/dist/validation/view.js

@@ -0,0 +1,21 @@
+import { ast } from '../ast';
+export const viewChecks = (services) => {
+    const index = services.shared.workspace.IndexManager;
+    return (el, accept) => {
+        if (!el.name) {
+            return;
+        }
+        const anotherViews = index
+            .allElements(ast.View)
+            .filter(n => n.name === el.name)
+            .limit(2)
+            .count();
+        if (anotherViews > 1) {
+            accept('error', `Duplicate view '${el.name}'`, {
+                node: el,
+                property: 'name'
+            });
+        }
+    };
+};
+//# sourceMappingURL=view.js.map

package/package.json

@@ -1,21 +1,26 @@
 {
   "name": "@likec4/language-server",
   "description": "LikeC4 Language Server",
-  "version": "0.6.2",
+  "version": "0.8.0",
   "license": "MIT",
-  "type": "module",
   "bugs": "https://github.com/likec4/likec4/issues",
-  "homepage": "https://like-c4.dev",
+  "homepage": "https://likec4.dev",
   "author": "Denis Davydkov <denis@davydkov.com>",
   "files": [
     "dist",
-    "contrib"
+    "contrib",
+    "!**/__mocks__/",
+    "!**/__test__/",
+    "!**/*.spec.js",
+    "!**/*.spec.d.ts",
+    "!**/*.map"
   ],
   "repository": {
     "type": "git",
     "url": "https://github.com/likec4/likec4.git",
     "directory": "packages/language-server"
   },
+  "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -23,12 +28,12 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
+      "require": "./dist/index.js"
     },
     "./builtin": {
       "types": "./dist/builtin.d.ts",
       "import": "./dist/builtin.js",
-      "require": "./dist/builtin.cjs"
+      "require": "./dist/builtin.js"
     }
   },
   "publishConfig": {
@@ -41,58 +46,48 @@
       ".": {
         "types": "./dist/index.d.ts",
         "import": "./dist/index.js",
-        "require": "./dist/index.cjs"
+        "require": "./dist/index.js"
       },
       "./builtin": {
         "types": "./dist/builtin.d.ts",
         "import": "./dist/builtin.js",
-        "require": "./dist/builtin.cjs"
+        "require": "./dist/builtin.js"
       }
     }
   },
   "scripts": {
-    "compile": "tsc --emitDeclarationOnly",
-    "build:release": "run generate && tsc -p tsconfig.esm.json",
-    "build:langium": "langium generate",
-    "build:ts": "tsc",
+    "turbo-build": "run -T turbo run build --filter='language-server'",
+    "compile": "tsc --noEmit",
     "watch:langium": "langium generate --watch",
     "watch:ts": "tsc --watch",
     "generate": "langium generate",
-    "build": "run-s 'build:langium' 'build:ts'",
-    "dev": "run generate && run-p 'watch:*'",
+    "build": "tsc",
+    "dev": "run-p 'watch:*'",
     "lint": "run -T eslint src/ --fix",
     "clean": "run -T rimraf dist contrib",
     "test": "vitest run",
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@likec4/core": "0.6.2",
-    "@likec4/language-protocol": "0.6.2",
+    "@likec4/core": "0.7.0",
     "@mobily/ts-belt": "^3.13.1",
+    "langium": "^1.2.0",
     "nanoid": "^4.0.2",
     "object-hash": "^3.0.0",
-    "rambdax": "^9.1.0",
+    "rambdax": "^9.1.1",
     "strip-indent": "^4.0.0",
     "tiny-invariant": "^1.3.1",
-    "type-fest": "^3.8.0",
-    "vscode-uri": "~3.0.7"
-  },
-  "peerDependencies": {
-    "langium": "^1.1.0",
-    "vscode-languageserver-protocol": "~3.17.2"
-  },
-  "peerDependenciesMeta": {
-    "vscode-languageserver-protocol": {
-      "optional": true
-    }
+    "type-fest": "^3.9.0",
+    "vscode-languageserver": "~8.1.0",
+    "vscode-languageserver-protocol": "~3.17.3"
   },
   "devDependencies": {
     "@types/node": "^18.15.11",
     "@types/object-hash": "^3.0.2",
-    "langium-cli": "^1.1.0",
+    "langium-cli": "^1.2.0",
     "npm-run-all": "^4.1.5",
     "typescript": "^5.0.4",
-    "vite": "^4.2.2",
-    "vitest": "^0.30.1"
+    "vite": "^4.3.3",
+    "vitest": "^0.31.0"
   }
 }