@agilewallaby/c4-model 1.1.0 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agilewallaby/c4-model",
-  "version": "1.1.0",
+  "version": "2.1.0",
   "publishConfig": {
     "access": "public"
   },
@@ -14,8 +14,13 @@
     "testcontainers": "^10.28.0",
     "tslib": "^2.3.0"
   },
-  "type": "commonjs",
+  "type": "module",
   "main": "./src/index.js",
-  "typings": "./src/index.d.ts",
-  "types": "./src/index.d.ts"
+  "types": "./src/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./src/index.js",
+      "types": "./src/index.d.ts"
+    }
+  }
 }

package/src/index.js

@@ -1,12 +1,587 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./model"), exports);
-tslib_1.__exportStar(require("./person"), exports);
-tslib_1.__exportStar(require("./softwareSystem"), exports);
-tslib_1.__exportStar(require("./container"), exports);
-tslib_1.__exportStar(require("./component"), exports);
-tslib_1.__exportStar(require("./views"), exports);
-tslib_1.__exportStar(require("./structurizrDslWriter"), exports);
-tslib_1.__exportStar(require("./generateDiagrams"), exports);
-//# sourceMappingURL=index.js.map
+// libs/c4-model/src/model.ts
+import { glob } from "glob";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+
+// libs/c4-model/src/core.ts
+import { camelCase } from "change-case";
+var Element = class {
+  constructor(name, defaultTags = [], definition) {
+    this.name = name;
+    this.description = definition?.description;
+    this.tags = (definition?.tags ?? []).concat(["Element"]).concat(defaultTags);
+  }
+  description;
+  tags;
+  _relationships = [];
+  get canonicalName() {
+    return camelCase(this.name);
+  }
+  uses(otherElement, definition) {
+    const relationship = new Relationship(this, otherElement, definition);
+    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) {
+    super(name, defaultTags, definition);
+    this.technology = definition?.technology;
+  }
+};
+var Relationship = class {
+  constructor(source, destination, definition) {
+    this.source = source;
+    this.destination = destination;
+    this.description = definition?.description;
+    this.technology = definition?.technology;
+    this.tags = (definition?.tags ?? []).concat(["Relationship"]);
+  }
+  description;
+  tags;
+  technology;
+};
+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) {
+    super(name, ["Component"], definition);
+    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, definition) {
+    const component = this.container.defineComponent(name, definition);
+    this._components.set(name, component);
+    return component;
+  }
+  getComponents() {
+    return Array.from(this._components.values());
+  }
+};
+var Container = class extends TechnicalElement {
+  constructor(name, definition) {
+    super(name, ["Container"], definition);
+    this.name = name;
+  }
+  _components = /* @__PURE__ */ new Map();
+  _groups = /* @__PURE__ */ new Map();
+  defineComponent(name, definition) {
+    if (this._components.has(name)) {
+      throw Error(`A Component named '${name}' is defined elsewhere in this Container. A Component can be defined only once.`);
+    }
+    const component = new Component(name, definition);
+    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, definition) {
+    const container = this.softwareSystem.defineContainer(name, definition);
+    this._containers.set(name, container);
+    return container;
+  }
+  getContainers() {
+    return Array.from(this._containers.values());
+  }
+};
+var SoftwareSystem = class extends Element {
+  constructor(name, definition) {
+    super(name, ["Software System"], definition);
+    this.name = name;
+  }
+  _containers = /* @__PURE__ */ new Map();
+  _groups = /* @__PURE__ */ new Map();
+  defineContainer(name, definition) {
+    if (this._containers.has(name)) {
+      throw Error(`A Container named '${name}' is defined elsewhere in this SoftwareSystem. A Container can be defined only once.`);
+    }
+    const container = new Container(name, definition);
+    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) {
+    super(name, ["Person"], definition);
+    this.name = name;
+  }
+  getChildElements() {
+    return [];
+  }
+};
+
+// libs/c4-model/src/model.ts
+var __dirname = dirname(fileURLToPath(import.meta.url));
+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, definition) {
+    const softwareSystem = this.model.defineSoftwareSystem(name, definition);
+    this.softwareSystems.set(name, softwareSystem);
+    return softwareSystem;
+  }
+  definePerson(name, definition) {
+    const person = this.model.definePerson(name, definition);
+    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, definition) {
+    if (this.softwareSystems.has(name)) {
+      throw Error(`A SoftwareSystem named '${name}' is defined elsewhere in this Model. A SoftwareSystem can be defined only once.`);
+    }
+    const system = new SoftwareSystem(name, definition);
+    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, definition) {
+    if (this.people.has(name)) {
+      throw Error(`A Person named '${name}' is defined elsewhere in this Model. A Person can be defined only once.`);
+    }
+    const person = new Person(name, definition);
+    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());
+  }
+};
+async function buildModelWithCatalog(options = {}) {
+  const { modelName = "model", globPath = "c4.dsl.ts", searchRoot = __dirname } = options;
+  const model = new Model(modelName);
+  const result = await glob(`**/${globPath}`, { cwd: searchRoot });
+  if (result.length === 0) {
+    throw new Error(`No ${globPath} files found`);
+  }
+  const modules = await Promise.all(result.map((file) => import(join(searchRoot, file))));
+  const registrations = [];
+  const rootCatalog = {};
+  for (const module of modules) {
+    if (!module.c4Module) {
+      continue;
+    }
+    const instance = module.c4Module;
+    const local = instance.registerDefinitions(model);
+    rootCatalog[instance.key] = local;
+    registrations.push({ instance, key: instance.key, local });
+  }
+  if (registrations.length === 0) {
+    throw new Error(`No c4Module exports found in any ${globPath} files`);
+  }
+  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/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;
+  }
+  writeElement(elementType, element, level, closeElement = true) {
+    let elementDsl = "";
+    elementDsl += this.writeLine(`${element.canonicalName} = ${elementType} "${element.name}" {`, level);
+    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);
+    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);
+    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;
+  }
+  writeRelationships(elements, level) {
+    let relationshipsDsl = "";
+    elements.forEach((element) => {
+      element.getRelationshipsInHierarchy().forEach((relationship) => {
+        const tech = relationship.technology ? ` "${relationship.technology}"` : "";
+        relationshipsDsl += this.writeLine(
+          `${relationship.source.canonicalName} -> ${relationship.destination.canonicalName} "${relationship.description ?? "uses"}"${tech} {`,
+          level
+        );
+        relationshipsDsl += this.writeLine(`tags ${relationship.tags.map((tag) => `"${tag}"`).join(" ")}`, level + 1);
+        relationshipsDsl += this.writeLine(`}`, 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.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/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,
+  Model,
+  ModelGroup,
+  Person,
+  SoftwareSystem,
+  SoftwareSystemGroup,
+  StructurizrDSLWriter,
+  View,
+  Views,
+  buildModel,
+  buildModelWithCatalog,
+  generateDiagrams
+};

package/CLAUDE.md

@@ -1,45 +0,0 @@
-# c4-model
-
-## About
-
-TypeScript library for defining C4 architecture models and generating Structurizr DSL.
-
-## Structurizr DSL Reference
-
-Structurizr DSL docs are available locally at `docs/structurizr/` (run
-`pnpm fetch-structurizr-docs` to populate). When working on `structurizrDslWriter.ts`,
-read the relevant files from that directory. If not present locally, source is:
-https://github.com/structurizr/structurizr.github.io/tree/main/dsl
-
-## Running tasks
-
-```sh
-pnpm exec nx run c4-model:test
-pnpm exec nx run c4-model:build
-pnpm exec nx run c4-model:lint
-```
-
-## Architecture
-
-- `core.ts` — Base classes: `Element`, `TechnicalElement`, `Relationship`, `Reference`, `Group`
-- `model.ts` — `Model` class, `C4Module` interface, `buildModel()` two-phase loader
-- `person.ts` / `softwareSystem.ts` / `container.ts` / `component.ts` — C4 element types
-- `views.ts` — View definitions (system landscape, context, container, component)
-- `structurizrDslWriter.ts` — Generates Structurizr DSL from a Model + Views
-
-## C4Module pattern
-
-Modules are defined in `c4.dsl.ts` files discovered by `buildModel()` via glob. Each exports a `c4Module`:
-
-```ts
-export const c4Module: C4Module<RootCatalog, LocalCatalog> = {
-    key: 'myModule',
-    registerDefinitions(model) { /* define elements, return catalog */ },
-    buildRelationships(local, dependencies) { /* wire up cross-module relationships */ },
-}
-```
-
-- **Phase 1**: All modules register definitions; results stored in a root catalog keyed by module key
-- **Phase 2**: Each module receives its own catalog and all other modules' catalogs to build relationships
-- `CatalogKeyOf` and `Dependencies` utility types ensure type-safe keys and dependency access
-- See `libs/c4-model-examples` for integration tests using `buildModel()`

package/src/component.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Component = void 0;
-const core_1 = require("./core");
-class Component extends core_1.TechnicalElement {
-    constructor(name, definition) {
-        super(name, ['Component'], definition);
-        this.name = name;
-    }
-    getChildElements() {
-        return [];
-    }
-}
-exports.Component = Component;
-//# sourceMappingURL=component.js.map

package/src/component.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"component.js","sourceRoot":"","sources":["../../../../libs/c4-model/src/component.ts"],"names":[],"mappings":";;;AAAA,iCAAwE;AAIxE,MAAa,SAAU,SAAQ,uBAAgB;IAC3C,YAC6B,IAAY,EACrC,UAAgC;QAEhC,KAAK,CAAC,IAAI,EAAE,CAAC,WAAW,CAAC,EAAE,UAAU,CAAC,CAAA;QAHb,SAAI,GAAJ,IAAI,CAAQ;IAIzC,CAAC;IAEM,gBAAgB;QACnB,OAAO,EAAE,CAAA;IACb,CAAC;CACJ;AAXD,8BAWC"}