@likec4/language-server 1.7.4 → 1.8.0

package/src/model-graph/utils/buildElementNotations.ts

@@ -0,0 +1,63 @@
+import type { ComputedNode, ElementNotation } from '@likec4/core'
+import { entries, flatMap, groupBy, map, mapValues, pipe, piped, prop, sortBy, unique } from 'remeda'
+
+/**
+ * Build element notations from computed nodes:
+ * 1. Group by notation
+ * 2. Group by shape
+ * 3. Group by color
+ * 4. For each group get unique kinds
+ * 5. Unwind the groups
+ */
+export function buildElementNotations(nodes: ComputedNode[]): ElementNotation[] {
+  return pipe(
+    nodes,
+    groupBy(prop('notation')),
+    mapValues(
+      piped(
+        groupBy(prop('shape')),
+        mapValues(
+          piped(
+            groupBy(prop('color')),
+            mapValues(
+              piped(
+                map(prop('kind')),
+                unique()
+              )
+            ),
+            entries(),
+            map(([color, kinds]) => ({
+              kinds,
+              color
+            }))
+          )
+        ),
+        entries(),
+        flatMap(([shape, colors]) =>
+          colors.map(({ color, kinds }) => ({
+            shape,
+            color,
+            kinds
+          }))
+        )
+      )
+    ),
+    entries(),
+    flatMap(([title, shapes]) =>
+      shapes.map(({ shape, color, kinds }) => ({
+        title,
+        shape,
+        color,
+        kinds
+      }))
+    ),
+    sortBy(
+      prop('title'),
+      prop('shape'),
+      [
+        n => n.kinds.length,
+        'desc'
+      ]
+    )
+  )
+}

package/src/references/scope-computation.ts

@@ -82,15 +82,15 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
     docExports: AstNodeDescription[],
     document: LikeC4LangiumDocument
   ) {
-    if (isNullish(likec4lib) || likec4lib.length === 0) {
+    if (isNullish(likec4lib)) {
       return
     }
-    for (const iconAst of likec4lib.flatMap(l => l.icons)) {
-      try {
+    try {
+      for (const iconAst of likec4lib.flatMap(l => l.icons)) {
         docExports.push(this.descriptions.createDescription(iconAst, iconAst.name, document))
-      } catch (e) {
-        logError(e)
       }
+    } catch (e) {
+      logError(e)
     }
   }
 

package/src/validation/dynamic-view-rule.ts

@@ -9,10 +9,6 @@ export const dynamicViewRulePredicate = (
   return (predicate, accept) => {
     const expr = elementExpressionFromPredicate(predicate.value)
     switch (true) {
-      case ast.isElementRef(expr):
-      case ast.isElementDescedantsExpression(expr):
-      case ast.isExpandElementExpression(expr):
-        return
       case ast.isElementKindExpression(expr):
       case ast.isElementTagExpression(expr):
       case ast.isWildcardExpression(expr): {
@@ -21,8 +17,6 @@ export const dynamicViewRulePredicate = (
         })
         return
       }
-      default:
-        nonexhaustive(expr)
     }
   }
 }

package/src/validation/property-checks.ts

@@ -28,7 +28,7 @@ export const iconPropertyRuleChecks = (
       })
     }
     if (
-      ast.isStyleProperties(container) && ast.isElementBody(container.$container)
+      ast.isElementStyleProperty(container) && ast.isElementBody(container.$container)
       && container.$container.props.some(p => ast.isIconProperty(p))
     ) {
       accept('warning', `Redundant as icon defined on element`, {

package/src/view-utils/view-hash.ts

@@ -1,6 +1,6 @@
 import type { ComputedView } from '@likec4/core/types'
 import objectHash from 'object-hash'
-import { isString, pick } from 'remeda'
+import { isTruthy, map, mapToObj, pick, pipe } from 'remeda'
 import type { SetOptional } from 'type-fest'
 
 export function calcViewLayoutHash<V extends ComputedView>(view: SetOptional<V, 'hash'>): V {
@@ -8,26 +8,20 @@ export function calcViewLayoutHash<V extends ComputedView>(view: SetOptional<V,
     id: view.id,
     __: view.__ ?? 'element',
     autoLayout: view.autoLayout,
-    nodes: view.nodes
-      .map(pick(['id', 'title', 'description', 'technology', 'shape', 'icon', 'children']))
-      .toSorted((a, b) => a.id.localeCompare(b.id)),
-    edges: view.edges
-      .map(pick(['id', 'source', 'target', 'label', 'description', 'technology', 'dir', 'head', 'tail', 'line']))
-      .toSorted((a, b) => a.id.localeCompare(b.id))
+    nodes: pipe(
+      view.nodes,
+      map(pick(['id', 'title', 'description', 'technology', 'shape', 'icon', 'children'])),
+      mapToObj(({ id, icon, ...node }) => [id, { ...node, icon: isTruthy(icon) ? 'Y' : 'N' }])
+    ),
+    edges: pipe(
+      view.edges,
+      map(pick(['source', 'target', 'label', 'description', 'technology', 'dir', 'head', 'tail', 'line'])),
+      mapToObj(({ source, target, ...edge }) => [`${source}:${target}`, edge])
+    )
   }
   view.hash = objectHash(tohash, {
     ignoreUnknown: true,
-    respectType: false,
-    replacer(value) {
-      if (!isString(value)) {
-        return value
-      }
-      value = value.trim()
-      if (value.match('^(aws|tech|gcp|https|http)')) {
-        value = 'U' // hide urls
-      }
-      return value
-    }
+    respectType: false
   })
   return view as V
 }