@likec4/core 1.18.0 → 1.19.1

package/dist/utils/index.js

@@ -0,0 +1,347 @@
+import { T as requireIterator, S as requireForeach, R as getDefaultExportFromCjs, b as t, W as n, f as commonAncestor, h as compareFqnHierarchically } from '../shared/object_hash.CE_oF3I3.js';
+export { D as DefaultMap, e as ancestorsFqn, c as commonHead, g as compareByFqnHierarchically, d as compareNatural, H as difference, I as equalsSet, v as getOrCreate, i as hasAtLeast, j as hierarchyDistance, k as hierarchyLevel, y as ifilter, z as iflat, A as imap, J as intersection, o as isAncestor, q as isDescendantOf, B as isIterable, w as isNonEmptyArray, a as isSameHierarchy, x as isString, C as isome, E as iunique, n as nameFromFqn, N as objectHash, p as parentFqn, s as sortByFqnHierarchically, r as sortNaturalByFqn, u as sortParentsFirst, M as stringHash, K as symmetricDifference, F as toArray, G as toSet, L as union } from '../shared/object_hash.CE_oF3I3.js';
+import { i as invariant } from '../shared/chunk-RAAYCPUM.M-JWF7SS.js';
+
+function o(r,n){let e=Math.ceil(r),t=Math.floor(n);if(t<e)throw new RangeError(`randomInteger: The range [${r.toString()},${n.toString()}] contains no integer`);return Math.floor(Math.random()*(t-e+1)+e)}
+
+/**
+ * Mnemonist Linked List
+ * ======================
+ *
+ * Singly linked list implementation. Uses raw JavaScript objects as nodes
+ * as benchmarks proved it was the fastest thing to do.
+ */
+
+var linkedList$1;
+var hasRequiredLinkedList;
+
+function requireLinkedList () {
+	if (hasRequiredLinkedList) return linkedList$1;
+	hasRequiredLinkedList = 1;
+	var Iterator = requireIterator(),
+	    forEach = requireForeach();
+
+	/**
+	 * Linked List.
+	 *
+	 * @constructor
+	 */
+	function LinkedList() {
+	  this.clear();
+	}
+
+	/**
+	 * Method used to clear the list.
+	 *
+	 * @return {undefined}
+	 */
+	LinkedList.prototype.clear = function() {
+
+	  // Properties
+	  this.head = null;
+	  this.tail = null;
+	  this.size = 0;
+	};
+
+	/**
+	 * Method used to get the first item of the list.
+	 *
+	 * @return {any}
+	 */
+	LinkedList.prototype.first = function() {
+	  return this.head ? this.head.item : undefined;
+	};
+	LinkedList.prototype.peek = LinkedList.prototype.first;
+
+	/**
+	 * Method used to get the last item of the list.
+	 *
+	 * @return {any}
+	 */
+	LinkedList.prototype.last = function() {
+	  return this.tail ? this.tail.item : undefined;
+	};
+
+	/**
+	 * Method used to add an item at the end of the list.
+	 *
+	 * @param  {any}    item - The item to add.
+	 * @return {number}
+	 */
+	LinkedList.prototype.push = function(item) {
+	  var node = {item: item, next: null};
+
+	  if (!this.head) {
+	    this.head = node;
+	    this.tail = node;
+	  }
+	  else {
+	    this.tail.next = node;
+	    this.tail = node;
+	  }
+
+	  this.size++;
+
+	  return this.size;
+	};
+
+	/**
+	 * Method used to add an item at the beginning of the list.
+	 *
+	 * @param  {any}    item - The item to add.
+	 * @return {number}
+	 */
+	LinkedList.prototype.unshift = function(item) {
+	  var node = {item: item, next: null};
+
+	  if (!this.head) {
+	    this.head = node;
+	    this.tail = node;
+	  }
+	  else {
+	    if (!this.head.next)
+	      this.tail = this.head;
+	    node.next = this.head;
+	    this.head = node;
+	  }
+
+	  this.size++;
+
+	  return this.size;
+	};
+
+	/**
+	 * Method used to retrieve & remove the first item of the list.
+	 *
+	 * @return {any}
+	 */
+	LinkedList.prototype.shift = function() {
+	  if (!this.size)
+	    return undefined;
+
+	  var node = this.head;
+
+	  this.head = node.next;
+	  this.size--;
+
+	  return node.item;
+	};
+
+	/**
+	 * Method used to iterate over the list.
+	 *
+	 * @param  {function}  callback - Function to call for each item.
+	 * @param  {object}    scope    - Optional scope.
+	 * @return {undefined}
+	 */
+	LinkedList.prototype.forEach = function(callback, scope) {
+	  if (!this.size)
+	    return;
+
+	  scope = arguments.length > 1 ? scope : this;
+
+	  var n = this.head,
+	      i = 0;
+
+	  while (n) {
+	    callback.call(scope, n.item, i, this);
+	    n = n.next;
+	    i++;
+	  }
+	};
+
+	/**
+	 * Method used to convert the list into an array.
+	 *
+	 * @return {array}
+	 */
+	LinkedList.prototype.toArray = function() {
+	  if (!this.size)
+	    return [];
+
+	  var array = new Array(this.size);
+
+	  for (var i = 0, l = this.size, n = this.head; i < l; i++) {
+	    array[i] = n.item;
+	    n = n.next;
+	  }
+
+	  return array;
+	};
+
+	/**
+	 * Method used to create an iterator over a list's values.
+	 *
+	 * @return {Iterator}
+	 */
+	LinkedList.prototype.values = function() {
+	  var n = this.head;
+
+	  return new Iterator(function() {
+	    if (!n)
+	      return {
+	        done: true
+	      };
+
+	    var value = n.item;
+	    n = n.next;
+
+	    return {
+	      value: value,
+	      done: false
+	    };
+	  });
+	};
+
+	/**
+	 * Method used to create an iterator over a list's entries.
+	 *
+	 * @return {Iterator}
+	 */
+	LinkedList.prototype.entries = function() {
+	  var n = this.head,
+	      i = 0;
+
+	  return new Iterator(function() {
+	    if (!n)
+	      return {
+	        done: true
+	      };
+
+	    var value = n.item;
+	    n = n.next;
+	    i++;
+
+	    return {
+	      value: [i - 1, value],
+	      done: false
+	    };
+	  });
+	};
+
+	/**
+	 * Attaching the #.values method to Symbol.iterator if possible.
+	 */
+	if (typeof Symbol !== 'undefined')
+	  LinkedList.prototype[Symbol.iterator] = LinkedList.prototype.values;
+
+	/**
+	 * Convenience known methods.
+	 */
+	LinkedList.prototype.toString = function() {
+	  return this.toArray().join(',');
+	};
+
+	LinkedList.prototype.toJSON = function() {
+	  return this.toArray();
+	};
+
+	LinkedList.prototype.inspect = function() {
+	  var array = this.toArray();
+
+	  // Trick so that node displays the name of the constructor
+	  Object.defineProperty(array, 'constructor', {
+	    value: LinkedList,
+	    enumerable: false
+	  });
+
+	  return array;
+	};
+
+	if (typeof Symbol !== 'undefined')
+	  LinkedList.prototype[Symbol.for('nodejs.util.inspect.custom')] = LinkedList.prototype.inspect;
+
+	/**
+	 * Static @.from function taking an arbitrary iterable & converting it into
+	 * a list.
+	 *
+	 * @param  {Iterable} iterable   - Target iterable.
+	 * @return {LinkedList}
+	 */
+	LinkedList.from = function(iterable) {
+	  var list = new LinkedList();
+
+	  forEach(iterable, function(value) {
+	    list.push(value);
+	  });
+
+	  return list;
+	};
+
+	/**
+	 * Exporting.
+	 */
+	linkedList$1 = LinkedList;
+	return linkedList$1;
+}
+
+var linkedListExports = requireLinkedList();
+const linkedList = /*@__PURE__*/getDefaultExportFromCjs(linkedListExports);
+
+function ifind(arg1, arg2) {
+  const pred = arg2 ?? arg1;
+  invariant(t(pred));
+  function _find(iter) {
+    for (const value of iter) {
+      if (pred(value)) {
+        return value;
+      }
+    }
+    return;
+  }
+  if (!arg2) {
+    return _find;
+  }
+  return _find(arg1);
+}
+
+function ireduce(arg1, arg2, arg3) {
+  const reducer = n(arg3) ? arg2 : arg1;
+  const initialValue = arg3 ?? arg2;
+  invariant(t(reducer));
+  function _reduce(iter) {
+    let acc = initialValue;
+    for (const value of iter) {
+      acc = reducer(acc, value);
+    }
+    return acc;
+  }
+  return n(arg3) ? _reduce(arg1) : _reduce;
+}
+
+const DELAY = "LIKEC4_DELAY";
+function delay(...args) {
+  let ms = 100;
+  if (args.length === 2) {
+    ms = o(args[0], args[1]);
+  } else if (args.length === 1) {
+    ms = args[0];
+  }
+  return new Promise((resolve) => {
+    setTimeout(() => {
+      resolve(DELAY);
+    }, ms ?? 100);
+  });
+}
+
+const compareRelations = (a, b) => {
+  const parentA = commonAncestor(a.source, a.target);
+  const parentB = commonAncestor(b.source, b.target);
+  if (parentA && !parentB) {
+    return 1;
+  }
+  if (!parentA && parentB) {
+    return -1;
+  }
+  const compareParents = parentA && parentB ? compareFqnHierarchically(parentA, parentB) : 0;
+  if (compareParents !== 0) {
+    return compareParents;
+  }
+  const compareSource = compareFqnHierarchically(a.source, b.source);
+  if (compareSource !== 0) {
+    return compareSource;
+  }
+  return compareFqnHierarchically(a.target, b.target);
+};
+
+export { linkedList as LinkedList, commonAncestor, compareFqnHierarchically, compareRelations, delay, ifind, ireduce };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@likec4/core",
-  "version": "1.18.0",
+  "version": "1.19.1",
   "license": "MIT",
   "homepage": "https://likec4.dev",
   "author": "Denis Davydkov <denis@davydkov.com>",
