@likec4/core 1.47.0 → 1.49.0

package/dist/types/expression-model.d.mts

@@ -1,190 +0,0 @@
-import { W as WhereOperator, C as Color, f as RelationshipLineType, g as RelationshipArrowType, P as PredicateSelector, h as ElementShape, B as BorderStyle, e as ShapeSize } from '../shared/core.DC5IAaDT.mjs';
-import { A as Any, S as StrictViewId, E as ElementKind, T as Tag } from '../shared/core.D00YbOhQ.mjs';
-import { E as ExclusiveUnion } from '../shared/core.DB0Ue5Wx.mjs';
-import { FqnRef } from './fqnRef.mjs';
-import { M as MarkdownOrString, I as Icon } from '../shared/core.C_3y3eqV.mjs';
-import 'type-fest';
-
-type AnyAux = Any;
-declare namespace ModelFqnExpr {
-    type Wildcard = {
-        wildcard: true;
-    };
-    function isWildcard<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelFqnExpr.Wildcard;
-    interface Ref<M extends AnyAux> {
-        ref: FqnRef.ModelRef<M>;
-        selector?: PredicateSelector;
-    }
-    function isModelRef<A extends AnyAux>(ref: ModelExpression<A>): ref is ModelFqnExpr.Ref<A>;
-    interface ElementKindExpr<A extends AnyAux = AnyAux> {
-        elementKind: ElementKind<A>;
-        isEqual: boolean;
-    }
-    function isElementKindExpr<A extends AnyAux>(expr: ModelExpression<A>): expr is ElementKindExpr<A>;
-    interface ElementTagExpr<A extends AnyAux> {
-        elementTag: Tag<A>;
-        isEqual: boolean;
-    }
-    function isElementTagExpr<A extends AnyAux>(expr: ModelExpression<A>): expr is ElementTagExpr<A>;
-    type NonWildcard<A extends AnyAux = AnyAux> = ExclusiveUnion<{
-        Ref: Ref<A>;
-        ElementKind: ElementKindExpr<A>;
-        ElementTag: ElementTagExpr<A>;
-    }>;
-    interface Where<A extends AnyAux = AnyAux> {
-        where: {
-            expr: ExclusiveUnion<{
-                Wildcard: Wildcard;
-                Ref: Ref<A>;
-                ElementKind: ElementKindExpr<A>;
-                ElementTag: ElementTagExpr<A>;
-            }>;
-            condition: WhereOperator<A>;
-        };
-    }
-    function isWhere<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelFqnExpr.Where<A>;
-    interface Custom<A extends AnyAux = AnyAux> {
-        custom: {
-            expr: OrWhere<A>;
-            title?: string;
-            description?: MarkdownOrString;
-            technology?: string;
-            notation?: string;
-            shape?: ElementShape;
-            color?: Color;
-            icon?: Icon;
-            border?: BorderStyle;
-            opacity?: number;
-            navigateTo?: StrictViewId<A>;
-            multiple?: boolean;
-            size?: ShapeSize;
-            padding?: ShapeSize;
-            textSize?: ShapeSize;
-        };
-    }
-    function isCustom<A extends AnyAux>(expr: ModelExpression<A>): expr is Custom<A>;
-    function is<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelFqnExpr<A>;
-    type OrWhere<A extends AnyAux = AnyAux> = ExclusiveUnion<{
-        Wildcard: ModelFqnExpr.Wildcard;
-        Ref: ModelFqnExpr.Ref<A>;
-        ElementKind: ElementKindExpr<A>;
-        ElementTag: ElementTagExpr<A>;
-        Where: ModelFqnExpr.Where<A>;
-    }>;
-    type Any<A extends AnyAux = AnyAux> = ExclusiveUnion<{
-        Wildcard: Wildcard;
-        Ref: Ref<A>;
-        ElementKind: ElementKindExpr<A>;
-        ElementTag: ElementTagExpr<A>;
-        Where: Where<A>;
-        Custom: Custom<A>;
-    }>;
-    function unwrap<A extends AnyAux>(expr: ModelFqnExpr.Any<A>): Wildcard | Ref<A> | ElementKindExpr<A> | ElementTagExpr<A>;
-}
-type ModelFqnExpr<A extends AnyAux = AnyAux> = ExclusiveUnion<{
-    Wildcard: ModelFqnExpr.Wildcard;
-    Ref: ModelFqnExpr.Ref<A>;
-    ElementKind: ModelFqnExpr.ElementKindExpr<A>;
-    ElementTag: ModelFqnExpr.ElementTagExpr<A>;
-}>;
-declare namespace ModelRelationExpr {
-    type Endpoint<A extends AnyAux = AnyAux> = ModelFqnExpr.Where<A>['where']['expr'];
-    interface Direct<A extends AnyAux = AnyAux> {
-        source: Endpoint<A>;
-        target: Endpoint<A>;
-        isBidirectional?: boolean;
-    }
-    function isDirect<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelRelationExpr.Direct<A>;
-    interface Incoming<A extends AnyAux = AnyAux> {
-        incoming: Endpoint<A>;
-    }
-    function isIncoming<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelRelationExpr.Incoming<A>;
-    interface Outgoing<A extends AnyAux = AnyAux> {
-        outgoing: Endpoint<A>;
-    }
-    function isOutgoing<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelRelationExpr.Outgoing<A>;
-    interface InOut<A extends AnyAux = AnyAux> {
-        inout: Endpoint<A>;
-    }
-    function isInOut<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelRelationExpr.InOut<A>;
-    interface Where<A extends AnyAux = AnyAux> {
-        where: {
-            expr: ExclusiveUnion<{
-                Direct: ModelRelationExpr.Direct<A>;
-                Incoming: ModelRelationExpr.Incoming<A>;
-                Outgoing: ModelRelationExpr.Outgoing<A>;
-                InOut: ModelRelationExpr.InOut<A>;
-            }>;
-            condition: WhereOperator<A>;
-        };
-    }
-    function isWhere<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelRelationExpr.Where<A>;
-    interface Custom<A extends AnyAux = AnyAux> {
-        customRelation: {
-            expr: OrWhere<A>;
-            title?: string;
-            description?: string;
-            technology?: string;
-            notation?: string;
-            navigateTo?: StrictViewId<A>;
-            notes?: string;
-            color?: Color;
-            line?: RelationshipLineType;
-            head?: RelationshipArrowType;
-            tail?: RelationshipArrowType;
-        };
-    }
-    function isCustom<A extends AnyAux>(expr: ModelExpression<A>): expr is Custom<A>;
-    function is<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelRelationExpr<A>;
-    type OrWhere<A extends AnyAux = AnyAux> = ExclusiveUnion<{
-        Direct: Direct<A>;
-        Incoming: Incoming<A>;
-        Outgoing: Outgoing<A>;
-        InOut: InOut<A>;
-        Where: Where<A>;
-    }>;
-    type Any<A extends AnyAux = AnyAux> = ExclusiveUnion<{
-        Direct: Direct<A>;
-        Incoming: Incoming<A>;
-        Outgoing: Outgoing<A>;
-        InOut: InOut<A>;
-        Where: Where<A>;
-        Custom: Custom<A>;
-    }>;
-    function unwrap<A extends AnyAux>(expr: ModelRelationExpr.Any<A>): Direct<A> | Incoming<A> | Outgoing<A> | InOut<A>;
-}
-type ModelRelationExpr<A extends AnyAux = AnyAux> = ExclusiveUnion<{
-    Direct: ModelRelationExpr.Direct<A>;
-    Incoming: ModelRelationExpr.Incoming<A>;
-    Outgoing: ModelRelationExpr.Outgoing<A>;
-    InOut: ModelRelationExpr.InOut<A>;
-}>;
-/**
- * Represents a version 2 expression which can be one of several types.
- *
- * @template D - The type for the deployment FQN, defaults to `Fqn`.
- * @template M - The type for the model FQN, defaults to `Fqn`.
- */
-type ModelExpression<A extends AnyAux = AnyAux> = ExclusiveUnion<{
-    Wildcard: ModelFqnExpr.Wildcard;
-    Ref: ModelFqnExpr.Ref<A>;
-    ElementKind: ModelFqnExpr.ElementKindExpr<A>;
-    ElementTag: ModelFqnExpr.ElementTagExpr<A>;
-    Custom: ModelFqnExpr.Custom<A>;
-    Direct: ModelRelationExpr.Direct<A>;
-    Incoming: ModelRelationExpr.Incoming<A>;
-    Outgoing: ModelRelationExpr.Outgoing<A>;
-    InOut: ModelRelationExpr.InOut<A>;
-    Where: ModelExpression.Where<A>;
-    CustomRelation: ModelRelationExpr.Custom<A>;
-}>;
-declare namespace ModelExpression {
-    type Where<A extends AnyAux = AnyAux> = ModelFqnExpr.Where<A> | ModelRelationExpr.Where<A>;
-    function isWhere<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelExpression.Where<A>;
-    function isRelationWhere<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelRelationExpr.Where<A>;
-    function isFqnExprWhere<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelFqnExpr.Where<A>;
-    function isFqnExpr<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelFqnExpr.Any<A>;
-    function isRelationExpr<A extends AnyAux>(expr: ModelExpression<A>): expr is ModelRelationExpr.Any<A>;
-}
-
-export { ModelExpression, ModelFqnExpr, ModelRelationExpr };

