@likec4/core 1.20.0 → 1.20.2

package/src/builder/Builder-style1.test-d.ts

@@ -1,190 +0,0 @@
-import { expectTypeOf, test } from 'vitest'
-import type { LikeC4Model } from '../model/LikeC4Model'
-import type { ParsedLikeC4Model } from '../types'
-import { Builder } from './Builder'
-
-test('Builder types - style 1', () => {
-  const {
-    model: {
-      model,
-      actor,
-      system,
-      component,
-      relTo,
-    },
-    deployment: {
-      deployment,
-      instanceOf,
-      env,
-      vm,
-    },
-    views: {
-      deploymentView,
-      views,
-      view,
-      viewOf,
-      $rules,
-      $include,
-    },
-    builder,
-  } = Builder.forSpecification({
-    elements: {
-      actor: {
-        style: {
-          shape: 'person',
-        },
-      },
-      system: {},
-      component: {},
-    },
-    deployments: {
-      env: {},
-      vm: {},
-    },
-    relationships: {
-      like: {},
-      dislike: {},
-    },
-    tags: ['tag1', 'tag2', 'tag1'],
-  })
-
-  const m = builder
-    .with(
-      model(
-        actor('alice'),
-        actor('bob'),
-        system('cloud').with(
-          component('backend').with(
-            component('api'),
-            component('db'),
-          ),
-          component('frontend').with(
-            relTo('cloud.backend.api'),
-          ),
-        ),
-      ),
-      deployment(
-        env('prod').with(
-          vm('vm1'),
-        ),
-        env('prod.vm2'),
-        env('dev').with(
-          vm('vm1'),
-          instanceOf('cloud.backend.api'),
-          instanceOf(
-            'wrong',
-            // @ts-expect-error
-            'non-existing',
-          ),
-          vm('vm2'),
-        ),
-      ),
-      views(
-        view(
-          'view',
-          // @ts-expect-error
-          $include('wrong'),
-        ), // rules inside
-        view(
-          'view',
-          // @ts-expect-error #tag22 is not defined
-          $include('cloud.backend', {
-            where: 'tag is #tag22',
-          }),
-        ),
-        // using with
-        view('view').with(
-          // @ts-expect-error
-          $include('wrong'),
-          // @ts-expect-error
-          $style('wrong', { color: 'red' }),
-        ),
-      ),
-      views(
-        viewOf('view-of', 'cloud.backend.api'),
-        // @ts-expect-error
-        viewOf('view-of', 'wrong'),
-        viewOf(
-          'view-of',
-          'cloud.backend.api',
-          $rules(
-            $include('* -> *'),
-            // @ts-expect-error
-            $include('wrong'),
-          ),
-        ),
-        viewOf(
-          'view-of',
-          // @ts-expect-error
-          '-cloud.backend.api',
-          'Title',
-        ),
-        viewOf(
-          'view-of',
-          // @ts-expect-error
-          '-cloud.backend.api',
-          $rules(),
-        ),
-        viewOf(
-          'view-of',
-          'cloud.backend.api',
-          { title: 'asdasd' },
-          $rules(
-            $include('* -> *'),
-            // @ts-expect-error
-            $include('wrong'),
-          ),
-        ),
-      ),
-      views(
-        deploymentView(
-          'deployment',
-          $rules(
-            // @ts-expect-error
-            $include('pr'),
-          ),
-        ),
-        deploymentView(
-          'deployment',
-          'Title',
-          $rules(
-            // @ts-expect-error
-            $include('pr'),
-          ),
-        ),
-        deploymentView('deployment').with(
-          // @ts-expect-error
-          $include('pr'),
-        ),
-      ),
-    )
-
-  expectTypeOf(m.Types.Fqn).toEqualTypeOf(
-    '' as 'alice' | 'bob' | 'cloud' | 'cloud.backend' | 'cloud.backend.api' | 'cloud.backend.db' | 'cloud.frontend',
-  )
-  expectTypeOf(m.Types.ViewId).toEqualTypeOf(
-    '' as 'view' | 'view-of' | 'deployment',
-  )
-  expectTypeOf(m.Types.DeploymentFqn).toEqualTypeOf(
-    '' as 'prod' | 'dev' | 'prod.vm1' | 'prod.vm2' | 'dev.vm1' | 'dev.vm2' | 'dev.api' | 'dev.wrong',
-  )
-
-  expectTypeOf(m.build()).toEqualTypeOf(
-    {} as ParsedLikeC4Model<
-      'actor' | 'system' | 'component',
-      'like' | 'dislike',
-      'tag1' | 'tag2',
-      'alice' | 'bob' | 'cloud' | 'cloud.backend' | 'cloud.backend.api' | 'cloud.backend.db' | 'cloud.frontend',
-      'view' | 'view-of' | 'deployment',
-      'prod' | 'dev' | 'prod.vm1' | 'prod.vm2' | 'dev.vm1' | 'dev.vm2' | 'dev.api' | 'dev.wrong'
-    >,
-  )
-
-  expectTypeOf(m.toLikeC4Model()).toEqualTypeOf(
-    {} as LikeC4Model.Computed<
-      'alice' | 'bob' | 'cloud' | 'cloud.backend' | 'cloud.backend.api' | 'cloud.backend.db' | 'cloud.frontend',
-      'prod' | 'dev' | 'prod.vm1' | 'prod.vm2' | 'dev.vm1' | 'dev.vm2' | 'dev.api' | 'dev.wrong',
-      'view' | 'view-of' | 'deployment'
-    >,
-  )
-})

