@likec4/core 1.7.1 → 1.7.3

package/dist/types/expression.d.ts

@@ -64,7 +64,7 @@ export declare function isElement(expr: Expression): expr is ElementExpression;
 export interface ElementWhereExpr extends Omit<BaseExpr, 'where'> {
     where: {
         expr: ElementExpression;
-        condition: WhereOperator;
+        condition: WhereOperator<string, string>;
     };
 }
 export declare function isElementWhere(expr: Expression): expr is ElementWhereExpr;
@@ -93,7 +93,7 @@ export declare function isRelationExpression(expr: Expression): expr is Relation
 export interface RelationWhereExpr extends Omit<BaseExpr, 'where'> {
     where: {
         expr: RelationExpression;
-        condition: WhereOperator;
+        condition: WhereOperator<string, string>;
     };
 }
 export declare function isRelationWhere(expr: Expression): expr is RelationWhereExpr;

package/dist/types/operators.d.ts

@@ -1,35 +1,44 @@
 import type { NonEmptyArray } from './_common';
 export type EqualOperator<V> = {
     eq: V;
+    neq?: never;
 } | {
+    eq?: never;
     neq: V;
 };
-export interface TagEqual {
-    tag: EqualOperator<string>;
-}
-export declare const isTagEqual: (operator: WhereOperator) => operator is TagEqual;
-export interface KindEqual {
-    kind: EqualOperator<string>;
-}
-export declare const isKindEqual: (operator: WhereOperator) => operator is KindEqual;
-export interface NotOperator<T> {
-    not: T;
-}
-export declare const isNotOperator: (operator: WhereOperator) => operator is NotOperator<WhereOperator>;
-export interface AndOperator<T> {
-    and: NonEmptyArray<T>;
-}
-export declare const isAndOperator: (operator: WhereOperator) => operator is AndOperator<WhereOperator>;
-export interface OrOperator<T> {
-    or: NonEmptyArray<T>;
-}
-export declare const isOrOperator: (operator: WhereOperator) => operator is OrOperator<WhereOperator>;
-export type WhereOperator = TagEqual | KindEqual | NotOperator<WhereOperator> | AndOperator<WhereOperator> | OrOperator<WhereOperator>;
+type AllNever = {
+    not?: never;
+    and?: never;
+    or?: never;
+    tag?: never;
+    kind?: never;
+};
+export type TagEqual<Tag> = Omit<AllNever, 'tag'> & {
+    tag: EqualOperator<Tag>;
+};
+export declare const isTagEqual: <Tag>(operator: WhereOperator<Tag, any>) => operator is TagEqual<Tag>;
+export type KindEqual<Kind> = Omit<AllNever, 'kind'> & {
+    kind: EqualOperator<Kind>;
+};
+export declare const isKindEqual: <Kind>(operator: WhereOperator<any, Kind>) => operator is KindEqual<Kind>;
+export type NotOperator<Tag, Kind> = Omit<AllNever, 'not'> & {
+    not: WhereOperator<Tag, Kind>;
+};
+export declare const isNotOperator: <Tag, Kind>(operator: WhereOperator<Tag, Kind>) => operator is NotOperator<Tag, Kind>;
+export type AndOperator<Tag, Kind> = Omit<AllNever, 'and'> & {
+    and: NonEmptyArray<WhereOperator<Tag, Kind>>;
+};
+export declare const isAndOperator: <Tag, Kind>(operator: WhereOperator<Tag, Kind>) => operator is AndOperator<Tag, Kind>;
+export type OrOperator<Tag, Kind> = Omit<AllNever, 'or'> & {
+    or: NonEmptyArray<WhereOperator<Tag, Kind>>;
+};
+export declare const isOrOperator: <Tag, Kind>(operator: WhereOperator<Tag, Kind>) => operator is OrOperator<Tag, Kind>;
+export type WhereOperator<Tag, Kind> = TagEqual<Tag> | KindEqual<Kind> | NotOperator<Tag, Kind> | AndOperator<Tag, Kind> | OrOperator<Tag, Kind>;
 type Filterable<FTag extends string = string, FKind extends string = string> = {
     tags?: FTag[] | null;
     kind?: FKind;
 };
 type OperatorPredicate<V extends Filterable> = (value: V) => boolean;
-export declare function whereOperatorAsPredicate<FTag extends string = string, FKind extends string = string>(operator: WhereOperator): OperatorPredicate<Filterable<FTag, FKind>>;
+export declare function whereOperatorAsPredicate<FTag extends string = string, FKind extends string = string>(operator: WhereOperator<FTag, FKind>): OperatorPredicate<Filterable<FTag, FKind>>;
 export {};
 //# sourceMappingURL=operators.d.ts.map

package/dist/types/view-changes.d.ts

@@ -1,8 +1,8 @@
 import type { NonEmptyArray } from './_common';
 import type { BorderStyle, ElementShape, Fqn } from './element';
 import type { ThemeColor } from './theme';