package/dist/types/expression-model.mjs

@@ -1,109 +0,0 @@
-import { FqnRef } from './fqnRef.mjs';
-
-var ModelFqnExpr;
-((ModelFqnExpr2) => {
-  function isWildcard(expr) {
-    return "wildcard" in expr && expr.wildcard === true;
-  }
-  ModelFqnExpr2.isWildcard = isWildcard;
-  function isModelRef(ref) {
-    return "ref" in ref && FqnRef.isModelRef(ref.ref);
-  }
-  ModelFqnExpr2.isModelRef = isModelRef;
-  function isElementKindExpr(expr) {
-    return "elementKind" in expr && "isEqual" in expr;
-  }
-  ModelFqnExpr2.isElementKindExpr = isElementKindExpr;
-  function isElementTagExpr(expr) {
-    return "elementTag" in expr && "isEqual" in expr;
-  }
-  ModelFqnExpr2.isElementTagExpr = isElementTagExpr;
-  function isWhere(expr) {
-    return "where" in expr && is(expr.where.expr);
-  }
-  ModelFqnExpr2.isWhere = isWhere;
-  function isCustom(expr) {
-    return "custom" in expr && (is(expr.custom.expr) || isWhere(expr.custom.expr));
-  }
-  ModelFqnExpr2.isCustom = isCustom;
-  function is(expr) {
-    return isWildcard(expr) || isModelRef(expr) || isElementKindExpr(expr) || isElementTagExpr(expr);
-  }
-  ModelFqnExpr2.is = is;
-  function unwrap(expr) {
-    if (isCustom(expr)) {
-      expr = expr.custom.expr;
-    }
-    if (isWhere(expr)) {
-      expr = expr.where.expr;
-    }
-    return expr;
-  }
-  ModelFqnExpr2.unwrap = unwrap;
-})(ModelFqnExpr || (ModelFqnExpr = {}));
-var ModelRelationExpr;
-((ModelRelationExpr2) => {
-  function isDirect(expr) {
-    return "source" in expr && "target" in expr;
-  }
-  ModelRelationExpr2.isDirect = isDirect;
-  function isIncoming(expr) {
-    return "incoming" in expr;
-  }
-  ModelRelationExpr2.isIncoming = isIncoming;
-  function isOutgoing(expr) {
-    return "outgoing" in expr;
-  }
-  ModelRelationExpr2.isOutgoing = isOutgoing;
-  function isInOut(expr) {
-    return "inout" in expr;
-  }
-  ModelRelationExpr2.isInOut = isInOut;
-  function isWhere(expr) {
-    return "where" in expr && (isDirect(expr.where.expr) || isIncoming(expr.where.expr) || isOutgoing(expr.where.expr) || isInOut(expr.where.expr));
-  }
-  ModelRelationExpr2.isWhere = isWhere;
-  function isCustom(expr) {
-    return "customRelation" in expr;
-  }
-  ModelRelationExpr2.isCustom = isCustom;
-  function is(expr) {
-    return isDirect(expr) || isIncoming(expr) || isOutgoing(expr) || isInOut(expr);
-  }
-  ModelRelationExpr2.is = is;
-  function unwrap(expr) {
-    if (isCustom(expr)) {
-      expr = expr.customRelation.expr;
-    }
-    if (isWhere(expr)) {
-      expr = expr.where.expr;
-    }
-    return expr;
-  }
-  ModelRelationExpr2.unwrap = unwrap;
-})(ModelRelationExpr || (ModelRelationExpr = {}));
-var ModelExpression;
-((ModelExpression2) => {
-  function isWhere(expr) {
-    return "where" in expr;
-  }
-  ModelExpression2.isWhere = isWhere;
-  function isRelationWhere(expr) {
-    return ModelRelationExpr.isWhere(expr);
-  }
-  ModelExpression2.isRelationWhere = isRelationWhere;
-  function isFqnExprWhere(expr) {
-    return ModelFqnExpr.isWhere(expr);
-  }
-  ModelExpression2.isFqnExprWhere = isFqnExprWhere;
-  function isFqnExpr(expr) {
-    return ModelFqnExpr.is(expr) || ModelFqnExpr.isWhere(expr) || ModelFqnExpr.isCustom(expr);
-  }
-  ModelExpression2.isFqnExpr = isFqnExpr;
-  function isRelationExpr(expr) {
-    return ModelRelationExpr.is(expr) || ModelRelationExpr.isWhere(expr) || ModelRelationExpr.isCustom(expr);
-  }
-  ModelExpression2.isRelationExpr = isRelationExpr;
-})(ModelExpression || (ModelExpression = {}));
-
-export { ModelExpression, ModelFqnExpr, ModelRelationExpr };