@@ -29,65 +29,79 @@
   "sideEffects": false,
   "exports": {
     ".": {
-      "types": "./dist/index.d.mts",
-      "default": "./dist/index.mjs"
+      "sources": "./src/index.ts",
+      "default": {
+        "types": "./dist/index.d.ts",
+        "import": "./dist/index.js",
+        "default": "./dist/index.js"
+      }
+    },
+    "./builder": {
+      "sources": "./src/builder/index.ts",
+      "default": {
+        "types": "./dist/builder/index.d.ts",
+        "import": "./dist/builder/index.js",
+        "default": "./dist/builder/index.js"
+      }
     },
     "./compute-view": {
-      "types": "./dist/compute-view/index.d.mts",
-      "default": "./dist/compute-view/index.mjs"
+      "sources": "./src/compute-view/index.ts",
+      "default": {
+        "types": "./dist/compute-view/index.d.ts",
+        "import": "./dist/compute-view/index.js",
+        "default": "./dist/compute-view/index.js"
+      }
     },
     "./model": {
-      "types": "./dist/model/index.d.mts",
-      "default": "./dist/model/index.mjs"
+      "sources": "./src/model/index.ts",
+      "default": {
+        "types": "./dist/model/index.d.ts",
+        "import": "./dist/model/index.js",
+        "default": "./dist/model/index.js"
+      }
+    },
+    "./utils": {
+      "sources": "./src/utils/index.ts",
+      "default": {
+        "types": "./dist/utils/index.d.ts",
+        "import": "./dist/utils/index.js",
+        "default": "./dist/utils/index.js"
+      }
     },
     "./types": {
-      "types": "./dist/types/index.d.mts",
-      "default": "./dist/types/index.mjs"
+      "sources": "./src/types/index.ts",
+      "default": {
+        "types": "./dist/types/index.d.ts",
+        "import": "./dist/types/index.js",
+        "default": "./dist/types/index.js"
+      }
     }
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
-    "access": "public",
-    "exports": {
-      ".": {
-        "types": "./dist/index.d.mts",
-        "default": "./dist/index.mjs"
-      },
-      "./compute-view": {
-        "types": "./dist/compute-view/index.d.mts",
-        "default": "./dist/compute-view/index.mjs"
-      },
-      "./model": {
-        "types": "./dist/model/index.d.mts",
-        "default": "./dist/model/index.mjs"
-      },
-      "./types": {
-        "types": "./dist/types/index.d.mts",
-        "default": "./dist/types/index.mjs"
-      }
-    }
+    "access": "public"
   },
   "dependencies": {
-    "defu": "^6.1.4",
     "type-fest": "4.28.1"
   },
   "devDependencies": {
-    "@dagrejs/dagre": "^1.1.4",
-    "@likec4/tsconfig": "1.18.0",
-    "@mantine/colors-generator": "7.15.1",
+    "@likec4/tsconfig": "1.19.1",
+    "@mantine/colors-generator": "7.15.2",
     "@types/natural-compare-lite": "^1.4.2",
     "@types/object-hash": "^3.0.6",
     "chroma-js": "^3.1.2",
+    "defu": "^6.1.4",
     "graphology": "^0.25.4",
     "graphology-dag": "^0.4.1",
     "graphology-types": "^0.24.8",
     "mnemonist": "^0.39.8",
     "natural-compare-lite": "^1.4.0",
     "object-hash": "^3.0.0",
+    "obliterator": "^2.0.4",
     "remeda": "^2.17.4",
     "turbo": "^2.3.3",
     "typescript": "^5.7.2",
-    "unbuild": "^3.0.0-rc.11",
+    "unbuild": "^3.1.0",
     "vitest": "^2.1.8"
   },
   "packageManager": "yarn@4.5.3"