package/src/builder/Builder-style2.test-d.ts

@@ -1,175 +0,0 @@
-import { expectTypeOf, test } from 'vitest'
-import type { LikeC4Model } from '../model/LikeC4Model'
-import type { ParsedLikeC4Model } from '../types'
-import { Builder } from './Builder'
-
-test('Builder types - style 2', () => {
-  const m = Builder
-    .specification({
-      elements: {
-        actor: {
-          style: {
-            shape: 'person',
-          },
-        },
-        system: {},
-        component: {},
-      },
-      deployments: {
-        env: {},
-        vm: {},
-      },
-      relationships: {
-        like: {},
-        dislike: {},
-      },
-      tags: ['tag1', 'tag2', 'tag1'],
-    })
-    .model(({ actor, system, component, relTo }, _) =>
-      _(
-        actor('alice'),
-        actor('bob'),
-        system('cloud').with(
-          component('backend').with(
-            component('api'),
-            component('db'),
-          ),
-          component('frontend').with(
-            // @ts-expect-error
-            relTo('non-existing'),
-          ),
-        ),
-      )
-    )
-    .deployment(({ env, vm, instanceOf }, _) =>
-      _(
-        env('prod').with(
-          vm('vm1'),
-          vm('vm2'),
-        ),
-        env('dev').with(
-          vm('vm1'),
-          instanceOf('cloud.backend.api'),
-          instanceOf(
-            'wrong',
-            // @ts-expect-error
-            'non-existing',
-          ),
-          vm('vm2'),
-        ),
-      )
-    )
-    // Test Element View
-    .views(({ view, $include, $style }, _) =>
-      _(
-        // rules inside
-        view(
-          'view',
-          // @ts-expect-error
-          $include('wrong'),
-          // @ts-expect-error #tag22 is not defined
-          $include('cloud.backend', {
-            where: 'tag is #tag22',
-          }),
-        ),
-        // using with
-        view('view').with(
-          // @ts-expect-error
-          $include('wrong'),
-          // @ts-expect-error
-          $style('wrong', { color: 'red' }),
-        ),
-      )
-    )
-    // Test Element View Of
-    .views(({ viewOf, $rules, $include }, _) =>
-      _(
-        viewOf('view-of', 'cloud.backend'),
-        // @ts-expect-error
-        viewOf('view-of', 'wrong'),
-        viewOf(
-          'view-of',
-          'cloud.backend.api',
-          $rules(
-            // @ts-expect-error
-            $include('wrong'),
-          ),
-        ),
-        viewOf(
-          'view-of',
-          'cloud.backend.api',
-          $rules(
-            // @ts-expect-error
-            $include('wrong'),
-          ),
-        ).with(
-          $include('* -> alice.*'),
-          // @ts-expect-error
-          $include('wrong'),
-        ),
-        viewOf(
-          'view-of',
-          // @ts-expect-error
-          'cloud.backensd.api',
-          'Title',
-        ).with(
-          $include('* -> alice.*'),
-          // @ts-expect-error
-          $include('wrong'),
-        ),
-      )
-    )
-    // Test Deployment View
-    .views(({ deploymentView, $rules, $include }, _) =>
-      _(
-        deploymentView(
-          'deployment',
-          $rules(
-            // @ts-expect-error
-            $include('pr'),
-          ),
-        ),
-        deploymentView(
-          'deployment',
-          'Title',
-          $rules(
-            // @ts-expect-error
-            $include('pr'),
-          ),
-        ),
-        deploymentView('deployment').with(
-          // @ts-expect-error
-          $include('pr'),
-        ),
-      )
-    )
-
-  expectTypeOf(m.Types.Fqn).toEqualTypeOf(
-    '' as 'alice' | 'bob' | 'cloud' | 'cloud.backend' | 'cloud.backend.api' | 'cloud.backend.db' | 'cloud.frontend',
-  )
-  expectTypeOf(m.Types.ViewId).toEqualTypeOf(
-    '' as 'view' | 'view-of' | 'deployment',
-  )
-  expectTypeOf(m.Types.DeploymentFqn).toEqualTypeOf(
-    '' as 'prod' | 'dev' | 'prod.vm1' | 'prod.vm2' | 'dev.vm1' | 'dev.vm2' | 'dev.api' | 'dev.wrong',
-  )
-
-  expectTypeOf(m.build()).toEqualTypeOf(
-    {} as ParsedLikeC4Model<
-      'actor' | 'system' | 'component',
-      'like' | 'dislike',
-      'tag1' | 'tag2',
-      'alice' | 'bob' | 'cloud' | 'cloud.backend' | 'cloud.backend.api' | 'cloud.backend.db' | 'cloud.frontend',
-      'view' | 'view-of' | 'deployment',
-      'prod' | 'dev' | 'prod.vm1' | 'prod.vm2' | 'dev.vm1' | 'dev.vm2' | 'dev.api' | 'dev.wrong'
-    >,
-  )
-
-  expectTypeOf(m.toLikeC4Model()).toEqualTypeOf(
-    {} as LikeC4Model.Computed<
-      'alice' | 'bob' | 'cloud' | 'cloud.backend' | 'cloud.backend.api' | 'cloud.backend.db' | 'cloud.frontend',
-      'prod' | 'dev' | 'prod.vm1' | 'prod.vm2' | 'dev.vm1' | 'dev.vm2' | 'dev.api' | 'dev.wrong',
-      'view' | 'view-of' | 'deployment'
-    >,
-  )
-})

