@likec4/core 1.38.0 → 1.39.0

package/dist/shared/core.DoM6aM9N.mjs

@@ -0,0 +1,7 @@
+import { isNonNullish } from 'remeda';
+
+function isIterable(something) {
+  return isNonNullish(something) && typeof something === "object" && Symbol.iterator in something;
+}
+
+export { isIterable as i };

package/dist/shared/{core.DsznOb9G.mjs → core.DozSPE83.mjs}

@@ -1,33 +1,16 @@
-import { u as u$1 } from './core.DbRvwARP.mjs';
-import { p } from './core.Y3j3s-oq.mjs';
-import { m as m$2 } from './core.ByrmCl9I.mjs';
-import { i as i$2 } from './core.CpwrZi3D.mjs';
-import { g as hierarchyLevel, n as nameFromFqn, i as isAncestor, d as commonAncestor, l as sortNaturalByFqn, m as sortParentsFirst, p as parentFqn, b as ancestorsFqn, C, a as compareNaturalHierarchically, c as compareNatural } from './core.DQj9iv_y.mjs';
+import { unique, isTruthy, isEmpty, hasAtLeast, values, last, entries, pipe, map, sort, split, sortBy, prop } from 'remeda';
+import { o as hierarchyLevel, n as nameFromFqn, i as isAncestor, g as commonAncestor, s as sortNaturalByFqn, f as sortParentsFirst, p as parentFqn, a as ancestorsFqn, k as compareNaturalHierarchically, j as compareNatural } from './core.DgttqsJc.mjs';
 import { g as getOrCreate } from './core.DcS-0zys.mjs';
-import { i as i$1, n as n$3, e as DeploymentNodeModel, c as DeployedInstanceModel, N as NestedElementOfDeployedInstanceModel, g as DeploymentRelationModel } from './core.DyzAZvbX.mjs';
-import { D as DefaultMap } from './core.yaRvRnMW.mjs';
+import { e as DeploymentNodeModel, c as DeployedInstanceModel, g as DeploymentRelationModel, N as NestedElementOfDeployedInstanceModel } from './core.CsbOakly.mjs';
+import { D as DefaultMap } from './core.BuoXfSMj.mjs';
 import { i as invariant, a as nonNullable } from './core.D4npX2q8.mjs';