package/dist/types/expression.d.mts

@@ -1,6 +0,0 @@
-export { j as Expression, F as FqnExpr, P as PredicateSelector, i as RelationExpr } from '../shared/core.DC5IAaDT.mjs';
-import '../shared/core.D00YbOhQ.mjs';
-import '../shared/core.DB0Ue5Wx.mjs';
-import './fqnRef.mjs';
-import '../shared/core.C_3y3eqV.mjs';
-import 'type-fest';

package/dist/types/expression.mjs

@@ -1,113 +0,0 @@
-import { FqnRef } from './fqnRef.mjs';
-
-var FqnExpr;
-((FqnExpr2) => {
-  function isWildcard(expr) {
-    return "wildcard" in expr && expr.wildcard === true;
-  }
-  FqnExpr2.isWildcard = isWildcard;
-  function isModelRef(ref) {
-    return "ref" in ref && FqnRef.isModelRef(ref.ref);
-  }
-  FqnExpr2.isModelRef = isModelRef;
-  function isDeploymentRef(expr) {
-    return "ref" in expr && FqnRef.isDeploymentRef(expr.ref);
-  }
-  FqnExpr2.isDeploymentRef = isDeploymentRef;
-  function isElementKindExpr(expr) {
-    return "elementKind" in expr && "isEqual" in expr;
-  }
-  FqnExpr2.isElementKindExpr = isElementKindExpr;
-  function isElementTagExpr(expr) {
-    return "elementTag" in expr && "isEqual" in expr;
-  }
-  FqnExpr2.isElementTagExpr = isElementTagExpr;
-  function isWhere(expr) {
-    return "where" in expr && is(expr.where.expr);
-  }
-  FqnExpr2.isWhere = isWhere;
-  function isCustom(expr) {
-    return "custom" in expr && (is(expr.custom.expr) || isWhere(expr.custom.expr));
-  }
-  FqnExpr2.isCustom = isCustom;
-  function is(expr) {
-    return isWildcard(expr) || isModelRef(expr) || isDeploymentRef(expr) || isElementKindExpr(expr) || isElementTagExpr(expr);
-  }
-  FqnExpr2.is = is;
-  function unwrap(expr) {
-    if (isCustom(expr)) {
-      expr = expr.custom.expr;
-    }
-    if (isWhere(expr)) {
-      expr = expr.where.expr;
-    }
-    return expr;
-  }
-  FqnExpr2.unwrap = unwrap;
-})(FqnExpr || (FqnExpr = {}));
-var RelationExpr;
-((RelationExpr2) => {
-  function isDirect(expr) {
-    return "source" in expr && "target" in expr;
-  }
-  RelationExpr2.isDirect = isDirect;
-  function isIncoming(expr) {
-    return "incoming" in expr;
-  }
-  RelationExpr2.isIncoming = isIncoming;
-  function isOutgoing(expr) {
-    return "outgoing" in expr;
-  }
-  RelationExpr2.isOutgoing = isOutgoing;
-  function isInOut(expr) {
-    return "inout" in expr;
-  }
-  RelationExpr2.isInOut = isInOut;
-  function isWhere(expr) {
-    return "where" in expr && (isDirect(expr.where.expr) || isIncoming(expr.where.expr) || isOutgoing(expr.where.expr) || isInOut(expr.where.expr));
-  }
-  RelationExpr2.isWhere = isWhere;
-  function isCustom(expr) {
-    return "customRelation" in expr;
-  }
-  RelationExpr2.isCustom = isCustom;
-  function is(expr) {
-    return isDirect(expr) || isIncoming(expr) || isOutgoing(expr) || isInOut(expr);
-  }
-  RelationExpr2.is = is;
-  function unwrap(expr) {
-    if (isCustom(expr)) {
-      expr = expr.customRelation.expr;
-    }
-    if (isWhere(expr)) {
-      expr = expr.where.expr;
-    }
-    return expr;
-  }
-  RelationExpr2.unwrap = unwrap;
-})(RelationExpr || (RelationExpr = {}));
-var Expression;
-((Expression2) => {
-  function isWhere(expr) {
-    return "where" in expr;
-  }
-  Expression2.isWhere = isWhere;
-  function isRelationWhere(expr) {
-    return RelationExpr.isWhere(expr);
-  }
-  Expression2.isRelationWhere = isRelationWhere;
-  function isFqnExprWhere(expr) {
-    return FqnExpr.isWhere(expr);
-  }
-  Expression2.isFqnExprWhere = isFqnExprWhere;
-  function isFqnExpr(expr) {
-    return FqnExpr.is(expr) || FqnExpr.isWhere(expr) || FqnExpr.isCustom(expr);
-  }
-  Expression2.isFqnExpr = isFqnExpr;
-  function isRelation(expr) {
-    return RelationExpr.is(expr) || RelationExpr.isWhere(expr) || RelationExpr.isCustom(expr);
-  }
-  Expression2.isRelation = isRelation;
-})(Expression || (Expression = {}));
-
-export { Expression, FqnExpr, RelationExpr };