package/src/compute-view/utils/uniqueTags.test.ts

@@ -1,42 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { uniqueTags } from './uniqueTags'
-
-describe('uniqueTags function', () => {
-  it('returns unique tags from an array of elements', () => {
-    const input = [
-      { tags: ['tag1', 'tag2', 'tag3'] },
-      { tags: ['tag2', 'tag3', 'tag4'] },
-      { tags: ['tag3', 'tag4', 'tag5'] }
-    ] as const
-    const result = uniqueTags(input)
-    expect(result).toEqual(['tag1', 'tag2', 'tag3', 'tag4', 'tag5'])
-  })
-
-  it('should return unique tags naturally sorted', () => {
-    const input = [
-      { tags: ['tag1', 'tag20', 'tag30'] },
-      { tags: ['tag2', 'tag23', 'tag34'] },
-      { tags: ['tag3'] }
-    ] as const
-    const result = uniqueTags(input)
-    expect(result).toEqual([
-      'tag1',
-      'tag2',
-      'tag3',
-      'tag20',
-      'tag23',
-      'tag30',
-      'tag34'
-    ])
-    // ].sort(compareNatural))
-  })
-
-  it('returns null if the tags array is null', () => {
-    const input = [
-      { tags: null },
-      {}
-    ]
-    const result = uniqueTags(input)
-    expect(result).toBeNull()
-  })
-})

package/src/model/LikeC4Model.test-d.ts

