@likec4/core 1.8.1 → 1.10.0

package/dist/utils/relations.spec.js

@@ -1,210 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { compareRelations, Relations } from './relations';
-const { isAnyBetween, isAnyInOut, isBetween, isIncoming, isInside, isOutgoing } = Relations;
-const relations = [
-    {
-        id: 'customer:cloud.frontend.dashboard',
-        source: 'customer',
-        target: 'cloud.frontend.dashboard',
-        title: ''
-    },
-    {
-        id: 'support:cloud.frontend.adminPanel',
-        source: 'support',
-        target: 'cloud.frontend.adminPanel',
-        title: ''
-    },
-    {
-        id: 'cloud.backend.storage:amazon.s3',
-        source: 'cloud.backend.storage',
-        target: 'amazon.s3',
-        title: ''
-    },
-    {
-        id: 'amazon.api:cloud.backend.graphql',
-        source: 'amazon.api',
-        target: 'cloud.backend.graphql',
-        title: ''
-    },
-    {
-        id: 'cloud.backend.graphql:cloud.backend.storage',
-        source: 'cloud.backend.graphql',
-        target: 'cloud.backend.storage',
-        title: ''
-    },
-    {
-        id: 'cloud.frontend.dashboard:cloud.backend.graphql',
-        source: 'cloud.frontend.dashboard',
-        target: 'cloud.backend.graphql',
-        title: ''
-    },
-    {
-        id: 'cloud.frontend.adminPanel:cloud.backend.graphql',
-        source: 'cloud.frontend.adminPanel',
-        target: 'cloud.backend.graphql',
-        title: ''
-    }
-];
-describe('relation predicates', () => {
-    const expectRelations = (predicate) => expect(relations.filter(predicate).map(r => r.id));
-    const customer = 'customer';
-    const cloud = 'cloud';
-    const frontend = 'cloud.frontend';
-    const backend = 'cloud.backend';
-    it('isBetween: cloud.frontend -> cloud.backend', () => {
-        expectRelations(isBetween(frontend, backend)).toEqual([
-            'cloud.frontend.dashboard:cloud.backend.graphql',
-            'cloud.frontend.adminPanel:cloud.backend.graphql'
-        ]);
-    });
-    it('isBetween: cloud.frontend.dashboard -> cloud.backend', () => {
-        expectRelations(isBetween('cloud.frontend.dashboard', backend)).toEqual([
-            'cloud.frontend.dashboard:cloud.backend.graphql'
-        ]);
-    });
-    it('isBetween: cloud.backend -> cloud.frontend', () => {
-        expectRelations(isBetween(backend, frontend)).toEqual([]);
-    });
-    it('isBetween: cloud.backend -> cloud.backend', () => {
-        expectRelations(isBetween(backend, backend)).toEqual([
-            'cloud.backend.graphql:cloud.backend.storage'
-        ]);
-    });
-    it('isBetween: customer -> cloud', () => {
-        expectRelations(isBetween(customer, cloud)).toEqual(['customer:cloud.frontend.dashboard']);
-    });
-    it('isIncoming: customer', () => {
-        expectRelations(isIncoming(customer)).toEqual([]);
-    });
-    it('isIncoming: cloud', () => {
-        expectRelations(isIncoming(cloud)).toEqual([
-            'customer:cloud.frontend.dashboard',
-            'support:cloud.frontend.adminPanel',
-            'amazon.api:cloud.backend.graphql'
-        ]);
-    });
-    it('isIncoming: cloud.frontend', () => {
-        expectRelations(isIncoming(frontend)).toEqual([
-            'customer:cloud.frontend.dashboard',
-            'support:cloud.frontend.adminPanel'
-        ]);
-    });
-    it('isIncoming: cloud.frontend.dashboard', () => {
-        expectRelations(isIncoming('cloud.frontend.dashboard')).toEqual([
-            'customer:cloud.frontend.dashboard'
-        ]);
-    });
-    it('isOutgoing: cloud', () => {
-        expectRelations(isOutgoing(cloud)).toEqual(['cloud.backend.storage:amazon.s3']);
-    });
-    it('isOutgoing: cloud.frontend', () => {
-        expectRelations(isOutgoing(frontend)).toEqual([
-            'cloud.frontend.dashboard:cloud.backend.graphql',
-            'cloud.frontend.adminPanel:cloud.backend.graphql'
-        ]);
-    });
-    it('isOutgoing: cloud.backend.storage', () => {
-        expectRelations(isOutgoing('cloud.backend.storage')).toEqual([
-            'cloud.backend.storage:amazon.s3'
-        ]);
-    });
-    it('isInside: cloud', () => {
-        expectRelations(isInside(cloud)).toEqual([
-            'cloud.backend.graphql:cloud.backend.storage',
-            'cloud.frontend.dashboard:cloud.backend.graphql',
-            'cloud.frontend.adminPanel:cloud.backend.graphql'
-        ]);
-    });
-    it('isInside: cloud.frontend', () => {
-        expectRelations(isInside(frontend)).toEqual([]);
-    });
-    it('isInside: cloud.backend', () => {
-        expectRelations(isInside(backend)).toEqual(['cloud.backend.graphql:cloud.backend.storage']);
-    });
-    it('isAnyInOut: customer', () => {
-        expectRelations(isAnyInOut(customer)).toEqual(['customer:cloud.frontend.dashboard']);
-    });
-    it('isAnyInOut: cloud', () => {
-        expectRelations(isAnyInOut(cloud)).toEqual([
-            'customer:cloud.frontend.dashboard',
-            'support:cloud.frontend.adminPanel',
-            'cloud.backend.storage:amazon.s3',
-            'amazon.api:cloud.backend.graphql'
-        ]);
-    });
-    it('isAnyBetween: cloud and amazon', () => {
-        expectRelations(isAnyBetween(cloud, 'amazon')).toEqual([
-            'cloud.backend.storage:amazon.s3',
-            'amazon.api:cloud.backend.graphql'
-        ]);
-    });
-});
-describe('compareRelations', () => {
-    function rel(source, target) {
-        return {
-            source,
-            target
-        };
-    }
-    function sorted(...relations) {
-        return relations.sort(compareRelations).map(r => r.source + ' -> ' + r.target);
-    }
-    it('should sort by source and target', () => {
-        expect(sorted(rel('customer', 'cloud.ui'), rel('customer', 'cloud'))).toEqual([
-            'customer -> cloud',
-            'customer -> cloud.ui'
-        ]);
-        expect(sorted(rel('1', '2.1'), rel('1', '2'), rel('1.1.1', '2'), rel('1.1.1', '2.1'), rel('1.1', '2'))).toEqual(['1 -> 2', '1 -> 2.1', '1.1 -> 2', '1.1.1 -> 2', '1.1.1 -> 2.1']);
-    });
-    it('should sort by parent', () => {
-        expect(sorted(
-        // same parent
-        rel('cloud.1.1', 'cloud.2.1'), rel('cloud.1.1', 'cloud.2'), rel('cloud.1', 'cloud.2.1'), rel('cloud.1', 'cloud.2'), 
-        // no same parent
-        rel('cloud.1.1', 'aws.1'), rel('cloud.1', 'aws.1'), rel('cloud', 'aws'))).toEqual([
-            'cloud -> aws',
-            'cloud.1 -> aws.1',
-            'cloud.1.1 -> aws.1',
-            'cloud.1 -> cloud.2',
-            'cloud.1 -> cloud.2.1',
-            'cloud.1.1 -> cloud.2',
-            'cloud.1.1 -> cloud.2.1'
-        ]);
-    });
-    it('should sort by ancestors', () => {
-        expect(sorted(
-        // same parent 2nd level
-        rel('cloud.api.1', 'cloud.api.2'), rel('cloud.ui.1', 'cloud.ui.2'), rel('cloud.ui.2', 'cloud.ui.1'), 
-        // same ancestor cloud
-        rel('cloud.ui.1', 'cloud.api.1'), rel('cloud.ui.2', 'cloud.api.2'), rel('cloud.ui', 'cloud.api.1'), 
-        // same parent 1st level
-        rel('cloud.ui', 'cloud.api'), 
-        // no same parent
-        rel('cloud.api.1', 'aws.1'), rel('cloud.api', 'aws.1'), rel('cloud.api', 'aws'), rel('cloud.ui.1', 'aws.1'), rel('cloud.ui', 'aws'), rel('cloud', 'aws'))).toEqual([
-            'cloud -> aws',
-            'cloud.api -> aws',
-            'cloud.ui -> aws',
-            'cloud.api -> aws.1',
-            'cloud.api.1 -> aws.1',
-            'cloud.ui.1 -> aws.1',
-            'cloud.ui -> cloud.api',
-            'cloud.ui -> cloud.api.1',
-            'cloud.ui.1 -> cloud.api.1',
-            'cloud.ui.2 -> cloud.api.2',
-            'cloud.api.1 -> cloud.api.2',
-            'cloud.ui.1 -> cloud.ui.2',
-            'cloud.ui.2 -> cloud.ui.1'
-        ]);
-    });
-    it('should sort relations from example', () => {
-        expect(sorted(...relations)).toEqual([
-            'customer -> cloud.frontend.dashboard',
-            'support -> cloud.frontend.adminPanel',
-            'amazon.api -> cloud.backend.graphql',
-            'cloud.backend.storage -> amazon.s3',
-            'cloud.frontend.dashboard -> cloud.backend.graphql',
-            'cloud.frontend.adminPanel -> cloud.backend.graphql',
-            'cloud.backend.graphql -> cloud.backend.storage'
-        ]);
-    });
-});