package/dist/types/fqnRef.d.mts

@@ -1,60 +0,0 @@
-import { A as Any, a as ElementId, P as ProjectId, F as Fqn, D as DeploymentId } from '../shared/core.D00YbOhQ.mjs';
-import { E as ExclusiveUnion } from '../shared/core.DB0Ue5Wx.mjs';
-import 'type-fest';
-import '../shared/core.C_3y3eqV.mjs';
-
-type AnyAux = Any;
-declare namespace FqnRef {
-    /**
-     * Reference to logical model element
-     */
-    interface ElementRef<A extends AnyAux = AnyAux> {
-        project?: never;
-        model: ElementId<A>;
-    }
-    function isElementRef<A extends AnyAux>(ref: FqnRef<A>): ref is ElementRef<A>;
-    /**
-     * Reference to imported logical model element
-     */
-    interface ImportRef<A extends AnyAux = AnyAux> {
-        project: ProjectId<A>;
-        model: ElementId<A>;
-    }
-    function isImportRef<A extends AnyAux>(ref: FqnRef<A>): ref is ImportRef<A>;
-    function flatten<A extends AnyAux>(ref: FqnRef<A>): Fqn<A>;
-    type ModelRef<A extends AnyAux = AnyAux> = ImportRef<A> | ElementRef<A>;
-    function isModelRef<A extends AnyAux>(ref: FqnRef<A>): ref is ModelRef<A>;
-    /**
-     * Represents a reference to an instance within a deployment.
-     *
-     * @template D - The type representing the deployment fqn. Defaults to `Fqn`.
-     * @template M - The type representing the model fqn. Defaults to `Fqn`.
-     *
-     * @property {D} deployment - TThe fully qualified name (FQN) of the deployed instance.
-     * @property {M} element - The element reference within the deployment.
-     */
-    interface InsideInstanceRef<A extends AnyAux = AnyAux> {
-        deployment: DeploymentId<A>;
-        element: ElementId<A>;
-    }
-    function isInsideInstanceRef<A extends AnyAux>(ref: FqnRef<A>): ref is InsideInstanceRef<A>;
-    /**
-     * Represents a reference to a deployment element.
-     *
-     * @template F - The type of the fully qualified name (FQN) of the deployment element. Defaults to `Fqn`.
-     * @property {F} deployment - The fully qualified name (FQN) of the deployment element.
-     */
-    interface DeploymentElementRef<A extends AnyAux> {
-        deployment: DeploymentId<A>;
-        element?: never;
-    }
-    function isDeploymentElementRef<A extends AnyAux>(ref: FqnRef<A>): ref is DeploymentElementRef<A>;
-    type DeploymentRef<A extends AnyAux> = DeploymentElementRef<A> | InsideInstanceRef<A>;
-    function isDeploymentRef<A extends AnyAux>(ref: FqnRef<A>): ref is DeploymentRef<A>;
-}
-type FqnRef<A extends AnyAux = AnyAux> = ExclusiveUnion<{
-    DeploymentRef: FqnRef.DeploymentRef<A>;
-    ModelRef: FqnRef.ModelRef<A>;
-}>;
-
-export { FqnRef };