@@ -1,152 +0,0 @@
-import { expectTypeOf, test } from 'vitest'
-import { Builder } from '../builder'
-import type { ComputedView, Fqn, ViewId } from '../types'
-import { LikeC4Model } from './LikeC4Model'
-
-test('LikeC4Model.create: should have types', () => {
-  const {
-    model: {
-      model,
-      actor,
-      system,
-      component,
-      relTo
-    },
-    deployment: {
-      deployment,
-      instanceOf,
-      env,
-      vm
-    },
-    views: {
-      deploymentView,
-      views,
-      view,
-      $include
-    },
-    builder
-  } = Builder.forSpecification({
-    elements: {
-      actor: {
-        style: {
-          shape: 'person'
-        }
-      },
-      system: {},
-      component: {}
-    },
-    deployments: {
-      env: {},
-      vm: {}
-    },
-    relationships: {
-      like: {},
-      dislike: {}
-    },
-    tags: ['tag1', 'tag2', 'tag1']
-  })
-
-  const source = builder
-    .with(
-      model(
-        actor('alice'),
-        actor('bob'),
-        system('cloud').with(
-          component('backend').with(
-            component('api'),
-            component('db')
-          ),
-          component('frontend').with(
-            relTo('cloud.backend.api')
-          )
-        )
-      ),
-      deployment(
-        env('prod').with(
-          vm('vm1'),
-          vm('vm2')
-        ),
-        env('dev').with(
-          vm('vm1'),
-          instanceOf('api', 'cloud.backend.api'),
-          vm('vm2')
-        )
-      ),
-      views(
-        view('index', $include('*')),
-        deploymentView('prodview', $include('*'))
-      )
-    )
-    .build()
-
-  const m = LikeC4Model.compute(source)
-
-  // @ts-expect-error
-  m.element('wrong')
-
-  expectTypeOf(m.Aux.Element).toEqualTypeOf(
-    '' as 'alice' | 'bob' | 'cloud' | 'cloud.backend' | 'cloud.backend.api' | 'cloud.backend.db' | 'cloud.frontend'
-  )
-  expectTypeOf(m.Aux.Fqn).toEqualTypeOf(
-    '' as Fqn<'alice' | 'bob' | 'cloud' | 'cloud.backend' | 'cloud.backend.api' | 'cloud.backend.db' | 'cloud.frontend'>
-  )
-  expectTypeOf(m.Aux.ViewId).toEqualTypeOf(
-    '' as ViewId<'index' | 'prodview'>
-  )
-  expectTypeOf(m.Aux.ViewType).toEqualTypeOf(
-    {} as ComputedView<ViewId<'index' | 'prodview'>>
-  )
-  expectTypeOf(m.Aux.Deployment).toEqualTypeOf(
-    '' as 'prod' | 'dev' | 'prod.vm1' | 'prod.vm2' | 'dev.vm1' | 'dev.vm2' | 'dev.api'
-  )
-  expectTypeOf(m.Aux.DeploymentFqn).toEqualTypeOf(
-    '' as Fqn<'prod' | 'dev' | 'prod.vm1' | 'prod.vm2' | 'dev.vm1' | 'dev.vm2' | 'dev.api'>
-  )
-})
-
-test('LikeC4Model.fromDump: should have types', () => {
-  const m = LikeC4Model.fromDump({
-    specification: {
-      tags: [],
-      elements: {},
-      relationships: {},
-      deployments: {}
-    },
-    elements: {
-      el1: {},
-      el2: {}
-    },
-    relations: {},
-    globals: {
-      predicates: {},
-      dynamicPredicates: {},
-      styles: {}
-    },
-    views: {
-      v1: {},
-      v2: {}
-    },
-    deployments: {
-      elements: {
-        d1: {},
-        d2: {}
-      },
-      relations: {}
-    }
-  })
-  expectTypeOf(m.Aux.Element).toEqualTypeOf(
-    '' as 'el1' | 'el2'
-  )
-  expectTypeOf(m.Aux.Fqn).toEqualTypeOf(
-    '' as Fqn<'el1' | 'el2'>
-  )
-  expectTypeOf(m.Aux.ViewId).toEqualTypeOf(
-    '' as ViewId<'v1' | 'v2'>
-  )
-  expectTypeOf(m.Aux.Deployment).toEqualTypeOf(
-    '' as 'd1' | 'd2'
-  )
-  expectTypeOf(m.Aux.DeploymentFqn).toEqualTypeOf(
-    '' as Fqn<'d1' | 'd2'>
-  )
-})