@likec4/language-server 1.6.0 → 1.7.0

package/src/validation/view-predicates/{custom-relation-expr.ts → relation-with.ts}

@@ -2,9 +2,9 @@ import { AstUtils, type ValidationCheck } from 'langium'
 import { ast } from '../../ast'
 import type { LikeC4Services } from '../../module'
 
-export const customRelationExprChecks = (
+export const relationPredicateWithChecks = (
   _services: LikeC4Services
-): ValidationCheck<ast.CustomRelationExpression> => {
+): ValidationCheck<ast.RelationPredicateWith> => {
   return (el, accept) => {
     const container = AstUtils.getContainerOfType(el, ast.isViewRulePredicate)
     if (ast.isExcludePredicate(container)) {

package/src/validation/view.ts

@@ -1,18 +1,17 @@
-import { CstUtils, type ValidationCheck } from 'langium'
+import { type ValidationCheck } from 'langium'
 import { ast } from '../ast'
 import type { LikeC4Services } from '../module'
-import { deserializeFromComment, hasManualLayout } from '../view-utils/manual-layout'
 
 export const viewChecks = (services: LikeC4Services): ValidationCheck<ast.LikeC4View> => {
   const index = services.shared.workspace.IndexManager
   return (el, accept) => {
-    const commentNode = CstUtils.findCommentNode(el.$cstNode, ['BLOCK_COMMENT'])
-    if (commentNode && hasManualLayout(commentNode.text) && !deserializeFromComment(commentNode.text)) {
-      accept('warning', `Malformed @likec4-generated (ignored)`, {
-        node: el,
-        range: commentNode.range
-      })
-    }
+    // const commentNode = CstUtils.findCommentNode(el.$cstNode, ['BLOCK_COMMENT'])
+    // if (commentNode && hasManualLayout(commentNode.text) && !deserializeFromComment(commentNode.text)) {
+    //   accept('warning', `Malformed @likec4-generated (ignored)`, {
+    //     node: el,
+    //     range: commentNode.range
+    //   })
+    // }
     if (!el.name) {
       return
     }

package/src/view-utils/manual-layout.ts

@@ -1,64 +1,65 @@
-import { invariant } from '@likec4/core'
-import type { EdgeId, Fqn, ViewManualLayout } from '@likec4/core/types'
-import JSON5 from 'json5'
-import { chunk, entries, hasAtLeast, mapToObj } from 'remeda'
+import type { ViewManualLayout } from '@likec4/core/types'
+import { decode, encode } from '@msgpack/msgpack'
+import { fromBase64, toBase64 } from '@smithy/util-base64'
+import { mapValues } from 'remeda'
 
-export namespace CompactViewManualLayout {
-  export type Node = [
-    id: Fqn,
-    x: number,
-    y: number,
-    width: number,
-    height: number
-  ]
-
-  export type Edge = [
-    id: EdgeId,
-    // flatten array of points, [x1, y1, x2, y2, ...]
-    controlPoints: number[]
-  ]
-
-  // TODO replace with Zod/Valibot
-  export function isCompactLayout(layout: any): layout is CompactViewManualLayout {
-    return Array.isArray(layout) && hasAtLeast(layout, 3)
-      && layout[0] === 1
-      && Array.isArray(layout[1])
-      && Array.isArray(layout[2])
-  }
-
-  export function pack(layout: ViewManualLayout): CompactViewManualLayout {
-    return [
-      1,
-      entries(layout.nodes).map(([id, { x, y, width, height }]) => [id as Fqn, x, y, width, height]),
-      entries(layout.edges).map((
-        [id, { controlPoints }]
-      ) => [id as EdgeId, controlPoints.flatMap(({ x, y }) => [x, y])])
-    ]
+function pack({
+  nodes,
+  edges,
+  ...rest
+}: ViewManualLayout) {
+  return {
+    ...rest,
+    nodes: mapValues(nodes, ({ x, y, width, height, isCompound, ...n }) => ({
+      ...n,
+      b: [x, y, width, height] as const,
+      c: isCompound
+    })),
+    edges: mapValues(edges, ({ points, controlPoints, labelBBox, dotpos, ...e }) => ({
+      ...!!controlPoints && { cp: controlPoints },
+      ...!!labelBBox && { l: labelBBox },
+      ...!!dotpos && { dp: dotpos },
+      ...e,
+      p: points
+    }))
   }
+}
 
-  export function unpack([_v, nodes, edges]: CompactViewManualLayout): ViewManualLayout {
-    return {
-      nodes: mapToObj(nodes, ([id, x, y, width, height]) => [id, { x, y, width, height }]),
-      // edges: Object.fromEntries(edges.map(([id, controlPoints]) => [id, { controlPoints: mapWithFeedback(controlPoints, (x, y) => ({ x, y }), { x: 0, y: 0 }) }])
-      edges: mapToObj(edges, ([id, controlPoints]) => {
-        return [id, {
-          controlPoints: chunk(controlPoints, 2).map(([x, y = 0]) => ({ x, y }))
-        }]
-      })
-    }
+function unpack({
+  nodes,
+  edges,
+  ...rest
+}: ReturnType<typeof pack>): ViewManualLayout {
+  return {
+    ...rest,
+    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, dp, ...e }) => ({
+      ...!!cp && { controlPoints: cp },
+      ...!!l && { labelBBox: l },
+      ...!!dp && { dotpos: dp },
+      ...e,
+      points: p
+    }))
   }
 }
 
-export type CompactViewManualLayout = [
-  1, // version
-  nodes: Array<CompactViewManualLayout.Node>,
-  edges: Array<CompactViewManualLayout.Edge>
-]
-
 export function serializeToComment(layout: ViewManualLayout) {
-  const compacted = CompactViewManualLayout.pack(layout)
-  const encoded = btoa(JSON5.stringify(compacted))
-  const lines = chunk(Array.from(encoded), 100).map(l => ' * ' + l.join(''))
+  const bytes = encode(pack(layout))
+  const base64 = toBase64(bytes)
+  const lines = [] as string[]
+  let offset = 0
+  const MAX_LINE_LENGTH = 200
+  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)'
@@ -72,24 +73,16 @@ export function hasManualLayout(comment: string) {
   return comment.includes('@likec4-generated')
 }
 
-export function deserializeFromComment(comment: string): ViewManualLayout | undefined {
+export function deserializeFromComment(comment: string): ViewManualLayout {
   if (!hasManualLayout(comment)) {
-    console.error(`Not a likec4-generated comment: ${comment}`)
-    return undefined
-  }
-  try {
-    const b64 = comment
-      .trim()
-      .split('\n')
-      .filter(l => !l.includes('**') && !l.includes('@likec4-') && !l.includes('*/'))
-      .map(l => l.replaceAll('*', '').trim())
-      .join('')
-    const decodedb64 = atob(b64)
-    const compacted = JSON5.parse(decodedb64)
-    invariant(CompactViewManualLayout.isCompactLayout(compacted), 'Invalid compacted layout')
-    return CompactViewManualLayout.unpack(compacted)
-  } catch (e) {
-    console.error(e)
-    return undefined
+    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) as any) as ViewManualLayout
 }

package/src/view-utils/resolve-relative-paths.ts

@@ -1,14 +1,20 @@
 import type { LikeC4View } from '@likec4/core'
 import { invariant } from '@likec4/core'
-import { hasAtLeast, unique, zip } from 'remeda'
+import { filter, hasAtLeast, isTruthy, map, pipe, unique, zip } from 'remeda'
 
 function commonAncestorPath(views: LikeC4View[], sep = '/') {
-  if (views.length <= 1) return ''
-  const uniqURIs = unique(views.flatMap(({ docUri }) => (docUri ? [docUri] : [])))
+  const uniqURIs = pipe(
+    views,
+    map(v => v.docUri),
+    filter(isTruthy),
+    unique()
+  )
   if (uniqURIs.length === 0) return ''
-  if (uniqURIs.length === 1) {
-    invariant(hasAtLeast(uniqURIs, 1))
-    return new URL(uniqURIs[0]).pathname
+  if (hasAtLeast(uniqURIs, 1) && uniqURIs.length === 1) {
+    const parts = new URL(uniqURIs[0]).pathname.split(sep)
+    if (parts.length <= 1) return sep
+    parts.pop() // remove filename
+    return parts.join(sep) + sep
   }
   invariant(hasAtLeast(uniqURIs, 2), 'Expected at least 2 unique URIs')
   const [baseUri, ...tail] = uniqURIs
@@ -31,7 +37,8 @@ function commonAncestorPath(views: LikeC4View[], sep = '/') {
 }
 
 export function resolveRelativePaths(views: LikeC4View[]): LikeC4View[] {
-  const commonPrefix = commonAncestorPath(views)
+  const sep = '/'
+  const commonPrefix = commonAncestorPath(views, sep)
   return (
     views
       // For each view, compute the relative path to the common prefix
@@ -43,12 +50,19 @@ export function resolveRelativePaths(views: LikeC4View[]): LikeC4View[] {
             parts: []
           }
         }
-        const path = new URL(view.docUri).pathname
-        const parts = path.replace(commonPrefix, '').split('/')
-        parts.pop() // remove filename
+        let path = new URL(view.docUri).pathname
+        if (commonPrefix.length > 0) {
+          invariant(
+            path.startsWith(commonPrefix),
+            `Expect path "${path}" to start with common prefix: "${commonPrefix}"`
+          )
+          path = path.slice(commonPrefix.length)
+        } else {
+          path = path.includes(sep) ? path.slice(path.lastIndexOf(sep) + 1) : path
+        }
         return {
           ...view,
-          parts
+          parts: path.split(sep)
         }
       })
       // Sort views by path segments
@@ -72,13 +86,10 @@ export function resolveRelativePaths(views: LikeC4View[]): LikeC4View[] {
       })
       // Build relativePath from path segments
       .map(({ parts, ...view }) => {
-        if (view.docUri) {
-          return {
-            ...view,
-            relativePath: parts.join('/')
-          }
+        return {
+          ...view,
+          relativePath: parts.join(sep)
         }
-        return view
       })
   )
 }

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

@@ -0,0 +1,33 @@
+import type { ComputedView } from '@likec4/core/types'
+import objectHash from 'object-hash'
+import { isString, pick } from 'remeda'
+import type { SetOptional } from 'type-fest'
+
+export function calcViewLayoutHash<V extends ComputedView>(view: SetOptional<V, 'hash'>): V {
+  const tohash = {
+    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))
+  }
+  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
+    }
+  })
+  return view as V
+}