package/src/errors/errors.spec.ts

@@ -1,88 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import {
-  BaseError,
-  InvalidArgError,
-  InvalidModelError,
-  invariant,
-  InvariantError,
-  NonExhaustiveError,
-  normalizeError,
-  NullableError,
-  RelationRefError,
-  UnknownError
-} from './index'
-
-describe('errors', () => {
-  describe('normalizeError', () => {
-    it.each([
-      { error: new BaseError('BaseError') },
-      { error: new RelationRefError('RelationRefError') },
-      { error: new UnknownError('UnknownError') },
-      { error: new InvariantError('InvariantError') },
-      { error: new NonExhaustiveError('NonExhaustiveError') },
-      { error: new InvalidModelError('InvalidModelError') },
-      { error: new NullableError('NullableError') },
-      { error: new InvalidArgError('InvalidArgError') }
-    ])('should return $error.name as-is', ({ error }) => {
-      expect(normalizeError(error)).toBe(error)
-    })
-
-    it.skip('should wrap an error', () => {
-      const cause = new Error('original test')
-      const error = normalizeError(cause)
-      expect(error).toBeInstanceOf(UnknownError)
-      expect(error).to.include({
-        name: 'UnknownError',
-        message: 'original test'
-      })
-      expect(error).to.have.property('cause').that.eq(cause)
-      expect(error)
-        .to.have.property('stack')
-        .that.is.a('string')
-        .and.includes('UnknownError: original test')
-    })
-
-    it('should wrap a string', () => {
-      const cause = 'error string'
-      const error = normalizeError(cause)
-      expect(error).toBeInstanceOf(UnknownError)
-      expect(error).to.include({
-        name: 'UnknownError',
-        message: cause
-      })
-      expect(error).not.to.have.property('cause')
-      expect(error).to.have.property('stack').that.is.a('string')
-    })
-
-    // Fails on serializiation of AST
-    it.skip('should wrap an object', () => {
-      const cause = { foo: 'bar' }
-      const error = normalizeError(cause)
-      expect(error).toBeInstanceOf(UnknownError)
-      expect(error).to.include({
-        name: 'UnknownError',
-        message: '{"foo":"bar"}'
-      })
-      expect(error).not.to.have.property('cause')
-      expect(error).to.have.property('stack').that.is.a('string')
-    })
-  })
-})
-
-describe('invariant', () => {
-  it('should throw an error if the condition fails', () => {
-    expect(() => invariant(false)).toThrow('Invariant failed')
-  })
-
-  it('should throw an error if the condition is null', () => {
-    expect(() => invariant(null)).toThrow(InvariantError)
-  })
-
-  it('should not throw an error if the condition passes', () => {
-    expect(() => invariant(true)).not.toThrow()
-  })
-
-  it('should throw an error with the provided message if the condition fails', () => {
-    expect(() => invariant(false, 'test')).toThrow('test')
-  })
-})