package/dist/types/fqnRef.mjs

@@ -1,45 +0,0 @@
-import { e } from '../shared/core.CqAJJpK_.mjs';
-import { a as GlobalFqn } from '../shared/core.D0WZutNd.mjs';
-
-var FqnRef;
-((FqnRef2) => {
-  function isElementRef(ref) {
-    return "model" in ref && !("project" in ref);
-  }
-  FqnRef2.isElementRef = isElementRef;
-  function isImportRef(ref) {
-    return "project" in ref && "model" in ref;
-  }
-  FqnRef2.isImportRef = isImportRef;
-  function flatten(ref) {
-    if (e(ref)) {
-      throw new Error(`Expected FqnRef, got: "${ref}"`);
-    }
-    if (isImportRef(ref)) {
-      return GlobalFqn(ref.project, ref.model);
-    }
-    if (isElementRef(ref)) {
-      return ref.model;
-    }
-    throw new Error("Expected FqnRef.ModelRef or FqnRef.ImportRef");
-  }
-  FqnRef2.flatten = flatten;
-  function isModelRef(ref) {
-    return isElementRef(ref) || isImportRef(ref);
-  }
-  FqnRef2.isModelRef = isModelRef;
-  function isInsideInstanceRef(ref) {
-    return "deployment" in ref && "element" in ref;
-  }
-  FqnRef2.isInsideInstanceRef = isInsideInstanceRef;
-  function isDeploymentElementRef(ref) {
-    return "deployment" in ref && !("element" in ref);
-  }
-  FqnRef2.isDeploymentElementRef = isDeploymentElementRef;
-  function isDeploymentRef(ref) {
-    return isDeploymentElementRef(ref) || isInsideInstanceRef(ref);
-  }
-  FqnRef2.isDeploymentRef = isDeploymentRef;
-})(FqnRef || (FqnRef = {}));
-
-export { FqnRef };