package/src/builder/Builder-style1.test-d.ts

@@ -0,0 +1,190 @@
+import { expectTypeOf, test } from 'vitest'
+import type { LikeC4Model } from '../model/LikeC4Model'
+import type { ParsedLikeC4Model } from '../types'
+import { Builder } from './Builder'
+
+test('Builder types - style 1', () => {
+  const {
+    model: {
+      model,
+      actor,
+      system,
+      component,
+      relTo,
+    },
+    deployment: {
+      deployment,
+      instanceOf,
+      env,
+      vm,
+    },
+    views: {
+      deploymentView,
+      views,
+      view,
+      viewOf,
+      $rules,
+      $include,
+    },
+    builder,
+  } = Builder.forSpecification({
+    elements: {
+      actor: {
+        style: {
+          shape: 'person',
+        },
+      },
+      system: {},
+      component: {},
+    },
+    deployments: {
+      env: {},
+      vm: {},
+    },
+    relationships: {
+      like: {},
+      dislike: {},
+    },
+    tags: ['tag1', 'tag2', 'tag1'],
+  })
+
+  const m = builder
+    .with(
+      model(
+        actor('alice'),
+        actor('bob'),
+        system('cloud').with(
+          component('backend').with(
+            component('api'),
+            component('db'),
+          ),
+          component('frontend').with(
+            relTo('cloud.backend.api'),
+          ),
+        ),
+      ),
+      deployment(
+        env('prod').with(
+          vm('vm1'),
+        ),
+        env('prod.vm2'),
+        env('dev').with(
+          vm('vm1'),
+          instanceOf('cloud.backend.api'),
+          instanceOf(
+            'wrong',
+            // @ts-expect-error
+            'non-existing',
+          ),
+          vm('vm2'),
+        ),
+      ),
+      views(
+        view(
+          'view',
+          // @ts-expect-error
+          $include('wrong'),
+        ), // rules inside
+        view(
+          'view',
+          // @ts-expect-error #tag22 is not defined
+          $include('cloud.backend', {
+            where: 'tag is #tag22',
+          }),
+        ),
+        // using with
+        view('view').with(
+          // @ts-expect-error
+          $include('wrong'),
+          // @ts-expect-error
+          $style('wrong', { color: 'red' }),
+        ),
+      ),
+      views(
+        viewOf('view-of', 'cloud.backend.api'),
+        // @ts-expect-error
+        viewOf('view-of', 'wrong'),
+        viewOf(
+          'view-of',
+          'cloud.backend.api',
+          $rules(
+            $include('* -> *'),
+            // @ts-expect-error
+            $include('wrong'),
+          ),
+        ),
+        viewOf(
+          'view-of',
+          // @ts-expect-error
+          '-cloud.backend.api',
+          'Title',
+        ),
+        viewOf(
+          'view-of',
+          // @ts-expect-error
+          '-cloud.backend.api',
+          $rules(),
+        ),
+        viewOf(
+          'view-of',
+          'cloud.backend.api',
+          { title: 'asdasd' },
+          $rules(
+            $include('* -> *'),
+            // @ts-expect-error
+            $include('wrong'),
+          ),
+        ),
+      ),
+      views(
+        deploymentView(
+          'deployment',
+          $rules(
+            // @ts-expect-error
+            $include('pr'),
+          ),
+        ),
+        deploymentView(
+          'deployment',
+          'Title',
+          $rules(
+            // @ts-expect-error
+            $include('pr'),
+          ),
+        ),
+        deploymentView('deployment').with(
+          // @ts-expect-error
+          $include('pr'),
+        ),
+      ),
+    )
+
+  expectTypeOf(m.Types.Fqn).toEqualTypeOf(
+    '' as 'alice' | 'bob' | 'cloud' | 'cloud.backend' | 'cloud.backend.api' | 'cloud.backend.db' | 'cloud.frontend',
+  )
+  expectTypeOf(m.Types.ViewId).toEqualTypeOf(
+    '' as 'view' | 'view-of' | 'deployment',
+  )
+  expectTypeOf(m.Types.DeploymentFqn).toEqualTypeOf(
+    '' as 'prod' | 'dev' | 'prod.vm1' | 'prod.vm2' | 'dev.vm1' | 'dev.vm2' | 'dev.api' | 'dev.wrong',
+  )
+
+  expectTypeOf(m.build()).toEqualTypeOf(
+    {} as ParsedLikeC4Model<
+      'actor' | 'system' | 'component',
+      'like' | 'dislike',
+      'tag1' | 'tag2',
+      'alice' | 'bob' | 'cloud' | 'cloud.backend' | 'cloud.backend.api' | 'cloud.backend.db' | 'cloud.frontend',
+      'view' | 'view-of' | 'deployment',
+      'prod' | 'dev' | 'prod.vm1' | 'prod.vm2' | 'dev.vm1' | 'dev.vm2' | 'dev.api' | 'dev.wrong'
+    >,
+  )
+
+  expectTypeOf(m.toLikeC4Model()).toEqualTypeOf(
+    {} as LikeC4Model.Computed<
+      'alice' | 'bob' | 'cloud' | 'cloud.backend' | 'cloud.backend.api' | 'cloud.backend.db' | 'cloud.frontend',
+      'prod' | 'dev' | 'prod.vm1' | 'prod.vm2' | 'dev.vm1' | 'dev.vm2' | 'dev.api' | 'dev.wrong',
+      'view' | 'view-of' | 'deployment'
+    >,
+  )
+})