package/src/reset.d.ts

@@ -1,2 +0,0 @@
-// Do not add any other lines of code to this file!
-import '@total-typescript/ts-reset'

package/src/types/opaque.ts

@@ -1,108 +0,0 @@
-declare const tag: unique symbol
-
-type Tagged<Token> = {
-  readonly [tag]: Token
-}
-
-/**
-Create an opaque type, which hides its internal details from the public, and can only be created by being used explicitly.
-
-The generic type parameter can be anything. It doesn't have to be an object.
-
-[Read more about opaque types.](https://codemix.com/opaque-types-in-javascript/)
-
-There have been several discussions about adding this feature to TypeScript via the `opaque type` operator, similar to how Flow does it. Unfortunately, nothing has (yet) moved forward:
-	- [Microsoft/TypeScript#202](https://github.com/microsoft/TypeScript/issues/202)
-	- [Microsoft/TypeScript#15408](https://github.com/Microsoft/TypeScript/issues/15408)
-	- [Microsoft/TypeScript#15807](https://github.com/Microsoft/TypeScript/issues/15807)
-
-@example
-```
-import type {Opaque} from 'type-fest';
-
-type AccountNumber = Opaque<number, 'AccountNumber'>;
-type AccountBalance = Opaque<number, 'AccountBalance'>;
-
-// The `Token` parameter allows the compiler to differentiate between types, whereas "unknown" will not. For example, consider the following structures:
-type ThingOne = Opaque<string>;
-type ThingTwo = Opaque<string>;
-
-// To the compiler, these types are allowed to be cast to each other as they have the same underlying type. They are both `string & { __opaque__: unknown }`.
-// To avoid this behaviour, you would instead pass the "Token" parameter, like so.
-type NewThingOne = Opaque<string, 'ThingOne'>;
-type NewThingTwo = Opaque<string, 'ThingTwo'>;
-
-// Now they're completely separate types, so the following will fail to compile.
-function createNewThingOne (): NewThingOne {
-	// As you can see, casting from a string is still allowed. However, you may not cast NewThingOne to NewThingTwo, and vice versa.
-	return 'new thing one' as NewThingOne;
-}
-
-// This will fail to compile, as they are fundamentally different types.
-const thingTwo = createNewThingOne() as NewThingTwo;
-
-// Here's another example of opaque typing.
-function createAccountNumber(): AccountNumber {
-	return 2 as AccountNumber;
-}
-
-function getMoneyForAccount(accountNumber: AccountNumber): AccountBalance {
-	return 4 as AccountBalance;
-}
-
-// This will compile successfully.
-getMoneyForAccount(createAccountNumber());
-
-// But this won't, because it has to be explicitly passed as an `AccountNumber` type.
-getMoneyForAccount(2);
-
-// You can use opaque values like they aren't opaque too.
-const accountNumber = createAccountNumber();
-
-// This will not compile successfully.
-const newAccountNumber = accountNumber + 2;
-
-// As a side note, you can (and should) use recursive types for your opaque types to make them stronger and hopefully easier to type.
-type Person = {
-	id: Opaque<number, Person>;
-	name: string;
-};
-```
-
-@category Type
-*/
-export type Opaque<Type, Token = unknown> = Type & Tagged<Token>
-
-/**
-Revert an opaque type back to its original type by removing the readonly `[tag]`.
-
-Why is this necessary?
-
-1. Use an `Opaque` type as object keys
-2. Prevent TS4058 error: "Return type of exported function has or is using name X from external module Y but cannot be named"
-
-@example
-```
-import type {Opaque, UnwrapOpaque} from 'type-fest';
-
-type AccountType = Opaque<'SAVINGS' | 'CHECKING', 'AccountType'>;
-
-const moneyByAccountType: Record<UnwrapOpaque<AccountType>, number> = {
-	SAVINGS: 99,
-	CHECKING: 0.1
-};
-
-// Without UnwrapOpaque, the following expression would throw a type error.
-const money = moneyByAccountType.SAVINGS; // TS error: Property 'SAVINGS' does not exist
-
-// Attempting to pass an non-Opaque type to UnwrapOpaque will raise a type error.
-type WontWork = UnwrapOpaque<string>;
-```
-
-@category Type
-*/
-export type UnwrapOpaque<OpaqueType extends Tagged<unknown>> = OpaqueType extends Opaque<
-  infer Type,
-  OpaqueType[typeof tag]
-> ? Type
-  : OpaqueType