package/dist/types/scalar.d.mts

@@ -1,2 +0,0 @@
-import 'type-fest';
-export { A as AnyFqn, B as BuiltInIcon, D as DeploymentFqn, b as DeploymentKind, k as EdgeId, E as ElementKind, F as Fqn, e as GlobalFqn, G as GroupElementKind, I as Icon, a as IconUrl, M as MarkdownOrString, j as NodeId, N as NoneIcon, P as ProjectId, d as RelationId, R as RelationKind, c as RelationshipKind, l as StepEdgeId, S as StepEdgeIdLiteral, n as StepEdgeKind, T as Tag, V as ViewId, p as extractStep, f as flattenMarkdownOrString, g as isGlobalFqn, i as isGroupElementKind, o as isStepEdgeId, h as splitGlobalFqn, m as stepEdgeId } from '../shared/core.C_3y3eqV.mjs';

package/dist/types/scalar.mjs

@@ -1,4 +0,0 @@
-import '../shared/core.CqAJJpK_.mjs';
-import '../shared/core.BKlholso.mjs';
-import '../shared/core.D4npX2q8.mjs';
-export { D as DeploymentFqn, E as EdgeId, F as Fqn, a as GlobalFqn, G as GroupElementKind, d as NodeId, N as NoneIcon, P as ProjectId, R as RelationId, S as StepEdgeKind, V as ViewId, h as extractStep, f as flattenMarkdownOrString, b as isGlobalFqn, i as isGroupElementKind, g as isStepEdgeId, c as splitGlobalFqn, e as stepEdgeId } from '../shared/core.D0WZutNd.mjs';