-import { F as FqnRef, b as isDeploymentNode, a as _type, _ as _stage, i as isOnStage, w as whereOperatorAsPredicate } from './core.DK6I-Nr7.mjs';
-import { m as memoizeProp } from './core.B0oEIXqd.mjs';
-import { i as ifilter } from './core.BH9nN-_I.mjs';
-import { c as splitGlobalFqn, g as extractStep, e as isStepEdgeId, i as isGroupElementKind, b as isGlobalFqn, a as GlobalFqn } from './core.BL_xjl90.mjs';
-import { n as n$2 } from './core.CnIyafWn.mjs';
-import { a as DefaultElementShape, D as DefaultThemeColor, R as RichText, b as DefaultShapeSize, g as DefaultRelationshipColor, e as DefaultLineStyle } from './core.H8NbNp2X.mjs';
-import { a as ihead, i as ifind } from './core.DsMrjY2q.mjs';
-
-function r(...t){return u$1(Object.values,t)}
-
-var T={asc:(r,n)=>r>n,desc:(r,n)=>r<n};function s(r,n){let[e,...o]=n;if(!m$1(e)){let t=u(...o);return r(e,t)}let a=u(e,...o);return t=>r(t,a)}function u(r,n,...e){let o=typeof r=="function"?r:r[0],a=typeof r=="function"?"asc":r[1],{[a]:t}=T,i=n===void 0?void 0:u(n,...e);return (y,c)=>{let p=o(y),l=o(c);return t(p,l)?1:t(l,p)?-1:i?.(y,c)??0}}function m$1(r){if(d(r))return  true;if(typeof r!="object"||!Array.isArray(r))return  false;let[n,e,...o]=r;return d(n)&&typeof e=="string"&&e in T&&o.length===0}var d=r=>typeof r=="function"&&r.length===1;
-
-function i(t,e,n){return typeof e=="number"||e===void 0?r=>r.split(t,e):t.split(e,n)}
-
-function m(...r){return u$1(o,r)}function o(r,t){let e=[...r];return e.sort(t),e}
-
-function a$1(...r){return s(n$1,r)}var n$1=(r,t)=>[...r].sort(t);
-
-function a(...e){return u$1(n,e)}var n=e=>e.at(-1);
-
-function t(...r){return u$1(Object.entries,r)}
+import { FqnRef } from '../types/fqnRef.mjs';
+import { b as isDeploymentNode, a as _type, _ as _stage, i as isOnStage, w as whereOperatorAsPredicate } from './core.yHe79zEl.mjs';
+import { m as memoizeProp } from './core.CUw_2J9j.mjs';
+import { i as ifilter } from './core.CCD1ID81.mjs';
+import { c as splitGlobalFqn, g as extractStep, e as isStepEdgeId, i as isGroupElementKind, b as isGlobalFqn, a as GlobalFqn } from './core.Be1n9a0i.mjs';
+import { a as DefaultElementShape, D as DefaultThemeColor, R as RichText, b as DefaultShapeSize, g as DefaultRelationshipColor, e as DefaultLineStyle } from './core.BqVo8LrH.mjs';
+import { a as ihead, i as ifind } from './core.GTgsmXS_.mjs';
 
 class ElementModel {
   constructor($model, $element) {
@@ -75,7 +58,7 @@ class ElementModel {
    */
   get tags() {
     return memoizeProp(this, Symbol.for("tags"), () => {
-      return i$1([
+      return unique([
         ...this.$element.tags ?? [],
         ...this.$model.specification.elements[this.$element.kind]?.tags ?? []
       ]);
@@ -233,13 +216,13 @@ class ElementModel {
    * @returns true if the element is deployed
    */
   isDeployed() {
-    return n$2(ihead(this.deployments()));
+    return isTruthy(ihead(this.deployments()));
   }
   deployments() {
     return this.$model.deployment.instancesOf(this);
   }
   hasMetadata() {
-    return !!this.$element.metadata && !n$3(this.$element.metadata);
+    return !!this.$element.metadata && !isEmpty(this.$element.metadata);
   }
   getMetadata(field) {
     if (field) {
@@ -263,7 +246,7 @@ const splitViewTitle = (title) => {
   invariant(!title.includes("\n"), "View title cannot contain newlines");
   if (title.includes(VIEW_FOLDERS_SEPARATOR)) {
     const segments = title.split(VIEW_FOLDERS_SEPARATOR).map((s) => s.trim()).filter((s) => s.length > 0);
-    if (i$2(segments, 1)) {
+    if (hasAtLeast(segments, 1)) {
       return segments;
     }
     return [""];
@@ -275,7 +258,7 @@ const normalizeViewPath = (title) => {
 };
 const getViewFolderPath = (title) => {
   const segments = splitViewTitle(title);
-  if (!i$2(segments, 2)) {
+  if (!hasAtLeast(segments, 2)) {
     return null;
   }
   return segments.slice(0, -1).join(VIEW_FOLDERS_SEPARATOR);
@@ -291,7 +274,7 @@ class LikeC4DeploymentModel {
   constructor($model) {
     this.$model = $model;
     const $deployments = this.$deployments = $model.$data.deployments;
-    const elements = r($deployments.elements);
+    const elements = values($deployments.elements);
     for (const element of sortParentsFirst(elements)) {
       const el = this.addElement(element);
       for (const tag of el.tags) {
@@ -301,7 +284,7 @@ class LikeC4DeploymentModel {
         this.#instancesOf.get(el.element.id).add(el);
       }
     }
-    for (const relation of r($deployments.relations)) {
+    for (const relation of values($deployments.relations)) {
       const el = this.addRelation(relation);
       for (const tag of el.tags) {
         this.#allTags.get(tag).add(el);
@@ -614,13 +597,13 @@ class RelationshipModel {
     return `${this.source.id} -> ${this.target.id}`;
   }
   get title() {
-    if (!n$2(this.$relationship.title)) {
+    if (!isTruthy(this.$relationship.title)) {
       return null;
     }
     return this.$relationship.title;
   }
   get technology() {
-    if (!n$2(this.$relationship.technology)) {
+    if (!isTruthy(this.$relationship.technology)) {
       return null;
     }
     return this.$relationship.technology;
@@ -664,7 +647,7 @@ class RelationshipModel {
     return true;
   }
   hasMetadata() {
-    return !!this.$relationship.metadata && !n$3(this.$relationship.metadata);
+    return !!this.$relationship.metadata && !isEmpty(this.$relationship.metadata);
   }
   getMetadata(field) {
     if (field) {
@@ -886,13 +869,13 @@ class NodeModel {
    * Check if this node references to logical model element.
    */
   hasElement() {
-    return n$2(this.#node.modelRef);
+    return isTruthy(this.#node.modelRef);
   }
   /**
    * Check if this node references to deployment element (Node or Instance).
    */
   hasDeployment() {
-    return n$2(this.#node.deploymentRef);
+    return isTruthy(this.#node.deploymentRef);
   }
   /**
    * Check if this node references to deployed instance
@@ -1147,7 +1130,7 @@ class LikeC4ViewModel {
     return this.$view[_type] === "element";
   }
   isScopedElementView() {
-    return this.$view[_type] === "element" && n$2(this.$view.viewOf);
+    return this.$view[_type] === "element" && isTruthy(this.$view.viewOf);
   }
   isDeploymentView() {
     return this.$view[_type] === "deployment";
@@ -1189,7 +1172,7 @@ class LikeC4ViewsFolder {
     this.$model = $model;
     this.path = path.join("/");
     this.isRoot = this.path === "";
-    this.title = a(path);
+    this.title = last(path);
     if (this.isRoot) {
       this.parentPath = void 0;
     } else {
@@ -1244,7 +1227,7 @@ class LikeC4ViewsFolder {
    */
   get parent() {
     invariant(!this.isRoot, "Root view folder has no parent");
-    if (n$3(this.parentPath)) {
+    if (isEmpty(this.parentPath)) {
       return null;
     }
     return this.$model.viewFolder(this.parentPath);
@@ -1365,13 +1348,13 @@ class LikeC4Model {
   $data;
   constructor($data) {
     this.$data = $data;
-    for (const [, element] of t($data.elements)) {
+    for (const [, element] of entries($data.elements)) {
       const el = this.addElement(element);
       for (const tag of el.tags) {
         this._allTags.get(tag).add(el);
       }
     }
-    for (const [projectId, elements] of t($data.imports ?? {})) {
+    for (const [projectId, elements] of entries($data.imports ?? {})) {
       for (const element of sortParentsFirst(elements)) {
         const el = this.addImportedElement(projectId, element);
         for (const tag of el.tags) {
@@ -1379,7 +1362,7 @@ class LikeC4Model {
         }
       }
     }
-    for (const relation of r($data.relations)) {
+    for (const relation of values($data.relations)) {
       const el = this.addRelation(relation);
       for (const tag of el.tags) {
         this._allTags.get(tag).add(el);
@@ -1388,21 +1371,21 @@ class LikeC4Model {
     this.deployment = new LikeC4DeploymentModel(this);
     if (isOnStage($data, "computed") || isOnStage($data, "layouted")) {
       const compare = compareNaturalHierarchically(VIEW_FOLDERS_SEPARATOR);
-      const views = C(
-        r($data.views),
-        m$2((view) => ({
+      const views = pipe(
+        values($data.views),
+        map((view) => ({
           view,
           path: normalizeViewPath(view.title ?? view.id),
           folderPath: view.title && getViewFolderPath(view.title) || ""
         })),
         // Sort hierarchically by groups, but keep same order within groups
-        m((a, b) => compare(a.folderPath, b.folderPath))
+        sort((a, b) => compare(a.folderPath, b.folderPath))
       );
       const getOrCreateFolder = (path) => {
         let folder = this._viewFolders.get(path);
         if (!folder) {
-          const segments = i(path, VIEW_FOLDERS_SEPARATOR);
-          invariant(i$2(segments, 1), `View group path "${path}" must have at least one element`);
+          const segments = split(path, VIEW_FOLDERS_SEPARATOR);
+          invariant(hasAtLeast(segments, 1), `View group path "${path}" must have at least one element`);
           let defaultView;
           if (path === "") {
             defaultView = views.find((view) => view.view.id === "index");
@@ -1419,7 +1402,7 @@ class LikeC4Model {
         if (this._viewFolders.has(folderPath)) {
           continue;
         }
-        i(folderPath, VIEW_FOLDERS_SEPARATOR).reduce((parent, segment) => {
+        split(folderPath, VIEW_FOLDERS_SEPARATOR).reduce((parent, segment) => {
           const path = [...parent, segment];
           const folder = getOrCreateFolder(path.join(VIEW_FOLDERS_SEPARATOR));
           this._viewFolderItems.get(parent.join(VIEW_FOLDERS_SEPARATOR)).add(folder);
@@ -1749,22 +1732,22 @@ class LikeC4Model {
    * Use {@link specification.tags} to get all defined tags
    */
   get tags() {
-    return memoizeProp(this, "tags", () => m([...this._allTags.keys()], compareNatural));
+    return memoizeProp(this, "tags", () => sort([...this._allTags.keys()], compareNatural));
   }
   /**
    * Returns all tags used in the model, sorted by usage count (descending).
    */
   get tagsSortedByUsage() {
-    return memoizeProp(this, "tagsSortedByUsage", () => C(
+    return memoizeProp(this, "tagsSortedByUsage", () => pipe(
       [...this._allTags.entries()],
-      m$2(([tag, tagged]) => ({
+      map(([tag, tagged]) => ({
         tag,
         count: tagged.size,
         tagged
       })),
-      m((a, b) => compareNatural(a.tag, b.tag)),
-      a$1(
-        [p("count"), "desc"]
+      sort((a, b) => compareNatural(a.tag, b.tag)),
+      sortBy(
+        [prop("count"), "desc"]
       )
     ));
   }
@@ -1980,4 +1963,4 @@ function isEdgeModel(edge) {
   return edge instanceof EdgeModel;
 }
 
-export { ElementModel as E, LikeC4Model as L, NodeModel as N, RelationshipModel as R, VIEW_FOLDERS_SEPARATOR as V, LikeC4DeploymentModel as a, EdgeModel as b, LikeC4ViewModel as c, LikeC4ViewsFolder as d, extractViewTitleFromPath as e, isDeployedInstanceModel as f, getViewFolderPath as g, isDeploymentElementModel as h, isDeploymentNodeModel as i, isNestedElementOfDeployedInstanceModel as j, isDeploymentRelationModel as k, isRelationModel as l, isElementModel as m, normalizeViewPath as n, isLikeC4ViewModel as o, isNodeModel as p, isEdgeModel as q, r, a$1 as s, t, a as u };
+export { ElementModel as E, LikeC4Model as L, NodeModel as N, RelationshipModel as R, VIEW_FOLDERS_SEPARATOR as V, LikeC4DeploymentModel as a, EdgeModel as b, LikeC4ViewModel as c, LikeC4ViewsFolder as d, extractViewTitleFromPath as e, isDeployedInstanceModel as f, getViewFolderPath as g, isDeploymentElementModel as h, isDeploymentNodeModel as i, isNestedElementOfDeployedInstanceModel as j, isDeploymentRelationModel as k, isRelationModel as l, isElementModel as m, normalizeViewPath as n, isLikeC4ViewModel as o, isNodeModel as p, isEdgeModel as q };

package/dist/shared/{core.DsMrjY2q.mjs → core.GTgsmXS_.mjs}

@@ -1,9 +1,9 @@
-import { t } from './core.BH9nN-_I.mjs';
+import { isFunction } from 'remeda';
 import { i as invariant } from './core.D4npX2q8.mjs';
 
 function ifind(arg1, arg2) {
   const pred = arg2 ?? arg1;
-  invariant(t(pred));
+  invariant(isFunction(pred));
   function _find(iter) {
     for (const value of iter) {
       if (pred(value)) {

package/dist/shared/core.ILwny7BV.mjs

@@ -0,0 +1,38 @@
+import { i as invariant } from './core.D4npX2q8.mjs';
+import { isDefined, isFunction } from 'remeda';
+
+function ifirst(arg1, arg2) {
+  const count = arg2 ?? arg1;
+  invariant(typeof count === "number" && count >= 0, "Count must be a non-negative number");
+  function* _first(iter) {
+    let taken = 0;
+    for (const value of iter) {
+      if (taken >= count) {
+        break;
+      }
+      yield value;
+      taken++;
+    }
+    return;
+  }
+  if (arg2 === void 0) {
+    return (iterable) => _first(iterable);
+  }
+  return _first(arg1);
+}
+
+function ireduce(arg1, arg2, arg3) {
+  const reducer = isDefined(arg3) ? arg2 : arg1;
+  const initialValue = arg3 ?? arg2;
+  invariant(isFunction(reducer));
+  function _reduce(iter) {
+    let acc = initialValue;
+    for (const value of iter) {
+      acc = reducer(acc, value);
+    }
+    return acc;
+  }
+  return isDefined(arg3) ? _reduce(arg1) : _reduce;
+}
+
+export { ireduce as a, ifirst as i };

package/dist/shared/core.PHwHXzkG.d.mts

@@ -0,0 +1,213 @@
+import { N as NonEmptyArray } from './core.DuSLYTG6.mjs';
+
+/**
+ * Mnemonist DefaultWeakMap Typings
+ * ================================
+ */
+declare class DefaultWeakMap<K extends object, V> {
+
+  // Constructor
+  constructor(factory: (key: K) => V);
+
+  // Methods
+  clear(): void;
+  set(key: K, value: V): this;
+  delete(key: K): boolean;
+  has(key: K): boolean;
+  get(key: K): V;
+  peek(key: K): V | undefined;
+  inspect(): any;
+}
+
+/**
+ * Mnemonist LinkedList Typings
+ * =============================
+ */
+declare class LinkedList<T> implements Iterable<T> {
+
+  // Members
+  size: number;
+
+  // Constructor
+  constructor();
+
+  // Methods
+  clear(): void;
+  first(): T | undefined;
+  last(): T | undefined;
+  peek(): T | undefined;
+  push(value: T): number;
+  shift(): T | undefined;
+  unshift(value: T): number;
+  forEach(callback: (value: T, index: number, list: this) => void, scope?: any): void;
+  toArray(): Array<T>;
+  values(): IterableIterator<T>;
+  entries(): IterableIterator<[number, T]>;
+  [Symbol.iterator](): IterableIterator<T>;
+  toString(): string;
+  toJSON(): Array<T>;
+  inspect(): any;
+
+  // Statics
+  static from<I>(iterable: Iterable<I> | {[key: string]: I}): LinkedList<I>;
+}
+
+/**
+ * Mnemonist Queue Typings
+ * ========================
+ */
+declare class Queue<T> implements Iterable<T> {
+
+  // Members
+  size: number;
+
+  // Constructor
+  constructor();
+
+  // Methods
+  clear(): void;
+  enqueue(item: T): number;
+  dequeue(): T | undefined;
+  peek(): T | undefined;
+  forEach(callback: (item: T, index: number, queue: this) => void, scope?: any): void;
+  toArray(): Array<T>;
+  values(): IterableIterator<T>;
+  entries(): IterableIterator<[number, T]>;
+  [Symbol.iterator](): IterableIterator<T>;
+  toString(): string;
+  toJSON(): Array<T>;
+  inspect(): any;
+
+  // Statics
+  static from<I>(iterable: Iterable<I> | {[key: string]: I}): Queue<I>;
+  static of<I>(...items: Array<I>): Queue<I>;
+}
+
+interface MultiMapConstructor {
+  new <K, V>(container: SetConstructor): MultiMap<K, V, Set<V>>;
+  new <K, V>(container?: ArrayConstructor): MultiMap<K, V, V[]>;
+
+  from<K, V>(
+    iterable: Iterable<[K, V]> | {[key: string]: V},
+    Container: SetConstructor
+  ): MultiMap<K, V, Set<V>>;
+  from<K, V>(
+    iterable: Iterable<[K, V]> | {[key: string]: V},
+    Container?: ArrayConstructor
+  ): MultiMap<K, V, V[]>;
+}
+/**
+ * Mnemonist MultiMap Typings
+ * ===========================
+ */
+
+interface MultiMap<K, V, C extends V[] | Set<V> = V[]> extends Iterable<[K, V]> {
+
+  // Members
+  dimension: number;
+  size: number;
+
+  // Methods
+  clear(): void;
+  set(key: K, value: V): this;
+  delete(key: K): boolean;
+  remove(key: K, value: V): boolean;
+  has(key: K): boolean;
+  get(key: K): C | undefined;
+  multiplicity(key: K): number;
+  forEach(callback: (value: V, key: K, map: this) => void, scope?: any): void;
+  forEachAssociation(callback: (value: C, key: K, map: this) => void, scope?: any): void;
+  keys(): IterableIterator<K>;
+  values(): IterableIterator<V>;
+  entries(): IterableIterator<[K, V]>;
+  containers(): IterableIterator<C>;
+  associations(): IterableIterator<[K, C]>;
+  [Symbol.iterator](): IterableIterator<[K, V]>;
+  inspect(): any;
+  toJSON(): any;
+}
+
+declare const MultiMap: MultiMapConstructor;
+
+/**
+ * Mnemonist BiMap Typings
+ * ========================
+ */
+declare class InverseMap<K, V> implements Iterable<[K, V]> {
+
+  // Members
+  size: number;
+  inverse: BiMap<V, K>;
+
+  // Constructor
+  constructor(original: BiMap<K, V>);
+
+  // Methods
+  clear(): void;
+  set(key: K, value: V): this;
+  delete(key: K): boolean;
+  has(key: K): boolean;
+  get(key: K): V | undefined;
+  forEach(callback: (value: V, key: K, map: this) => void, scope?: any): void;
+  keys(): IterableIterator<K>;
+  values(): IterableIterator<V>;
+  entries(): IterableIterator<[K, V]>;
+  [Symbol.iterator](): IterableIterator<[K, V]>;
+  inspect(): any;
+}
+
+declare class BiMap<K, V> implements Iterable<[K, V]> {
+
+  // Members
+  size: number;
+  inverse: InverseMap<V, K>;
+
+  // Constructor
+  constructor();
+
+  // Methods
+  clear(): void;
+  set(key: K, value: V): this;
+  delete(key: K): boolean;
+  has(key: K): boolean;
+  get(key: K): V | undefined;
+  forEach(callback: (value: V, key: K, map: this) => void, scope?: any): void;
+  keys(): IterableIterator<K>;
+  values(): IterableIterator<V>;
+  entries(): IterableIterator<[K, V]>;
+  [Symbol.iterator](): IterableIterator<[K, V]>;
+  inspect(): any;
+
+  // Statics
+  static from<I, J>(iterable: Iterable<[I, J]> | {[key: string]: J}): BiMap<I, J>;
+}
+
+declare function nonNullable<T>(value: T, message?: string | (() => string)): NonNullable<T>;
+declare function invariant(condition: any, message?: string): asserts condition;
+declare function nonexhaustive(value: never): never;
+
+declare function isString(value: unknown): value is string;
+declare function isNonEmptyArray<A>(arr: ArrayLike<A> | undefined): arr is NonEmptyArray<A>;
+
+/**
+ * Saves the value returned by fn() in a hidden property tag of obj object, so next time memoizeProp() is called,
+ * that value will be returned, and fn won't be called.
+ *
+ * @example
+ * ```ts
+ * class Model {
+ *   // using same Symbol
+ *   get computed1() {
+ *     return memoizeProp(this, Symbol.for('computed1'), () => doOnce())
+ *   }
+ *   // using string
+ *   get computed2() {
+ *     return memoizeProp(this, 'computed2', () => doOnce())
+ *   }
+ *
+ * }
+ * ```
+ */
+declare function memoizeProp<Tag extends symbol | string, Res>(obj: object, tag: Tag, fn: () => Res): Res;
+
+export { BiMap as B, DefaultWeakMap as D, LinkedList as L, MultiMap as M, Queue as Q, isNonEmptyArray as a, isString as b, nonNullable as c, invariant as i, memoizeProp as m, nonexhaustive as n };

package/dist/shared/core.T-eLZTW_.mjs

@@ -0,0 +1,59 @@
+import { isTruthy, isArray } from 'remeda';
+import { e as isStepEdgeId } from './core.Be1n9a0i.mjs';
+
+function isViewRulePredicate(rule) {
+  return "include" in rule || "exclude" in rule;
+}
+function isViewRuleStyle(rule) {
+  return "targets" in rule && "style" in rule;
+}
+function isComputedView(view) {
+  return view._stage === "computed";
+}
+function isDiagramView(view) {
+  return view._stage === "layouted";
+}
+function isElementView(view) {
+  return view._type === "element";
+}
+function isScopedElementView(view) {
+  return isElementView(view) && isTruthy(view.viewOf);
+}
+function isExtendsElementView(view) {
+  return isElementView(view) && isTruthy(view.extends);
+}
+function isDeploymentView(view) {
+  return view._type === "deployment";
+}
+function isDynamicView(view) {
+  return view._type === "dynamic";
+}
+
+function isViewRuleGlobalStyle(rule) {
+  return "styleId" in rule;
+}
+function isViewRuleGlobalPredicateRef(rule) {
+  return "predicateId" in rule;
+}
+function isAutoLayoutDirection(autoLayout) {
+  return autoLayout === "TB" || autoLayout === "BT" || autoLayout === "LR" || autoLayout === "RL";
+}
+function isViewRuleAutoLayout(rule) {
+  return "direction" in rule;
+}
+
+function getParallelStepsPrefix(id) {
+  if (isStepEdgeId(id) && id.includes(".")) {
+    return id.slice(0, id.indexOf(".") + 1);
+  }
+  return null;
+}
+function isDynamicViewParallelSteps(step) {
+  return "__parallel" in step && isArray(step.__parallel);
+}
+
+function isViewRuleGroup(rule) {
+  return "title" in rule && "groupRules" in rule && Array.isArray(rule.groupRules);
+}
+
+export { isViewRuleStyle as a, isComputedView as b, isDiagramView as c, isElementView as d, isScopedElementView as e, isExtendsElementView as f, isDeploymentView as g, isDynamicView as h, isViewRulePredicate as i, isViewRuleGlobalStyle as j, isViewRuleGlobalPredicateRef as k, isAutoLayoutDirection as l, isViewRuleAutoLayout as m, getParallelStepsPrefix as n, isDynamicViewParallelSteps as o, isViewRuleGroup as p };