@likec4/core 0.6.2 → 0.7.0

package/dist/types/opaque.d.ts

@@ -0,0 +1,103 @@
+declare const tag: unique symbol;
+declare 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;
+export {};
+//# sourceMappingURL=opaque.d.ts.map

package/dist/types/opaque.js

@@ -0,0 +1 @@
+export {};

package/dist/types/relation.d.ts

@@ -0,0 +1,11 @@
+import type { Opaque } from './opaque';
+import type { Fqn, Tag } from './element';
+export type RelationID = Opaque<string, 'RelationID'>;
+export interface Relation {
+    readonly id: RelationID;
+    readonly source: Fqn;
+    readonly target: Fqn;
+    readonly title: string;
+    readonly tags?: Tag[];
+}
+//# sourceMappingURL=relation.d.ts.map

package/dist/types/relation.js

@@ -0,0 +1 @@
+export {};

package/dist/types/view.d.ts

@@ -0,0 +1,30 @@
+import type { Opaque } from './opaque';
+import type { ElementShape, Fqn, ThemeColor } from './element';
+import type { ElementExpression, Expression } from './expression';
+export type ViewID = Opaque<string, 'ViewID'>;
+export interface ViewRuleExpression {
+    isInclude: boolean;
+    exprs: Expression[];
+}
+export declare function isViewRuleExpression(rule: ViewRule): rule is ViewRuleExpression;
+export interface ViewRuleStyle {
+    targets: ElementExpression[];
+    style: {
+        color?: ThemeColor;
+        shape?: ElementShape;
+    };
+}
+export declare function isViewRuleStyle(rule: ViewRule): rule is ViewRuleStyle;
+export interface ViewRuleAutoLayout {
+    autoLayout: 'TB' | 'BT' | 'LR' | 'RL';
+}
+export declare function isViewRuleAutoLayout(rule: ViewRule): rule is ViewRuleAutoLayout;
+export type ViewRule = ViewRuleExpression | ViewRuleStyle | ViewRuleAutoLayout;
+export interface ElementView {
+    readonly id: ViewID;
+    readonly viewOf?: Fqn;
+    readonly title?: string;
+    readonly description?: string;
+    readonly rules: ViewRule[];
+}
+//# sourceMappingURL=view.d.ts.map

package/dist/types/view.js

@@ -0,0 +1,9 @@
+export function isViewRuleExpression(rule) {
+    return 'exprs' in rule && 'isInclude' in rule;
+}
+export function isViewRuleStyle(rule) {
+    return 'style' in rule && 'targets' in rule;
+}
+export function isViewRuleAutoLayout(rule) {
+    return 'autoLayout' in rule;
+}

package/dist/utils/fqn.d.ts

@@ -0,0 +1,11 @@
+import type { Element, Fqn } from '../types';
+export declare function nameFromFqn(fqn: Fqn): string;
+export declare function isAncestor(...args: [ancestor: Fqn, another: Fqn] | [ancestor: Element, another: Element]): boolean;
+export declare function isSameHierarchy(...args: [one: Fqn, another: Fqn] | [one: Element, another: Element]): boolean;
+export declare function commonAncestor(first: Fqn, second: Fqn): Fqn | null;
+export declare function parentFqn(fqn: Fqn): Fqn | null;
+export declare const compareFqnHierarchically: (a: string, b: string) => number;
+export declare const compareByFqnHierarchically: <T extends {
+    id: Fqn;
+}>(a: T, b: T) => number;
+//# sourceMappingURL=fqn.d.ts.map

package/dist/utils/fqn.js

@@ -0,0 +1,51 @@
+import { isString } from './guards';
+export function nameFromFqn(fqn) {
+    const lastDot = fqn.lastIndexOf('.');
+    if (lastDot > 0) {
+        return fqn.slice(lastDot + 1);
+    }
+    else {
+        return fqn;
+    }
+}
+export function isAncestor(...args) {
+    const ancestor = isString(args[0]) ? args[0] : args[0].id;
+    const another = isString(args[1]) ? args[1] : args[1].id;
+    return another.startsWith(ancestor + '.');
+}
+export function isSameHierarchy(...args) {
+    const one = isString(args[0]) ? args[0] : args[0].id;
+    const another = isString(args[1]) ? args[1] : args[1].id;
+    return one === another || another.startsWith(one + '.') || one.startsWith(another + '.');
+}
+export function commonAncestor(first, second) {
+    const a = first.split('.');
+    const b = second.split('.');
+    let ancestor = null;
+    while (a.length > 1 && b.length > 1 && !!a[0] && a[0] === b[0]) {
+        ancestor = (ancestor ? `${ancestor}.${a[0]}` : a[0]);
+        a.shift();
+        b.shift();
+    }
+    return ancestor;
+}
+export function parentFqn(fqn) {
+    const lastDot = fqn.lastIndexOf('.');
+    if (lastDot > 0) {
+        return fqn.substring(0, lastDot);
+    }
+    return null;
+}
+export const compareFqnHierarchically = (a, b) => {
+    const depthA = a.split('.').length;
+    const depthB = b.split('.').length;
+    if (depthA === depthB) {
+        return a.localeCompare(b);
+    }
+    else {
+        return depthA - depthB;
+    }
+};
+export const compareByFqnHierarchically = (a, b) => {
+    return compareFqnHierarchically(a.id, b.id);
+};

package/dist/utils/guards.d.ts

@@ -0,0 +1,4 @@
+export declare function isString(value: unknown): value is string;
+export declare function failExpectedNever(arg: never): never;
+export declare function ignoreNeverInRuntime(arg: never): void;
+//# sourceMappingURL=guards.d.ts.map

package/dist/utils/guards.js