package/dist/utils/iterable/index.d.mts

@@ -1,132 +0,0 @@
-export { i as isIterable } from '../../shared/core.DXhDWKFZ.mjs';
-import { c as IteratorLike } from '../../shared/core.DB0Ue5Wx.mjs';
-import 'type-fest';
-
-/**
- * Filters an iterable based on a predicate.
- * Composabel first version of `ifilter`.
- * @signature
- *    ifilter(predicate)(data)
- */
-declare function ifilter<T, S extends T>(predicate: (v: T) => v is S): (iterable: Iterable<T>) => IteratorLike<S>;
-declare function ifilter<T>(predicate: (v: T) => boolean): (iterable: Iterable<T>) => IteratorLike<T>;
-/**
- * Filters an iterable based on a predicate.
- * Data first version of `ifilter`.
- * @signature
- *    ifilter(data, predicate)
- * @example
- *    ifilter(new Set([1, 2, 3]), x => x % 2 === 1) // => Iterable<[1, 3]>
- */
-declare function ifilter<T, S extends T>(iterable: Iterable<T>, predicate: (v: T) => v is S): IteratorLike<S>;
-declare function ifilter<T>(iterable: Iterable<T>, predicate: (v: T) => boolean): IteratorLike<T>;
-
-/**
- * Finds the first element in the iterable that satisfies the predicate.
- * Composable first version of `find`.
- * @signature
- *   ifind(predicate)(data)
- */
-declare function ifind<T, S extends T>(predicate: (item: T) => item is S): (iterable: Iterable<T>) => S | undefined;
-declare function ifind<T>(predicate: (item: T) => boolean): (iterable: Iterable<T>) => T | undefined;
-/**
- * Finds the first element in the iterable that satisfies the predicate.
- * Data first version of `find`.
- * @signature
- *  ifind(data, predicate)
- */
-declare function ifind<T, S extends T>(iterable: Iterable<T>, predicate: (item: T) => item is S): S | undefined;
-declare function ifind<T>(iterable: Iterable<T>, predicate: (item: T) => boolean): T | undefined;
-
-/**
- * Takes the first N elements from an iterable.
- * Composable first version of `ifirst`.
- * @signature
- *   ifirst(count)(data)
- */
-declare function ifirst<T>(count: number): (iterable: Iterable<T>) => IteratorLike<T>;
-/**
- * Takes the first N elements from an iterable.
- * Data first version of `ifirst`.
- * @signature
- *   ifirst(data, count)
- * @example
- *   ifirst([1, 2, 3, 4, 5], 3) // => Iterable<[1, 2, 3]>
- */
-declare function ifirst<T>(iterable: Iterable<T>, count: number): IteratorLike<T>;
-
-declare function iflat(): <T>(iterable: Iterable<IteratorLike<T>>) => IteratorLike<T>;
-declare function iflat<T>(iterable: Iterable<IteratorLike<T>>): IteratorLike<T>;
-
-type FlatMapFunction<T, S> = (item: T) => Iterable<S>;
-/**
- * Maps an iterable using a mapper function and flattens the result by one level.
- * Composable first version of `iflatMap`.
- * @signature
- *   iflatMap(mapper)(data)
- */
-declare function iflatMap<T, S>(mapper: FlatMapFunction<T, S>): (iterable: Iterable<T>) => IteratorLike<S>;
-/**
- * Maps an iterable using a mapper function and flattens the result by one level.
- * Data first version of `iflatMap`.
- * @signature
- *   iflatMap(data, mapper)
- */
-declare function iflatMap<T, S>(iterable: Iterable<T>, mapper: FlatMapFunction<T, S>): IteratorLike<S>;
-
-declare function ihead<T>(): (iterable: Iterable<T>) => T | undefined;
-/**
- * Finds the first element in the iterable that satisfies the predicate.
- * Data first version of `find`.
- * @signature
- *  ifind(data, predicate)
- */
-declare function ihead<T>(iterable: Iterable<T>): T | undefined;
-
-type MapFunction<T, S> = (item: T) => S;
-/**
- * Maps an iterable using a mapper function.
- * Composable first version of `imap`.
- * @signature
- *   imap(mapper)(data)
- */
-declare function imap<T, S>(mapper: MapFunction<T, S>): (iterable: Iterable<T>) => IteratorLike<S>;
-/**
- * Maps an iterable using a mapper function.
- * Data first version of `imap`.
- * @signature
- *   imap(data, mapper)
- */
-declare function imap<T, S>(iterable: Iterable<T>, mapper: MapFunction<T, S>): IteratorLike<S>;
-
-declare function ireduce<T, R>(reducer: (acc: R, item: T) => R, initialValue: R): (iterable: Iterable<T>) => R;
-declare function ireduce<T, R>(iterable: Iterable<T>, reducer: (acc: R, item: T) => R, initialValue: R): R;
-
-/**
- * Checks if at least one element in the iterable satisfies the predicate.
- * Composable first version of `some`.
- * @signature
- *   isome(predicate)(data)
- */
-declare function isome<T>(predicate: (item: T) => boolean): (iterable: Iterable<T>) => boolean;
-/**
- * Checks if at least one element in the iterable satisfies the predicate.
- * Data first version of `some`.
- * @signature
- *  isome(data, predicate)
- */
-declare function isome<T>(iterable: Iterable<T>, predicate: (item: T) => boolean): boolean;
-
-declare function toArray(): <T>(iterable: Iterable<T> | ArrayLike<T>) => T[];
-declare function toArray<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
-declare function toSet(): <T>(iterable: Iterable<T>) => Set<T>;
-declare function toSet<T>(iterable: Iterable<T>): Set<T>;
-
-/**
- * Returns an iterable that yields only unique values.
- * It uses a Set to keep track of the values.
- */
-declare function iunique(): <T>(iterable: Iterable<T>) => IteratorLike<T>;
-declare function iunique<T>(iterable: Iterable<T>): IteratorLike<T>;
-
-export { ifilter, ifind, ifirst, iflat, iflatMap, ihead, imap, ireduce, isome, iunique, toArray, toSet };