-import type { ViewManualLayout } from './view';
-export declare namespace ViewChanges {
+import type { AutoLayoutDirection, ViewManualLayout } from './view';
+export declare namespace ViewChange {
     interface ChangeElementStyle {
         op: 'change-element-style';
         style: {
@@ -17,6 +17,10 @@ export declare namespace ViewChanges {
         op: 'save-manual-layout';
         layout: ViewManualLayout;
     }
+    interface ChangeAutoLayout {
+        op: 'change-autolayout';
+        layout: AutoLayoutDirection;
+    }
 }
-export type ViewChangeOp = ViewChanges.ChangeElementStyle | ViewChanges.SaveManualLayout;
+export type ViewChange = ViewChange.ChangeElementStyle | ViewChange.SaveManualLayout | ViewChange.ChangeAutoLayout;
 //# sourceMappingURL=view-changes.d.ts.map

package/dist/types/view.d.ts

@@ -2,7 +2,7 @@ import type { IconUrl, NonEmptyArray, Point, XYPoint } from './_common';
 import type { ElementKind, ElementShape, ElementStyle, Fqn, Tag } from './element';
 import type { ElementExpression, ElementPredicateExpression, Expression } from './expression';
 import type { Opaque } from './opaque';
-import type { RelationID, RelationshipArrowType, RelationshipLineType } from './relation';
+import type { RelationID, RelationshipArrowType, RelationshipKind, RelationshipLineType } from './relation';
 import type { ThemeColor } from './theme';
 export type ViewID = Opaque<string, 'ViewID'>;
 export type ViewRulePredicate = {
@@ -138,10 +138,12 @@ export interface ComputedEdge {
     description?: string;
     technology?: string;
     relations: RelationID[];
+    kind?: RelationshipKind;
     color?: ThemeColor;
     line?: RelationshipLineType;
     head?: RelationshipArrowType;
     tail?: RelationshipArrowType;
+    tags?: NonEmptyArray<Tag>;
     /**
      * If this edge is derived from custom relationship predicate
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@likec4/core",
-  "version": "1.7.1",
+  "version": "1.7.3",
   "license": "MIT",
   "homepage": "https://likec4.dev",
   "author": "Denis Davydkov <denis@davydkov.com>",
@@ -71,7 +71,7 @@
     "type-fest": "^4.21.0"
   },
   "devDependencies": {
-    "@likec4/tsconfig": "1.7.1",
+    "@likec4/tsconfig": "1.7.3",
     "@total-typescript/ts-reset": "^0.5.1",
     "execa": "^9.3.0",
     "typescript": "^5.5.4",

package/src/types/expression.ts

@@ -96,7 +96,7 @@ export function isElement(expr: Expression): expr is ElementExpression {
 export interface ElementWhereExpr extends Omit<BaseExpr, 'where'> {
   where: {
     expr: ElementExpression
-    condition: WhereOperator
+    condition: WhereOperator<string, string>
   }
 }
 export function isElementWhere(expr: Expression): expr is ElementWhereExpr {
@@ -146,7 +146,7 @@ export function isRelationExpression(expr: Expression): expr is RelationExpressi
 export interface RelationWhereExpr extends Omit<BaseExpr, 'where'> {
   where: {
     expr: RelationExpression
-    condition: WhereOperator
+    condition: WhereOperator<string, string>
   }
 }
 export function isRelationWhere(expr: Expression): expr is RelationWhereExpr {

package/src/types/operators.ts

@@ -4,58 +4,61 @@ import type { NonEmptyArray } from './_common'
 
 export type EqualOperator<V> = {
   eq: V
+  neq?: never
 } | {
+  eq?: never
   neq: V
 }
 
-export interface TagEqual {
-  tag: EqualOperator<string>
+type AllNever = {
+  not?: never
+  and?: never
+  or?: never
+  tag?: never
+  kind?: never
 }
-export const isTagEqual = (operator: WhereOperator): operator is TagEqual => {
+
+export type TagEqual<Tag> = Omit<AllNever, 'tag'> & {
+  tag: EqualOperator<Tag>
+}
+export const isTagEqual = <Tag>(operator: WhereOperator<Tag, any>): operator is TagEqual<Tag> => {
   return 'tag' in operator
 }
 
-export interface KindEqual {
-  kind: EqualOperator<string>
+export type KindEqual<Kind> = Omit<AllNever, 'kind'> & {
+  kind: EqualOperator<Kind>
 }
-export const isKindEqual = (operator: WhereOperator): operator is KindEqual => {
+export const isKindEqual = <Kind>(operator: WhereOperator<any, Kind>): operator is KindEqual<Kind> => {
   return 'kind' in operator
 }
 
-export interface NotOperator<T> {
-  not: T
+export type NotOperator<Tag, Kind> = Omit<AllNever, 'not'> & {
+  not: WhereOperator<Tag, Kind>
 }
-export const isNotOperator = (operator: WhereOperator): operator is NotOperator<WhereOperator> => {
+export const isNotOperator = <Tag, Kind>(operator: WhereOperator<Tag, Kind>): operator is NotOperator<Tag, Kind> => {
   return 'not' in operator
 }
 
-export interface AndOperator<T> {
-  and: NonEmptyArray<T>
+export type AndOperator<Tag, Kind> = Omit<AllNever, 'and'> & {
+  and: NonEmptyArray<WhereOperator<Tag, Kind>>
 }
-export const isAndOperator = (operator: WhereOperator): operator is AndOperator<WhereOperator> => {
+export const isAndOperator = <Tag, Kind>(operator: WhereOperator<Tag, Kind>): operator is AndOperator<Tag, Kind> => {
   return 'and' in operator
 }
 
-export interface OrOperator<T> {
-  or: NonEmptyArray<T>
+export type OrOperator<Tag, Kind> = Omit<AllNever, 'or'> & {
+  or: NonEmptyArray<WhereOperator<Tag, Kind>>
 }
-export const isOrOperator = (operator: WhereOperator): operator is OrOperator<WhereOperator> => {
+export const isOrOperator = <Tag, Kind>(operator: WhereOperator<Tag, Kind>): operator is OrOperator<Tag, Kind> => {
   return 'or' in operator
 }
 
-export type WhereOperator =
-  | TagEqual
-  | KindEqual
-  | NotOperator<WhereOperator>
-  | AndOperator<WhereOperator>
-  | OrOperator<WhereOperator>
-// type Ops<T> = UnionToIntersection<Op<T>>
-// type Op1<T> = RequireExactlyOne<T>
-
-// export type Operator1<T> = T extends Op<T> ? Op1<Ops<T>> : never
-// export type Operator = Operator1<any>
-
-// type L = keyof UnionToIntersection<Op<any>>
+export type WhereOperator<Tag, Kind> =
+  | TagEqual<Tag>
+  | KindEqual<Kind>
+  | NotOperator<Tag, Kind>
+  | AndOperator<Tag, Kind>
+  | OrOperator<Tag, Kind>
 
 type Filterable<
   FTag extends string = string,
@@ -70,7 +73,7 @@ type OperatorPredicate<V extends Filterable> = (value: V) => boolean
 export function whereOperatorAsPredicate<
   FTag extends string = string,
   FKind extends string = string
->(operator: WhereOperator): OperatorPredicate<Filterable<FTag, FKind>> {
+>(operator: WhereOperator<FTag, FKind>): OperatorPredicate<Filterable<FTag, FKind>> {
   switch (true) {
     case isTagEqual(operator): {
       if ('eq' in operator.tag) {

package/src/types/view-changes.ts

@@ -1,9 +1,9 @@
-import type { NonEmptyArray, XYPoint } from './_common'
+import type { NonEmptyArray } from './_common'
 import type { BorderStyle, ElementShape, Fqn } from './element'
 import type { ThemeColor } from './theme'
-import type { EdgeId, ViewManualLayout } from './view'
+import type { AutoLayoutDirection, ViewManualLayout } from './view'
 
-export namespace ViewChanges {
+export namespace ViewChange {
   export interface ChangeElementStyle {
     op: 'change-element-style'
     style: {
@@ -19,5 +19,10 @@ export namespace ViewChanges {
     op: 'save-manual-layout'
     layout: ViewManualLayout
   }
+
+  export interface ChangeAutoLayout {
+    op: 'change-autolayout'
+    layout: AutoLayoutDirection
+  }
 }
-export type ViewChangeOp = ViewChanges.ChangeElementStyle | ViewChanges.SaveManualLayout
+export type ViewChange = ViewChange.ChangeElementStyle | ViewChange.SaveManualLayout | ViewChange.ChangeAutoLayout

package/src/types/view.ts

@@ -3,7 +3,7 @@ import type { IconUrl, NonEmptyArray, Point, XYPoint } from './_common'
 import type { ElementKind, ElementShape, ElementStyle, Fqn, Tag } from './element'
 import type { ElementExpression, ElementPredicateExpression, Expression } from './expression'
 import type { Opaque } from './opaque'
-import type { RelationID, RelationshipArrowType, RelationshipLineType } from './relation'
+import type { RelationID, RelationshipArrowType, RelationshipKind, RelationshipLineType } from './relation'
 import type { ThemeColor } from './theme'
 
 // Full-qualified-name
@@ -196,10 +196,12 @@ export interface ComputedEdge {
   description?: string
   technology?: string
   relations: RelationID[]
+  kind?: RelationshipKind
   color?: ThemeColor
   line?: RelationshipLineType
   head?: RelationshipArrowType
   tail?: RelationshipArrowType
+  tags?: NonEmptyArray<Tag>
   /**
    * If this edge is derived from custom relationship predicate
    */