@agilewallaby/c4-model 2.2.0 → 2.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agilewallaby/c4-model",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "publishConfig": {
     "access": "public"
   },
@@ -14,12 +14,14 @@
     "testcontainers": "^10.28.0"
   },
   "type": "module",
-  "main": "./src/index.js",
+  "main": "./src/index.cjs",
+  "module": "./src/index.js",
   "types": "./src/index.d.ts",
   "exports": {
     ".": {
+      "types": "./src/index.d.ts",
       "import": "./src/index.js",
-      "types": "./src/index.d.ts"
+      "require": "./src/index.cjs"
     }
   }
 }

package/src/index.cjs

@@ -0,0 +1,952 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// libs/c4-model/src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Component: () => Component,
+  Container: () => Container,
+  ContainerGroup: () => ContainerGroup,
+  ElementArchetype: () => ElementArchetype,
+  Model: () => Model,
+  ModelGroup: () => ModelGroup,
+  Person: () => Person,
+  RelationshipArchetype: () => RelationshipArchetype,
+  SoftwareSystem: () => SoftwareSystem,
+  SoftwareSystemGroup: () => SoftwareSystemGroup,
+  StructurizrDSLWriter: () => StructurizrDSLWriter,
+  View: () => View,
+  Views: () => Views,
+  buildModel: () => buildModel,
+  buildModelWithCatalog: () => buildModelWithCatalog,
+  generateDiagrams: () => generateDiagrams,
+  mergeArchetypeWithOverride: () => mergeArchetypeWithOverride
+});
+module.exports = __toCommonJS(index_exports);
+
+// libs/c4-model/src/archetype.ts
+var ElementArchetype = class {
+  constructor(name, elementKind, definition, parent) {
+    this.name = name;
+    this.elementKind = elementKind;
+    this.parent = parent;
+    this.ownDescription = definition?.description;
+    this.ownTechnology = definition?.technology;
+    this.ownTags = definition?.tags ?? [];
+    this.description = this.ownDescription ?? parent?.description;
+    this.technology = this.ownTechnology ?? parent?.technology;
+    this.tags = [...parent?.tags ?? [], ...this.ownTags];
+  }
+  ownDescription;
+  ownTechnology;
+  ownTags;
+  description;
+  technology;
+  tags;
+};
+var RelationshipArchetype = class {
+  constructor(name, definition, parent) {
+    this.name = name;
+    this.parent = parent;
+    this.ownDescription = definition?.description;
+    this.ownTechnology = definition?.technology;
+    this.ownTags = definition?.tags ?? [];
+    this.description = this.ownDescription ?? parent?.description;
+    this.technology = this.ownTechnology ?? parent?.technology;
+    this.tags = [...parent?.tags ?? [], ...this.ownTags];
+  }
+  ownDescription;
+  ownTechnology;
+  ownTags;
+  description;
+  technology;
+  tags;
+};
+function mergeArchetypeWithOverride(archetype, override) {
+  return {
+    description: override?.description ?? archetype.description,
+    technology: override?.technology ?? archetype.technology,
+    tags: [...archetype.tags, ...override?.tags ?? []]
+  };
+}
+
+// node_modules/.pnpm/change-case@5.4.4/node_modules/change-case/dist/index.js
+var SPLIT_LOWER_UPPER_RE = /([\p{Ll}\d])(\p{Lu})/gu;
+var SPLIT_UPPER_UPPER_RE = /(\p{Lu})([\p{Lu}][\p{Ll}])/gu;
+var SPLIT_SEPARATE_NUMBER_RE = /(\d)\p{Ll}|(\p{L})\d/u;
+var DEFAULT_STRIP_REGEXP = /[^\p{L}\d]+/giu;
+var SPLIT_REPLACE_VALUE = "$1\0$2";
+var DEFAULT_PREFIX_SUFFIX_CHARACTERS = "";
+function split(value) {
+  let result = value.trim();
+  result = result.replace(SPLIT_LOWER_UPPER_RE, SPLIT_REPLACE_VALUE).replace(SPLIT_UPPER_UPPER_RE, SPLIT_REPLACE_VALUE);
+  result = result.replace(DEFAULT_STRIP_REGEXP, "\0");
+  let start = 0;
+  let end = result.length;
+  while (result.charAt(start) === "\0")
+    start++;
+  if (start === end)
+    return [];
+  while (result.charAt(end - 1) === "\0")
+    end--;
+  return result.slice(start, end).split(/\0/g);
+}
+function splitSeparateNumbers(value) {
+  const words = split(value);
+  for (let i = 0; i < words.length; i++) {
+    const word = words[i];
+    const match = SPLIT_SEPARATE_NUMBER_RE.exec(word);
+    if (match) {
+      const offset = match.index + (match[1] ?? match[2]).length;
+      words.splice(i, 1, word.slice(0, offset), word.slice(offset));
+    }
+  }
+  return words;
+}
+function camelCase(input, options) {
+  const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+  const lower = lowerFactory(options?.locale);
+  const upper = upperFactory(options?.locale);
+  const transform = options?.mergeAmbiguousCharacters ? capitalCaseTransformFactory(lower, upper) : pascalCaseTransformFactory(lower, upper);
+  return prefix + words.map((word, index) => {
+    if (index === 0)
+      return lower(word);
+    return transform(word, index);
+  }).join(options?.delimiter ?? "") + suffix;
+}
+function lowerFactory(locale) {
+  return locale === false ? (input) => input.toLowerCase() : (input) => input.toLocaleLowerCase(locale);
+}
+function upperFactory(locale) {
+  return locale === false ? (input) => input.toUpperCase() : (input) => input.toLocaleUpperCase(locale);
+}
+function capitalCaseTransformFactory(lower, upper) {
+  return (word) => `${upper(word[0])}${lower(word.slice(1))}`;
+}
+function pascalCaseTransformFactory(lower, upper) {
+  return (word, index) => {
+    const char0 = word[0];
+    const initial = index > 0 && char0 >= "0" && char0 <= "9" ? "_" + char0 : upper(char0);
+    return initial + lower(word.slice(1));
+  };
+}
+function splitPrefixSuffix(input, options = {}) {
+  const splitFn = options.split ?? (options.separateNumbers ? splitSeparateNumbers : split);
+  const prefixCharacters = options.prefixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS;
+  const suffixCharacters = options.suffixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS;
+  let prefixIndex = 0;
+  let suffixIndex = input.length;
+  while (prefixIndex < input.length) {
+    const char = input.charAt(prefixIndex);
+    if (!prefixCharacters.includes(char))
+      break;
+    prefixIndex++;
+  }
+  while (suffixIndex > prefixIndex) {
+    const index = suffixIndex - 1;
+    const char = input.charAt(index);
+    if (!suffixCharacters.includes(char))
+      break;
+    suffixIndex = index;
+  }
+  return [
+    input.slice(0, prefixIndex),
+    splitFn(input.slice(prefixIndex, suffixIndex)),
+    input.slice(suffixIndex)
+  ];
+}
+
+// libs/c4-model/src/core.ts
+var Element = class {
+  constructor(name, defaultTags = [], definition, archetype, overrideDefinition) {
+    this.name = name;
+    this.description = definition?.description;
+    this.tags = (definition?.tags ?? []).concat(["Element"]).concat(defaultTags);
+    this.archetype = archetype;
+    this.overrideDefinition = overrideDefinition;
+  }
+  description;
+  tags;
+  archetype;
+  overrideDefinition;
+  _relationships = [];
+  get canonicalName() {
+    return camelCase(this.name);
+  }
+  uses(otherElement, archetypeOrDef, override) {
+    let definition;
+    let archetype;
+    if (archetypeOrDef instanceof RelationshipArchetype) {
+      archetype = archetypeOrDef;
+      definition = mergeArchetypeWithOverride(archetypeOrDef, override);
+    } else {
+      definition = archetypeOrDef;
+    }
+    const relationship = new Relationship(this, otherElement, definition, archetype, override);
+    this._relationships.push(relationship);
+  }
+  get relationships() {
+    return this._relationships;
+  }
+  getRelationshipsInHierarchy() {
+    return this._relationships.concat(this.getChildElements().flatMap((element) => element.getRelationshipsInHierarchy()));
+  }
+  getChildElementNames(path2) {
+    const result = Array.from(this.getChildElements()).flatMap((reference) => {
+      const currentPath = `${path2 ? path2 : "" + this.name}.${reference.name}`;
+      return [currentPath, ...reference.getChildElementNames(currentPath)];
+    });
+    return result;
+  }
+};
+var TechnicalElement = class extends Element {
+  technology;
+  constructor(name, defaultTags = [], definition, archetype, overrideDefinition) {
+    super(name, defaultTags, definition, archetype, overrideDefinition);
+    this.technology = definition?.technology;
+  }
+};
+var Relationship = class {
+  constructor(source, destination, definition, archetype, overrideDefinition) {
+    this.source = source;
+    this.destination = destination;
+    this.description = definition?.description;
+    this.technology = definition?.technology;
+    this.tags = (definition?.tags ?? []).concat(["Relationship"]);
+    this.archetype = archetype;
+    this.overrideDefinition = overrideDefinition;
+  }
+  description;
+  tags;
+  technology;
+  archetype;
+  overrideDefinition;
+};
+var Group = class {
+  constructor(name) {
+    this.name = name;
+  }
+  // TODO: Implement this in some useful way?
+  // public addToGroup(groupCollection: string, groupMember: T) {}
+};
+
+// libs/c4-model/src/component.ts
+var Component = class extends TechnicalElement {
+  constructor(name, definition, archetype, overrideDefinition) {
+    super(name, ["Component"], definition, archetype, overrideDefinition);
+    this.name = name;
+  }
+  getChildElements() {
+    return [];
+  }
+};
+
+// libs/c4-model/src/container.ts
+var ContainerGroup = class extends Group {
+  constructor(name, container) {
+    super(name);
+    this.name = name;
+    this.container = container;
+  }
+  _components = /* @__PURE__ */ new Map();
+  defineComponent(name, archetypeOrDef, override) {
+    const component = this.container.defineComponent(name, archetypeOrDef, override);
+    this._components.set(name, component);
+    return component;
+  }
+  getComponents() {
+    return Array.from(this._components.values());
+  }
+};
+var Container = class extends TechnicalElement {
+  constructor(name, definition, archetype, overrideDefinition) {
+    super(name, ["Container"], definition, archetype, overrideDefinition);
+    this.name = name;
+  }
+  _components = /* @__PURE__ */ new Map();
+  _groups = /* @__PURE__ */ new Map();
+  defineComponent(name, archetypeOrDef, override) {
+    if (this._components.has(name)) {
+      throw Error(`A Component named '${name}' is defined elsewhere in this Container. A Component can be defined only once.`);
+    }
+    let definition;
+    let archetype;
+    if (archetypeOrDef instanceof ElementArchetype) {
+      archetype = archetypeOrDef;
+      definition = mergeArchetypeWithOverride(archetypeOrDef, override);
+    } else {
+      definition = archetypeOrDef;
+    }
+    const component = new Component(name, definition, archetype, override);
+    this._components.set(name, component);
+    return component;
+  }
+  addGroup(groupName) {
+    let group = this._groups.get(groupName);
+    if (!group) {
+      group = new ContainerGroup(groupName, this);
+      this._groups.set(groupName, group);
+    }
+    return group;
+  }
+  getGroups() {
+    return Array.from(this._groups.values());
+  }
+  getComponentsNotInGroups() {
+    const componentsInGroups = this.getGroups().flatMap((group) => group.getComponents());
+    return Array.from(this._components.values()).filter((component) => !componentsInGroups.includes(component));
+  }
+  getChildElements() {
+    return Array.from(this._components.values());
+  }
+};
+
+// libs/c4-model/src/softwareSystem.ts
+var SoftwareSystemGroup = class extends Group {
+  constructor(name, softwareSystem) {
+    super(name);
+    this.name = name;
+    this.softwareSystem = softwareSystem;
+  }
+  _containers = /* @__PURE__ */ new Map();
+  defineContainer(name, archetypeOrDef, override) {
+    const container = this.softwareSystem.defineContainer(name, archetypeOrDef, override);
+    this._containers.set(name, container);
+    return container;
+  }
+  getContainers() {
+    return Array.from(this._containers.values());
+  }
+};
+var SoftwareSystem = class extends Element {
+  constructor(name, definition, archetype, overrideDefinition) {
+    super(name, ["Software System"], definition, archetype, overrideDefinition);
+    this.name = name;
+  }
+  _containers = /* @__PURE__ */ new Map();
+  _groups = /* @__PURE__ */ new Map();
+  defineContainer(name, archetypeOrDef, override) {
+    if (this._containers.has(name)) {
+      throw Error(`A Container named '${name}' is defined elsewhere in this SoftwareSystem. A Container can be defined only once.`);
+    }
+    let definition;
+    let archetype;
+    if (archetypeOrDef instanceof ElementArchetype) {
+      archetype = archetypeOrDef;
+      definition = mergeArchetypeWithOverride(archetypeOrDef, override);
+    } else {
+      definition = archetypeOrDef;
+    }
+    const container = new Container(name, definition, archetype, override);
+    this._containers.set(name, container);
+    return container;
+  }
+  addGroup(groupName) {
+    let group = this._groups.get(groupName);
+    if (!group) {
+      group = new SoftwareSystemGroup(groupName, this);
+      this._groups.set(groupName, group);
+    }
+    return group;
+  }
+  getGroups() {
+    return Array.from(this._groups.values());
+  }
+  getChildElements() {
+    return Array.from(this._containers.values());
+  }
+  getContainersNotInGroups() {
+    const containersInGroups = Array.from(this._groups.values()).flatMap((group) => group.getContainers());
+    return Array.from(this._containers.values()).filter((container) => !containersInGroups.includes(container));
+  }
+};
+
+// libs/c4-model/src/person.ts
+var Person = class extends Element {
+  constructor(name, definition, archetype, overrideDefinition) {
+    super(name, ["Person"], definition, archetype, overrideDefinition);
+    this.name = name;
+  }
+  getChildElements() {
+    return [];
+  }
+};
+
+// libs/c4-model/src/model.ts
+var ModelGroup = class extends Group {
+  constructor(name, model) {
+    super(name);
+    this.name = name;
+    this.model = model;
+  }
+  softwareSystems = /* @__PURE__ */ new Map();
+  people = /* @__PURE__ */ new Map();
+  defineSoftwareSystem(name, archetypeOrDef, override) {
+    const softwareSystem = this.model.defineSoftwareSystem(name, archetypeOrDef, override);
+    this.softwareSystems.set(name, softwareSystem);
+    return softwareSystem;
+  }
+  definePerson(name, archetypeOrDef, override) {
+    const person = this.model.definePerson(name, archetypeOrDef, override);
+    this.people.set(name, person);
+    return person;
+  }
+  getSoftwareSystems() {
+    return Array.from(this.softwareSystems.values());
+  }
+  getPeople() {
+    return Array.from(this.people.values());
+  }
+};
+var Model = class {
+  constructor(name) {
+    this.name = name;
+  }
+  softwareSystems = /* @__PURE__ */ new Map();
+  people = /* @__PURE__ */ new Map();
+  groups = /* @__PURE__ */ new Map();
+  defineSoftwareSystem(name, archetypeOrDef, override) {
+    if (this.softwareSystems.has(name)) {
+      throw Error(`A SoftwareSystem named '${name}' is defined elsewhere in this Model. A SoftwareSystem can be defined only once.`);
+    }
+    let definition;
+    let archetype;
+    if (archetypeOrDef instanceof ElementArchetype) {
+      archetype = archetypeOrDef;
+      definition = mergeArchetypeWithOverride(archetypeOrDef, override);
+    } else {
+      definition = archetypeOrDef;
+    }
+    const system = new SoftwareSystem(name, definition, archetype, override);
+    this.softwareSystems.set(name, system);
+    return system;
+  }
+  // TODO:Should be a Group<SoftwareSystem | Person> if that is added back in
+  addGroup(groupName) {
+    let group = this.groups.get(groupName);
+    if (!group) {
+      group = new ModelGroup(groupName, this);
+      this.groups.set(groupName, group);
+    }
+    return group;
+  }
+  definePerson(name, archetypeOrDef, override) {
+    if (this.people.has(name)) {
+      throw Error(`A Person named '${name}' is defined elsewhere in this Model. A Person can be defined only once.`);
+    }
+    let definition;
+    let archetype;
+    if (archetypeOrDef instanceof ElementArchetype) {
+      archetype = archetypeOrDef;
+      definition = mergeArchetypeWithOverride(archetypeOrDef, override);
+    } else {
+      definition = archetypeOrDef;
+    }
+    const person = new Person(name, definition, archetype, override);
+    this.people.set(name, person);
+    return person;
+  }
+  validate() {
+  }
+  getPeople() {
+    return Array.from(this.people.values());
+  }
+  getSoftwareSystems() {
+    return Array.from(this.softwareSystems.values());
+  }
+  getPeopleNotInGroups() {
+    const peopleInGroups = Array.from(this.groups.values()).flatMap((group) => group.getPeople());
+    return Array.from(this.people.values()).filter((person) => !peopleInGroups.includes(person));
+  }
+  getSoftwareSystemsNotInGroups() {
+    const systemsInGroups = Array.from(this.groups.values()).flatMap((group) => group.getSoftwareSystems());
+    return Array.from(this.softwareSystems.values()).filter((system) => !systemsInGroups.includes(system));
+  }
+  getGroups() {
+    return Array.from(this.groups.values());
+  }
+};
+
+// libs/c4-model/src/views.ts
+var View = class {
+  constructor(key, viewDefinition) {
+    this.key = key;
+    this.description = viewDefinition.description;
+    this.subject = viewDefinition.subject;
+    this.title = viewDefinition.title;
+  }
+  subject;
+  description;
+  title;
+  _scopes = [];
+  includeAll() {
+    this._scopes.push("include *");
+  }
+  includeElement(element) {
+    this._scopes.push(`include ${element.canonicalName}`);
+  }
+  includeExpression(expression) {
+    this._scopes.push(`include ${expression}`);
+  }
+  excludeAll() {
+    this._scopes.push("exclude *");
+  }
+  excludeElement(element) {
+    this._scopes.push(`exclude ${element.canonicalName}`);
+  }
+  excludeExpression(expression) {
+    this._scopes.push(`exclude ${expression}`);
+  }
+  get scopes() {
+    return this._scopes;
+  }
+};
+var Views = class {
+  _systemLandscapeViews = /* @__PURE__ */ new Map();
+  _systemContextViews = /* @__PURE__ */ new Map();
+  _containerViews = /* @__PURE__ */ new Map();
+  _componentViews = /* @__PURE__ */ new Map();
+  addSystemLandscapeView(key, definition) {
+    const view = new View(key, { subject: void 0, description: definition.description, title: definition.title });
+    this._systemLandscapeViews.set(key, view);
+    return view;
+  }
+  addSystemContextView(key, definition) {
+    const view = new View(key, definition);
+    this._systemContextViews.set(key, view);
+    return view;
+  }
+  addContainerView(key, definition) {
+    const view = new View(key, definition);
+    this._containerViews.set(key, view);
+    return view;
+  }
+  addComponentView(key, definition) {
+    const view = new View(key, definition);
+    this._componentViews.set(key, view);
+    return view;
+  }
+  get systemLandscapeViews() {
+    return Array.from(this._systemLandscapeViews.values());
+  }
+  get systemContextViews() {
+    return Array.from(this._systemContextViews.values());
+  }
+  get containerViews() {
+    return Array.from(this._containerViews.values());
+  }
+  get componentViews() {
+    return Array.from(this._componentViews.values());
+  }
+};
+
+// libs/c4-model/src/structurizrDslWriter.ts
+var INDENT_SIZE = 2;
+var StructurizrDSLWriter = class {
+  constructor(model, views) {
+    this.model = model;
+    this.views = views;
+  }
+  collectArchetypes() {
+    const elementSet = /* @__PURE__ */ new Set();
+    const relationshipSet = /* @__PURE__ */ new Set();
+    const collectFromElement = (element) => {
+      if (element.archetype) {
+        let arch = element.archetype;
+        while (arch) {
+          elementSet.add(arch);
+          arch = arch.parent;
+        }
+      }
+      element.relationships.forEach((rel) => {
+        if (rel.archetype) {
+          let arch = rel.archetype;
+          while (arch) {
+            relationshipSet.add(arch);
+            arch = arch.parent;
+          }
+        }
+      });
+      element.getChildElements().forEach(collectFromElement);
+    };
+    const allElements = [...this.model.getPeople(), ...this.model.getSoftwareSystems()];
+    allElements.forEach(collectFromElement);
+    const sortArchetypes = (set) => {
+      const sorted = [];
+      const visited = /* @__PURE__ */ new Set();
+      const visit = (arch) => {
+        if (visited.has(arch)) return;
+        if (arch.parent && set.has(arch.parent)) visit(arch.parent);
+        visited.add(arch);
+        sorted.push(arch);
+      };
+      set.forEach(visit);
+      return sorted;
+    };
+    return {
+      elementArchetypes: sortArchetypes(elementSet),
+      relationshipArchetypes: sortArchetypes(relationshipSet)
+    };
+  }
+  writeArchetypes(level) {
+    const { elementArchetypes, relationshipArchetypes } = this.collectArchetypes();
+    if (elementArchetypes.length === 0 && relationshipArchetypes.length === 0) return "";
+    let dsl = this.writeLine(`archetypes {`, level);
+    for (const arch of elementArchetypes) {
+      const baseType = arch.parent ? arch.parent.name : arch.elementKind;
+      let inner = "";
+      if (arch.ownDescription) {
+        inner += this.writeLine(`description "${arch.ownDescription}"`, level + 2);
+      }
+      if (arch.ownTechnology) {
+        inner += this.writeLine(`technology "${arch.ownTechnology}"`, level + 2);
+      }
+      if (arch.ownTags.length > 0) {
+        inner += this.writeLine(`tags ${arch.ownTags.map((t) => `"${t}"`).join(" ")}`, level + 2);
+      }
+      if (inner) {
+        dsl += this.writeLine(`${arch.name} = ${baseType} {`, level + 1);
+        dsl += inner;
+        dsl += this.writeLine(`}`, level + 1);
+      } else {
+        dsl += this.writeLine(`${arch.name} = ${baseType} {}`, level + 1);
+      }
+    }
+    for (const arch of relationshipArchetypes) {
+      const arrow = arch.parent ? `--${arch.parent.name}->` : `->`;
+      let inner = "";
+      if (arch.ownDescription) {
+        inner += this.writeLine(`description "${arch.ownDescription}"`, level + 2);
+      }
+      if (arch.ownTechnology) {
+        inner += this.writeLine(`technology "${arch.ownTechnology}"`, level + 2);
+      }
+      if (arch.ownTags.length > 0) {
+        inner += this.writeLine(`tags ${arch.ownTags.map((t) => `"${t}"`).join(" ")}`, level + 2);
+      }
+      if (inner) {
+        dsl += this.writeLine(`${arch.name} = ${arrow} {`, level + 1);
+        dsl += inner;
+        dsl += this.writeLine(`}`, level + 1);
+      } else {
+        dsl += this.writeLine(`${arch.name} = ${arrow} {}`, level + 1);
+      }
+    }
+    dsl += this.writeLine(`}`, level);
+    return dsl;
+  }
+  writeElement(elementType, element, level, closeElement = true) {
+    let elementDsl = "";
+    const type = element.archetype ? element.archetype.name : elementType;
+    elementDsl += this.writeLine(`${element.canonicalName} = ${type} "${element.name}" {`, level);
+    if (element.archetype) {
+      const ovr = element.overrideDefinition;
+      if (ovr?.description) {
+        elementDsl += this.writeLine(`description "${ovr.description}"`, level + 1);
+      }
+      if (ovr?.tags && ovr.tags.length > 0) {
+        elementDsl += this.writeLine(`tags ${ovr.tags.map((tag) => `"${tag}"`).join(" ")}`, level + 1);
+      }
+      if (ovr && "technology" in ovr && ovr.technology) {
+        elementDsl += this.writeLine(`technology "${ovr.technology}"`, level + 1);
+      }
+    } else {
+      if (element.description) {
+        elementDsl += this.writeLine(`description "${element.description}"`, level + 1);
+      }
+      elementDsl += this.writeLine(`tags ${element.tags.map((tag) => `"${tag}"`).join(" ")}`, level + 1);
+    }
+    if (closeElement) {
+      elementDsl += this.writeLine(`}`, level);
+    }
+    return elementDsl;
+  }
+  writeComponent(component, level) {
+    let componentDsl = "";
+    componentDsl += this.writeElement("component", component, level, false);
+    if (!component.archetype && component.technology) {
+      componentDsl += this.writeLine(`technology "${component.technology}"`, level + 1);
+    }
+    componentDsl += this.writeLine(`}`, level);
+    return componentDsl;
+  }
+  writeContainerGroup(group, level) {
+    let containerGroupDsl = "";
+    containerGroupDsl += this.writeLine(`${group.name} = group "${group.name}" {`, level);
+    group.getComponents().forEach((component) => {
+      containerGroupDsl += this.writeComponent(component, level + 1);
+    });
+    containerGroupDsl += this.writeLine(`}`, level);
+    return containerGroupDsl;
+  }
+  writeContainer(container, level) {
+    let containerDsl = "";
+    containerDsl += this.writeElement("container", container, level, false);
+    if (!container.archetype && container.technology) {
+      containerDsl += this.writeLine(`technology "${container.technology}"`, level + 1);
+    }
+    container.getComponentsNotInGroups().forEach((component) => {
+      containerDsl += this.writeComponent(component, level + 1);
+    });
+    container.getGroups().forEach((group) => {
+      containerDsl += this.writeContainerGroup(group, level + 1);
+    });
+    containerDsl += this.writeLine(`}`, level);
+    return containerDsl;
+  }
+  writeSoftwareSystemGroup(group, level) {
+    let softwareSystemGroupDsl = "";
+    softwareSystemGroupDsl += this.writeLine(`${group.name} = group "${group.name}" {`, level);
+    group.getContainers().forEach((container) => {
+      softwareSystemGroupDsl += this.writeContainer(container, level + 1);
+    });
+    softwareSystemGroupDsl += this.writeLine(`}`, level);
+    return softwareSystemGroupDsl;
+  }
+  writeSoftwareSystem(softwareSystem, level) {
+    let softwareSystemDsl = "";
+    softwareSystemDsl += this.writeElement("softwareSystem", softwareSystem, level, false);
+    softwareSystem.getContainersNotInGroups().forEach((container) => {
+      softwareSystemDsl += this.writeContainer(container, level + 1);
+    });
+    softwareSystem.getGroups().forEach((group) => {
+      softwareSystemDsl += this.writeSoftwareSystemGroup(group, level + 1);
+    });
+    softwareSystemDsl += this.writeLine(`}`, level);
+    return softwareSystemDsl;
+  }
+  writeRelationship(relationship, level) {
+    let dsl = "";
+    if (relationship.archetype) {
+      const arrow = `--${relationship.archetype.name}->`;
+      const ovr = relationship.overrideDefinition;
+      const desc = ovr?.description ?? relationship.description ?? "uses";
+      dsl += this.writeLine(
+        `${relationship.source.canonicalName} ${arrow} ${relationship.destination.canonicalName} "${desc}" {`,
+        level
+      );
+      if (ovr?.technology) {
+        dsl += this.writeLine(`technology "${ovr.technology}"`, level + 1);
+      }
+      if (ovr?.tags && ovr.tags.length > 0) {
+        dsl += this.writeLine(`tags ${ovr.tags.map((tag) => `"${tag}"`).join(" ")}`, level + 1);
+      }
+      dsl += this.writeLine(`}`, level);
+    } else {
+      const tech = relationship.technology ? ` "${relationship.technology}"` : "";
+      dsl += this.writeLine(
+        `${relationship.source.canonicalName} -> ${relationship.destination.canonicalName} "${relationship.description ?? "uses"}"${tech} {`,
+        level
+      );
+      dsl += this.writeLine(`tags ${relationship.tags.map((tag) => `"${tag}"`).join(" ")}`, level + 1);
+      dsl += this.writeLine(`}`, level);
+    }
+    return dsl;
+  }
+  writeRelationships(elements, level) {
+    let relationshipsDsl = "";
+    elements.forEach((element) => {
+      element.getRelationshipsInHierarchy().forEach((relationship) => {
+        relationshipsDsl += this.writeRelationship(relationship, level);
+      });
+    });
+    return relationshipsDsl;
+  }
+  writeModelGroup(group, level) {
+    let modelGroupDsl = "";
+    modelGroupDsl += this.writeLine(`${group.name} = group "${group.name}" {`, level);
+    group.getPeople().forEach((person) => {
+      modelGroupDsl += this.writeElement("person", person, level + 1);
+    });
+    group.getSoftwareSystems().forEach((softwareSystem) => {
+      modelGroupDsl += this.writeSoftwareSystem(softwareSystem, level + 1);
+    });
+    modelGroupDsl += this.writeLine(`}`, level);
+    return modelGroupDsl;
+  }
+  writeModel(model, level) {
+    let modelDsl = "";
+    modelDsl += this.writeLine(`model {`, level);
+    modelDsl += this.writeArchetypes(level + 1);
+    modelDsl += this.writeLine("// Elements", level + 1);
+    model.getPeopleNotInGroups().forEach((person) => {
+      modelDsl += this.writeElement("person", person, level + 1);
+    });
+    model.getSoftwareSystemsNotInGroups().forEach((softwareSystem) => {
+      modelDsl += this.writeSoftwareSystem(softwareSystem, level + 1);
+    });
+    model.getGroups().forEach((group) => {
+      modelDsl += this.writeModelGroup(group, level + 1);
+    });
+    modelDsl += this.writeLine("// Relationships", level + 1);
+    modelDsl += this.writeRelationships(model.getPeople().concat(model.getSoftwareSystems()), level + 1);
+    modelDsl += this.writeLine(`}`, level);
+    return modelDsl;
+  }
+  writeView(view, viewType, level) {
+    let viewDsl = this.writeLine(`${viewType}${view.subject ? ' "' + view.subject.canonicalName + '"' : ""} "${view.key}" {`, level);
+    viewDsl += this.writeLine(`description "${view.description}"`, level + 1);
+    if (view.title) {
+      viewDsl += this.writeLine(`title "${view.title}"`, level + 1);
+    }
+    view.scopes.forEach((scope) => {
+      viewDsl += this.writeLine(`${scope}`, level + 1);
+    });
+    viewDsl += this.writeLine(`}`, level);
+    return viewDsl;
+  }
+  writeViews(views, level) {
+    let viewDsl = "";
+    viewDsl += this.writeLine(`views {`, level);
+    viewDsl += this.writeLine("// System Landscape Views", level + 1);
+    views.systemLandscapeViews.forEach((view) => {
+      viewDsl += this.writeView(view, "systemLandscape", level + 1);
+    });
+    viewDsl += this.writeLine("// System Context Views", level + 1);
+    views.systemContextViews.forEach((view) => {
+      viewDsl += this.writeView(view, "systemContext", level + 1);
+    });
+    viewDsl += this.writeLine("// Container Views", level + 1);
+    views.containerViews.forEach((view) => {
+      viewDsl += this.writeView(view, "container", level + 1);
+    });
+    viewDsl += this.writeLine("// Component Views", level + 1);
+    views.componentViews.forEach((view) => {
+      viewDsl += this.writeView(view, "component", level + 1);
+    });
+    viewDsl += this.writeLine(`theme default`, level + 1);
+    viewDsl += this.writeLine(`}`, level);
+    return viewDsl;
+  }
+  write() {
+    let dsl = "";
+    this.model.validate();
+    dsl += this.writeLine(`workspace "${this.model.name}" {`, 0);
+    dsl += this.writeModel(this.model, 1);
+    dsl += this.writeViews(this.views, 1);
+    dsl += this.writeLine(`}`, 0);
+    return dsl;
+  }
+  writeLine(line, level) {
+    const indent = " ".repeat(level * INDENT_SIZE);
+    return `${indent}${line}
+`;
+  }
+};
+
+// libs/c4-model/src/buildModel.ts
+var import_glob = require("glob");
+var import_path = require("path");
+var import_url = require("url");
+var import_meta = {};
+var _dirname = typeof __dirname !== "undefined" ? __dirname : (0, import_path.dirname)((0, import_url.fileURLToPath)(import_meta.url));
+async function buildModelWithCatalog(options = {}) {
+  const { modelName = "model", modules: explicitModules } = options;
+  const model = new Model(modelName);
+  let c4Modules;
+  if (explicitModules) {
+    c4Modules = [...explicitModules];
+  } else {
+    const { globPath = "c4.dsl.ts", searchRoot = _dirname } = options;
+    const result = await (0, import_glob.glob)(`**/${globPath}`, { cwd: searchRoot });
+    if (result.length === 0) {
+      throw new Error(`No ${globPath} files found`);
+    }
+    const imported = await Promise.all(result.map((file) => import((0, import_path.join)(searchRoot, file))));
+    c4Modules = imported.filter((m) => m.c4Module).map((m) => m.c4Module);
+  }
+  if (c4Modules.length === 0) {
+    throw new Error("No c4Module instances found");
+  }
+  const registrations = [];
+  const rootCatalog = {};
+  for (const instance of c4Modules) {
+    const local = instance.registerDefinitions(model);
+    rootCatalog[instance.key] = local;
+    registrations.push({ instance, key: instance.key, local });
+  }
+  for (const { instance, key, local } of registrations) {
+    const dependencies = Object.fromEntries(Object.entries(rootCatalog).filter(([k]) => k !== key));
+    instance.buildRelationships(local, dependencies);
+  }
+  return { model, catalog: rootCatalog };
+}
+async function buildModel(options = {}) {
+  return (await buildModelWithCatalog(options)).model;
+}
+
+// libs/c4-model/src/generateDiagrams.ts
+var fs = __toESM(require("fs"), 1);
+var os = __toESM(require("os"), 1);
+var path = __toESM(require("path"), 1);
+var import_testcontainers = require("testcontainers");
+async function generateDiagrams(options) {
+  const { views: viewsFactory, outputDir, ...buildOptions } = options;
+  const { model, catalog } = await buildModelWithCatalog(buildOptions);
+  const views = viewsFactory(catalog);
+  const dsl = new StructurizrDSLWriter(model, views).write();
+  const tmpDir = await fs.promises.mkdtemp(path.join(fs.realpathSync(os.tmpdir()), "c4-diagrams-"));
+  await fs.promises.writeFile(path.join(tmpDir, "workspace.dsl"), dsl, "utf8");
+  await new import_testcontainers.GenericContainer("structurizr/structurizr").withBindMounts([{ source: tmpDir, target: "/workspace", mode: "rw" }]).withCommand(["export", "-w", "/workspace/workspace.dsl", "-f", "mermaid", "-o", "/workspace"]).withWaitStrategy(import_testcontainers.Wait.forOneShotStartup()).start();
+  await fs.promises.mkdir(outputDir, { recursive: true });
+  const tmpFiles = await fs.promises.readdir(tmpDir);
+  const mmdFiles = tmpFiles.filter((f) => f.endsWith(".mmd"));
+  for (const file of mmdFiles) {
+    await fs.promises.copyFile(path.join(tmpDir, file), path.join(outputDir, file));
+  }
+  const generatedFiles = mmdFiles.map((f) => path.join(outputDir, f));
+  for (const file of mmdFiles) {
+    const baseName = path.basename(file, ".mmd");
+    const pngFile = `${baseName}.png`;
+    await new import_testcontainers.GenericContainer("minlag/mermaid-cli").withBindMounts([{ source: tmpDir, target: "/data", mode: "rw" }]).withCommand(["-i", `/data/${file}`, "-o", `/data/${pngFile}`]).withWaitStrategy(import_testcontainers.Wait.forOneShotStartup()).start();
+    await fs.promises.copyFile(path.join(tmpDir, pngFile), path.join(outputDir, pngFile));
+    generatedFiles.push(path.join(outputDir, pngFile));
+  }
+  return generatedFiles;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Component,
+  Container,
+  ContainerGroup,
+  ElementArchetype,
+  Model,
+  ModelGroup,
+  Person,
+  RelationshipArchetype,
+  SoftwareSystem,
+  SoftwareSystemGroup,
+  StructurizrDSLWriter,
+  View,
+  Views,
+  buildModel,
+  buildModelWithCatalog,
+  generateDiagrams,
+  mergeArchetypeWithOverride
+});