@@ -0,0 +1,10 @@
+export function isString(value) {
+    return typeof value === 'string';
+}
+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}`);
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from './fqn';
+export * from './guards';
+export * as Relations from './relations';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.js

@@ -0,0 +1,3 @@
+export * from './fqn';
+export * from './guards';
+export * as Relations from './relations';

package/dist/utils/relations.d.ts

@@ -0,0 +1,17 @@
+import type { Fqn } from '../types';
+type Relation = {
+    source: Fqn;
+    target: Fqn;
+};
+export declare const compareRelations: <T extends {
+    source: Fqn;
+    target: Fqn;
+}>(a: T, b: T) => number;
+export declare const isInside: (parent: Fqn) => (rel: Relation) => boolean;
+export declare const isBetween: (source: Fqn, target: Fqn) => (rel: Relation) => boolean;
+export declare const isAnyBetween: (source: Fqn, target: Fqn) => import("rambdax").Predicate<Relation>;
+export declare const isIncoming: (target: Fqn) => (rel: Relation) => boolean;
+export declare const isOutgoing: (source: Fqn) => (rel: Relation) => boolean;
+export declare const isAnyInOut: (source: Fqn) => import("rambdax").Predicate<Relation>;
+export {};
+//# sourceMappingURL=relations.d.ts.map

package/dist/utils/relations.js

@@ -0,0 +1,36 @@
+import { either } from 'rambdax';
+import { compareFqnHierarchically } from './fqn';
+export const compareRelations = (a, b) => {
+    return (compareFqnHierarchically(a.source, b.source) || compareFqnHierarchically(a.target, b.target));
+};
+export const isInside = (parent) => {
+    const prefix = parent + '.';
+    return (rel) => {
+        return rel.source.startsWith(prefix) && rel.target.startsWith(prefix);
+    };
+};
+export const isBetween = (source, target) => {
+    const sourcePrefix = source + '.';
+    const targetPrefix = target + '.';
+    return (rel) => {
+        return ((rel.source + '.').startsWith(sourcePrefix) && (rel.target + '.').startsWith(targetPrefix));
+    };
+};
+export const isAnyBetween = (source, target) => {
+    return either(isBetween(source, target), isBetween(target, source));
+};
+export const isIncoming = (target) => {
+    const targetPrefix = target + '.';
+    return (rel) => {
+        return (!(rel.source + '.').startsWith(targetPrefix) && (rel.target + '.').startsWith(targetPrefix));
+    };
+};
+export const isOutgoing = (source) => {
+    const sourcePrefix = source + '.';
+    return (rel) => {
+        return ((rel.source + '.').startsWith(sourcePrefix) && !(rel.target + '.').startsWith(sourcePrefix));
+    };
+};
+export const isAnyInOut = (source) => {
+    return either(isIncoming(source), isOutgoing(source));
+};

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@likec4/core",
-  "version": "0.6.2",
+  "version": "0.7.0",
   "license": "MIT",
   "bugs": "https://github.com/likec4/likec4/issues",
-  "homepage": "https://like-c4.dev",
+  "homepage": "https://likec4.dev",
   "author": "Denis Davydkov <denis@davydkov.com>",
   "files": [
-    "dist"
+    "dist",
+    "!**/*.spec.js",
+    "!**/*.spec.d.ts",
+    "!**/*.map"
   ],
   "repository": {
     "type": "git",
@@ -14,8 +17,7 @@
     "directory": "packages/core"
   },
   "scripts": {
-    "compile": "tsc --emitDeclarationOnly",
-    "build:release": "tsc -p tsconfig.esm.json",
+    "compile": "tsc --noEmit",
     "build": "tsc",
     "dev": "tsc --watch",
     "lint": "run -T eslint src/ --fix",
@@ -30,22 +32,22 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
+      "default": "./dist/index.js"
     },
     "./types": {
       "types": "./dist/types/index.d.ts",
       "import": "./dist/types/index.js",
-      "require": "./dist/types/index.cjs"
+      "default": "./dist/types/index.js"
     },
     "./utils": {
       "types": "./dist/utils/index.d.ts",
       "import": "./dist/utils/index.js",
-      "require": "./dist/utils/index.cjs"
+      "default": "./dist/utils/index.js"
     },
     "./compute-view": {
       "types": "./dist/compute-view/index.d.ts",
       "import": "./dist/compute-view/index.js",
-      "require": "./dist/compute-view/index.cjs"
+      "default": "./dist/compute-view/index.js"
     }
   },
   "sideEffects": false,
@@ -58,33 +60,33 @@
       ".": {
         "types": "./dist/index.d.ts",
         "import": "./dist/index.js",
-        "require": "./dist/index.cjs"
+        "default": "./dist/index.js"
       },
       "./types": {
         "types": "./dist/types/index.d.ts",
         "import": "./dist/types/index.js",
-        "require": "./dist/types/index.cjs"
+        "default": "./dist/types/index.js"
       },
       "./utils": {
         "types": "./dist/utils/index.d.ts",
         "import": "./dist/utils/index.js",
-        "require": "./dist/utils/index.cjs"
+        "default": "./dist/utils/index.js"
       },
       "./compute-view": {
         "types": "./dist/compute-view/index.d.ts",
         "import": "./dist/compute-view/index.js",
-        "require": "./dist/compute-view/index.cjs"
+        "default": "./dist/compute-view/index.js"
       }
     }
   },
   "dependencies": {
     "@dagrejs/graphlib": "^2.1.12",
-    "rambdax": "^9.1.0",
+    "rambdax": "^9.1.1",
     "tiny-invariant": "^1.3.1"
   },
   "devDependencies": {
     "typescript": "^5.0.4",
-    "vite": "^4.2.2",
-    "vitest": "^0.30.1"
+    "vite": "^4.3.3",
+    "vitest": "^0.31.0"
   }
 }