@agilewallaby/c4-model 2.0.0 → 2.2.0

package/src/index.js

@@ -1,9 +1,813 @@
-export * from './model';
-export * from './person';
-export * from './softwareSystem';
-export * from './container';
-export * from './component';
-export * from './views';
-export * from './structurizrDslWriter';
-export * from './generateDiagrams';
-//# sourceMappingURL=index.js.map
+// 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 ?? []]
+  };
+}
+
+// libs/c4-model/src/core.ts
+import { camelCase } from "change-case";
+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
+import { glob } from "glob";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+var __dirname = dirname(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 glob(`**/${globPath}`, { cwd: searchRoot });
+    if (result.length === 0) {
+      throw new Error(`No ${globPath} files found`);
+    }
+    const imported = await Promise.all(result.map((file) => import(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
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { GenericContainer, Wait } from "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 GenericContainer("structurizr/structurizr").withBindMounts([{ source: tmpDir, target: "/workspace", mode: "rw" }]).withCommand(["export", "-w", "/workspace/workspace.dsl", "-f", "mermaid", "-o", "/workspace"]).withWaitStrategy(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 GenericContainer("minlag/mermaid-cli").withBindMounts([{ source: tmpDir, target: "/data", mode: "rw" }]).withCommand(["-i", `/data/${file}`, "-o", `/data/${pngFile}`]).withWaitStrategy(Wait.forOneShotStartup()).start();
+    await fs.promises.copyFile(path.join(tmpDir, pngFile), path.join(outputDir, pngFile));
+    generatedFiles.push(path.join(outputDir, pngFile));
+  }
+  return generatedFiles;
+}
+export {
+  Component,
+  Container,
+  ContainerGroup,
+  ElementArchetype,
+  Model,
+  ModelGroup,
+  Person,
+  RelationshipArchetype,
+  SoftwareSystem,
+  SoftwareSystemGroup,
+  StructurizrDSLWriter,
+  View,
+  Views,
+  buildModel,
+  buildModelWithCatalog,
+  generateDiagrams,
+  mergeArchetypeWithOverride
+};