package/src/index.js

@@ -44,8 +44,93 @@ function mergeArchetypeWithOverride(archetype, override) {
   };
 }
 
+// node_modules/.pnpm/change-case@5.4.4/node_modules/change-case/dist/index.js
+var SPLIT_LOWER_UPPER_RE = /([\p{Ll}\d])(\p{Lu})/gu;
+var SPLIT_UPPER_UPPER_RE = /(\p{Lu})([\p{Lu}][\p{Ll}])/gu;
+var SPLIT_SEPARATE_NUMBER_RE = /(\d)\p{Ll}|(\p{L})\d/u;
+var DEFAULT_STRIP_REGEXP = /[^\p{L}\d]+/giu;
+var SPLIT_REPLACE_VALUE = "$1\0$2";
+var DEFAULT_PREFIX_SUFFIX_CHARACTERS = "";
+function split(value) {
+  let result = value.trim();
+  result = result.replace(SPLIT_LOWER_UPPER_RE, SPLIT_REPLACE_VALUE).replace(SPLIT_UPPER_UPPER_RE, SPLIT_REPLACE_VALUE);
+  result = result.replace(DEFAULT_STRIP_REGEXP, "\0");
+  let start = 0;
+  let end = result.length;
+  while (result.charAt(start) === "\0")
+    start++;
+  if (start === end)
+    return [];
+  while (result.charAt(end - 1) === "\0")
+    end--;
+  return result.slice(start, end).split(/\0/g);
+}
+function splitSeparateNumbers(value) {
+  const words = split(value);
+  for (let i = 0; i < words.length; i++) {
+    const word = words[i];
+    const match = SPLIT_SEPARATE_NUMBER_RE.exec(word);
+    if (match) {
+      const offset = match.index + (match[1] ?? match[2]).length;
+      words.splice(i, 1, word.slice(0, offset), word.slice(offset));
+    }
+  }
+  return words;
+}
+function camelCase(input, options) {
+  const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+  const lower = lowerFactory(options?.locale);
+  const upper = upperFactory(options?.locale);
+  const transform = options?.mergeAmbiguousCharacters ? capitalCaseTransformFactory(lower, upper) : pascalCaseTransformFactory(lower, upper);
+  return prefix + words.map((word, index) => {
+    if (index === 0)
+      return lower(word);
+    return transform(word, index);
+  }).join(options?.delimiter ?? "") + suffix;
+}
+function lowerFactory(locale) {
+  return locale === false ? (input) => input.toLowerCase() : (input) => input.toLocaleLowerCase(locale);
+}
+function upperFactory(locale) {
+  return locale === false ? (input) => input.toUpperCase() : (input) => input.toLocaleUpperCase(locale);
+}
+function capitalCaseTransformFactory(lower, upper) {
+  return (word) => `${upper(word[0])}${lower(word.slice(1))}`;
+}
+function pascalCaseTransformFactory(lower, upper) {
+  return (word, index) => {
+    const char0 = word[0];
+    const initial = index > 0 && char0 >= "0" && char0 <= "9" ? "_" + char0 : upper(char0);
+    return initial + lower(word.slice(1));
+  };
+}
+function splitPrefixSuffix(input, options = {}) {
+  const splitFn = options.split ?? (options.separateNumbers ? splitSeparateNumbers : split);
+  const prefixCharacters = options.prefixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS;
+  const suffixCharacters = options.suffixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS;
+  let prefixIndex = 0;
+  let suffixIndex = input.length;
+  while (prefixIndex < input.length) {
+    const char = input.charAt(prefixIndex);
+    if (!prefixCharacters.includes(char))
+      break;
+    prefixIndex++;
+  }
+  while (suffixIndex > prefixIndex) {
+    const index = suffixIndex - 1;
+    const char = input.charAt(index);
+    if (!suffixCharacters.includes(char))
+      break;
+    suffixIndex = index;
+  }
+  return [
+    input.slice(0, prefixIndex),
+    splitFn(input.slice(prefixIndex, suffixIndex)),
+    input.slice(suffixIndex)
+  ];
+}
+
 // libs/c4-model/src/core.ts
-import { camelCase } from "change-case";
 var Element = class {
   constructor(name, defaultTags = [], definition, archetype, overrideDefinition) {
     this.name = name;
@@ -727,7 +812,7 @@ var StructurizrDSLWriter = class {
 import { glob } from "glob";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
-var __dirname = dirname(fileURLToPath(import.meta.url));
+var _dirname = typeof __dirname !== "undefined" ? __dirname : dirname(fileURLToPath(import.meta.url));
 async function buildModelWithCatalog(options = {}) {
   const { modelName = "model", modules: explicitModules } = options;
   const model = new Model(modelName);
@@ -735,7 +820,7 @@ async function buildModelWithCatalog(options = {}) {
   if (explicitModules) {
     c4Modules = [...explicitModules];
   } else {
-    const { globPath = "c4.dsl.ts", searchRoot = __dirname } = options;
+    const { globPath = "c4.dsl.ts", searchRoot = _dirname } = options;
     const result = await glob(`**/${globPath}`, { cwd: searchRoot });
     if (result.length === 0) {
       throw new Error(`No ${globPath} files found`);