puremvc-typescript-graph 0.1.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 vizyman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,236 @@
+# puremvc-ts-graph
+
+PureMVC TypeScript 코드를 정적 분석하여 **알림(notification) 흐름**과 **시작 시점(startup) 배선**을 Mermaid 다이어그램으로 자동 생성하는 CLI 도구입니다.
+
+> English documentation: [README-en.md](./README-en.md)
+
+## 빠른 시작
+
+```bash
+npx puremvc-ts-graph
+```
+
+PureMVC 프로젝트 루트에서 실행하면 TypeScript 소스를 스캔하고 아래 구조로 결과를 출력합니다.
+
+```
+docs/
+  puremvc-graph.md          # 개요 + 알림 매핑 테이블
+  AppFacade/
+    startup.mmd               # 시작 시점 배선 다이어그램
+    runtime.mmd               # 런타임 알림 흐름 다이어그램
+    startup.png               # --format png 또는 images.enabled
+    runtime.png
+  TodoModuleFacade/
+    startup.mmd
+    runtime.mmd
+  unscoped/                   # Facade에 할당되지 않은 컴포넌트가 있을 때만
+    startup.mmd
+    runtime.mmd
+```
+
+## 연결을 어떻게 찾고 시각화하는가
+
+이 도구는 **런타임 실행 없이** TypeScript AST(추상 구문 트리)를 분석합니다. [ts-morph](https://github.com/dsherret/ts-morph)로 `srcDir` 아래 `.ts` 파일을 읽고, PureMVC API 호출 패턴과 상수 참조를 추적해 그래프를 만듭니다.
+
+### 1단계: 소스 스캔 및 상수 해석
+
+| 분석 대상 | 찾는 방법 | 용도 |
+| --- | --- | --- |
+| 알림 상수 | glob에 맞는 파일의 `export const` 객체 리터럴 (`constants.glob`, `constants.exportNames`) | `AppConstants.STARTUP` 같은 참조를 실제 문자열 값으로 변환 |
+| 클래스 이름 | 프로젝트 내 모든 `class` 선언 | 팩토리 표현식에서 Command/Proxy/Mediator 클래스 식별 |
+| 클래스 역할 (보조) | `extends` 절의 **직접 부모** 이름 패턴 매칭 | Facade 자동 감지, Observer 역할 라벨 표시 |
+
+상수 해석 예:
+
+```typescript
+// AppConstants.ts
+export const AppConstants = { STARTUP: 'startup' };
+
+// AppFacade.ts
+this.sendNotification(AppConstants.STARTUP);
+// → notification: "startup"
+```
+
+### 2단계: PureMVC API 호출 추출
+
+소스 코드에서 아래 호출을 찾아 **누가(registrar), 무엇을, 어떻게** 연결했는지 기록합니다.
+
+| API 호출 | 추출 정보 | 그래프에서의 의미 |
+| --- | --- | --- |
+| `registerCommand(notif, factory)` | 알림 이름, Command 클래스, 등록한 클래스(Facade/Command) | Command 등록 관계 |
+| `registerProxy(factory)` | Proxy 클래스, 등록한 Command | Proxy 등록 관계 |
+| `registerMediator(mediator)` | Mediator 클래스, 등록한 Command | Mediator 등록 관계 |
+| `addSubCommand(factory)` | MacroCommand → 하위 Command | MacroCommand 실행 순서 |
+| `sendNotification(notif)` | 발신 클래스, 알림 이름 | 런타임 알림 발송 |
+| `listNotificationInterests()` | 관찰 클래스, 구독 알림 목록 | Observer(Mediator/Command) 연결 |
+| `retrieveProxy(name)` | Command 클래스, 사용 Proxy | Command → Proxy 의존 |
+
+팩토리 표현식(`() => new StartupCommand()`, `() => StartupCommand` 등)에서 실제 클래스 이름을 추출합니다.
+
+### 3단계: Facade별 컴포넌트 분류
+
+여러 Facade를 지원하기 위해, 각 컴포넌트를 **어느 Facade에 속하는지** 결정합니다.
+
+1. **Facade 목록 결정**
+   - `facades` 설정이 있으면 그대로 사용
+   - 없으면 `extends Facade`인 클래스를 자동 감지
+   - 둘 다 없으면 `facadeClassName` + `startupNotification` 폴백
+
+2. **Startup 트리 구성**
+   - Facade의 `startupNotification`에 등록된 Command를 시작점으로 잡음
+   - `addSubCommand` 체인을 따라 MacroCommand 하위 Command를 재귀적으로 확장
+
+3. **컴포넌트 할당**
+   - Command: startup 트리 안의 클래스가 `registerCommand`한 Command
+   - Proxy/Mediator: startup 트리 안의 클래스가 `registerProxy` / `registerMediator`한 인스턴스
+   - Facade에 할당되지 않은 컴포넌트 → `unscoped/` 출력
+
+```
+AppFacade
+  └─ startup notification
+       └─ StartupCommand (MacroCommand)
+            ├─ PrepModelCommand  → registerProxy(TodoProxy)
+            ├─ PrepViewCommand   → registerMediator(TodoFormMediator)
+            └─ PrepControllerCommand → registerCommand(...)
+```
+
+### 4단계: 다이어그램 생성
+
+분석 결과를 Mermaid `flowchart`로 변환합니다.
+
+#### Startup 다이어그램 (`startup.mmd`) — 세로(TB)
+
+앱 **기동 시 한 번** 일어나는 배선을 표현합니다.
+
+- `Facade → startupNotification → StartupCommand`
+- MacroCommand `addSubCommand` 순서
+- Command가 등록한 다른 Command (`registrar → notification → Command`)
+- Command가 등록한 Proxy / Mediator
+
+#### Runtime 다이어그램 (`runtime.mmd`) — 가로(LR)
+
+**실행 중** 알림이 어떻게 흐르는지 표현합니다.
+
+- `sendNotification` 발신자 → 해당 알림에 등록된 Command
+- `sendNotification` 발신자 → `listNotificationInterests`로 구독 중인 Observer
+- Command가 `retrieveProxy`로 사용하는 Proxy
+
+#### Markdown 개요 (`puremvc-graph.md`)
+
+Facade별로 알림 매핑 테이블을 생성합니다.
+
+| Notification | Senders | Handlers |
+| --- | --- | --- |
+| 각 알림 | `sendNotification`을 호출하는 클래스 | 등록된 Command + Observer |
+
+### extends vs 등록 API (알아두면 좋은 점)
+
+다이어그램에 **연결을 잡는 기준은 `extends`가 아니라 PureMVC API 호출**입니다.  
+Command, Proxy, Mediator가 중간 베이스 클래스를 거쳐 구현되더라도, 아래 API로 등록·사용되면 그래프에 포함됩니다.
+
+| API | 그래프 반영 |
+| --- | --- |
+| `registerCommand` | Command 등록 및 startup/runtime 연결 |
+| `registerProxy` | Proxy 등록 |
+| `registerMediator` | Mediator 등록 |
+| `addSubCommand` | MacroCommand 실행 순서 |
+| `sendNotification` | 런타임 알림 발송 |
+| `listNotificationInterests` | Observer 구독 |
+| `retrieveProxy` | Command → Proxy 의존 |
+
+`extends` 분석은 **보조 정보**로만 사용됩니다.
+
+| `extends` 용도 | 영향 |
+| --- | --- |
+| Facade 자동 감지 | `extends Facade`인 클래스만 config 없이 Facade로 인식 |
+| Observer 역할 라벨 | `listNotificationInterests` 구독자를 Mediator / Command (observer) / Observer 로 표시 |
+
+예를 들어 `class MyCommand extends BaseCommand` (BaseCommand → SimpleCommand)처럼 2단계 상속이어도 `registerCommand`로 등록되어 있으면 **startup·runtime 다이어그램 모두에 정상 표시**됩니다. 역할 라벨만 `Observer`로 나올 수 있습니다.
+
+**실제로 주의할 점**
+
+- **2단계 Facade 상속**: `class ModuleFacade extends AppFacade`처럼 PureMVC `Facade`를 직접 extends하지 않으면 자동 감지되지 않습니다. config `facades`에 명시하세요.
+- **동적 알림 이름**: 변수나 함수 결과로 만든 알림은 상수로 해석되지 않으면 추적하지 못할 수 있습니다.
+
+## 설정
+
+예시 설정을 프로젝트에 복사합니다.
+
+```bash
+cp node_modules/puremvc-ts-graph/puremvc-graph.config.example.json puremvc-graph.config.json
+```
+
+또는 프로젝트 루트에 `puremvc-graph.config.json`을 직접 작성합니다.
+
+```json
+{
+  "srcDir": "src",
+  "docsDir": "docs",
+  "facades": [
+    { "className": "AppFacade", "startupNotification": "startup" },
+    { "className": "TodoModuleFacade", "startupNotification": "moduleStartup" }
+  ],
+  "constants": {
+    "glob": [
+      "**/*Constants.ts",
+      "**/notifications.ts"
+    ],
+    "exportNames": ["AppConstants", "TodoConstants"]
+  },
+  "images": {
+    "enabled": false,
+    "format": "png"
+  }
+}
+```
+
+| 옵션 | 기본값 | 설명 |
+| --- | --- | --- |
+| `srcDir` | `src` | 스캔할 TypeScript 소스 디렉터리 |
+| `docsDir` | `docs` | 생성 결과 출력 디렉터리 |
+| `facades` | `[]` | Facade 목록과 각 Facade의 startup 알림 |
+| `facadeClassName` | `AppFacade` | `facades`가 비어 있을 때 단일 Facade 폴백 |
+| `startupNotification` | `startup` | `facades`가 비어 있을 때 startup 알림 폴백 |
+| `constants.glob` | `["**/*Constants.ts"]` | 알림 상수 파일 glob (문자열 하나 또는 배열, OR 조건) |
+| `constants.exportNames` | `[]` | glob에 맞는 파일 안에서 파싱할 const 객체 이름 (빈 배열 = 전부) |
+| `images.enabled` | `false` | 매 실행마다 이미지 생성 (`images.format` 사용) |
+| `images.format` | `png` | 기본 이미지 형식: `png` 또는 `svg` |
+
+## CLI 옵션
+
+```bash
+npx puremvc-ts-graph
+npx puremvc-ts-graph --config ./my-config.json
+npx puremvc-ts-graph --cwd /path/to/project
+npx puremvc-ts-graph --format png
+npx puremvc-ts-graph --format svg
+npx puremvc-ts-graph --format png,svg   # 두 형식 모두
+npx puremvc-ts-graph --png              # --format png 단축
+npx puremvc-ts-graph --svg              # --format svg 단축
+npx puremvc-ts-graph --images           # config의 images.format 사용
+npx puremvc-ts-graph --help
+```
+
+이미지 생성은 `@mermaid-js/mermaid-cli`를 사용합니다(optional dependency). 최초 실행 시 Chromium 다운로드가 필요할 수 있습니다.
+
+## dev dependency로 설치
+
+```bash
+npm install -D puremvc-ts-graph
+```
+
+```json
+{
+  "scripts": {
+    "graph": "puremvc-graph"
+  }
+}
+```
+
+## 배포 안내
+
+npm 패키지명은 `puremvc-ts-graph`입니다. PureMVC npm org가 준비되면 `@puremvc/puremvc-ts-graph` 스코프 배포를 검토할 예정입니다.
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { Project } from 'ts-morph';
+import { generateImages } from './lib/image-generator.js';
+import { isHelpRequested, loadConfig, parseCliArgs, printCliHelp, resolveImageGeneration } from './lib/graph-config.js';
+import { buildFacadeDiagramFiles, buildMarkdown, buildStats, buildUnscopedRuntimeMermaid, buildUnscopedStartupMermaid } from './lib/graph-builder.js';
+import { collectGraphData } from './lib/graph-parser.js';
+function createProject(root) {
+    const tsConfigPath = join(root, 'tsconfig.json');
+    return new Project({
+        ...(existsSync(tsConfigPath) ? { tsConfigFilePath: tsConfigPath } : {}),
+        skipAddingFilesFromTsConfig: true
+    });
+}
+function writeDiagramSet(dir, startupMermaid, runtimeMermaid, mmdPaths) {
+    mkdirSync(dir, { recursive: true });
+    const startupPath = join(dir, 'startup.mmd');
+    const runtimePath = join(dir, 'runtime.mmd');
+    writeFileSync(startupPath, startupMermaid, 'utf8');
+    writeFileSync(runtimePath, runtimeMermaid, 'utf8');
+    mmdPaths.push(startupPath, runtimePath);
+}
+function main() {
+    const argv = process.argv.slice(2);
+    if (isHelpRequested(argv)) {
+        printCliHelp();
+        return;
+    }
+    const { projectRoot, configPath } = parseCliArgs(argv);
+    const config = loadConfig(projectRoot, configPath);
+    let imageFormats;
+    try {
+        imageFormats = resolveImageGeneration(argv, config);
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+    const srcDir = join(projectRoot, config.srcDir);
+    const docsDir = join(projectRoot, config.docsDir);
+    if (!existsSync(srcDir)) {
+        console.error(`Source directory not found: ${srcDir}`);
+        process.exit(1);
+    }
+    const project = createProject(projectRoot);
+    const sourceFiles = project.addSourceFilesAtPaths(join(srcDir, '**/*.ts'));
+    const data = collectGraphData(sourceFiles, config);
+    if (!existsSync(docsDir)) {
+        mkdirSync(docsDir, { recursive: true });
+    }
+    const stats = buildStats(data);
+    const mmdPaths = [];
+    const outputDirs = [];
+    const mdPath = join(docsDir, 'puremvc-graph.md');
+    writeFileSync(mdPath, buildMarkdown(data), 'utf8');
+    for (const facade of buildFacadeDiagramFiles(data)) {
+        const facadeDir = join(docsDir, facade.slug);
+        writeDiagramSet(facadeDir, facade.startupMermaid, facade.runtimeMermaid, mmdPaths);
+        outputDirs.push(facadeDir);
+    }
+    const unscopedStartup = buildUnscopedStartupMermaid(data);
+    const unscopedRuntime = buildUnscopedRuntimeMermaid(data);
+    if (unscopedStartup || unscopedRuntime) {
+        const unscopedDir = join(docsDir, 'unscoped');
+        mkdirSync(unscopedDir, { recursive: true });
+        outputDirs.push(unscopedDir);
+        if (unscopedStartup) {
+            const startupPath = join(unscopedDir, 'startup.mmd');
+            writeFileSync(startupPath, unscopedStartup, 'utf8');
+            mmdPaths.push(startupPath);
+        }
+        if (unscopedRuntime) {
+            const runtimePath = join(unscopedDir, 'runtime.mmd');
+            writeFileSync(runtimePath, unscopedRuntime, 'utf8');
+            mmdPaths.push(runtimePath);
+        }
+    }
+    const resolvedConfig = configPath ?? join(projectRoot, 'puremvc-graph.config.json');
+    console.log('PureMVC graph generated:');
+    console.log(`  Project: ${projectRoot}`);
+    console.log(`  Config: ${resolvedConfig}`);
+    console.log(`  ${mdPath}`);
+    for (const dir of outputDirs) {
+        console.log(`  ${dir}/`);
+        if (existsSync(join(dir, 'startup.mmd')))
+            console.log(`    startup.mmd`);
+        if (existsSync(join(dir, 'runtime.mmd')))
+            console.log(`    runtime.mmd`);
+    }
+    console.log('');
+    console.log(`Constant properties: ${stats.notifications}`);
+    console.log(`Command registrations: ${stats.commandRegistrations}`);
+    console.log(`Proxies: ${stats.proxies}`);
+    console.log(`Mediators: ${stats.mediators}`);
+    console.log(`Observers (listNotificationInterests): ${stats.listeners}`);
+    console.log(`Facades: ${stats.facades}`);
+    if (imageFormats) {
+        console.log('');
+        let totalFailed = 0;
+        for (const imageFormat of imageFormats) {
+            console.log(`Generating ${imageFormat.toUpperCase()} images...`);
+            const { generated, failed } = generateImages(mmdPaths, imageFormat);
+            for (const path of generated) {
+                console.log(`  ${path}`);
+            }
+            totalFailed += failed.length;
+        }
+        if (totalFailed > 0) {
+            console.error(`Failed to generate ${totalFailed} image(s).`);
+            process.exit(1);
+        }
+    }
+}
+main();

package/dist/lib/constants-resolver.d.ts

@@ -0,0 +1,18 @@
+import { ClassDeclaration, Node, SourceFile, type Expression } from 'ts-morph';
+import type { PureMvcGraphConfig } from './graph-config.js';
+export declare class ConstantsStore {
+    /** objectName -> propertyName -> notification string value */
+    private readonly objects;
+    /** identifierName -> resolved notification names (for array constants) */
+    private readonly arrayConstants;
+    get objectCount(): number;
+    get propertyCount(): number;
+    parseFromSourceFiles(sourceFiles: SourceFile[], config: PureMvcGraphConfig): void;
+    resolve(expr: Expression | Node | undefined): string | null;
+    resolveArray(expr: Expression | undefined, classDecl: ClassDeclaration | undefined): string[];
+    private matchesAnyConstantsGlob;
+    private matchesConstantsGlob;
+    private parseObjectLiterals;
+    private parseArrayConstants;
+    private unwrapAsConst;
+}

package/dist/lib/constants-resolver.js

@@ -0,0 +1,163 @@
+import { Node } from 'ts-morph';
+export class ConstantsStore {
+    /** objectName -> propertyName -> notification string value */
+    objects = new Map();
+    /** identifierName -> resolved notification names (for array constants) */
+    arrayConstants = new Map();
+    get objectCount() {
+        return this.objects.size;
+    }
+    get propertyCount() {
+        let count = 0;
+        for (const props of this.objects.values()) {
+            count += props.size;
+        }
+        return count;
+    }
+    parseFromSourceFiles(sourceFiles, config) {
+        for (const file of sourceFiles) {
+            if (!this.matchesAnyConstantsGlob(file.getFilePath(), config.constants.glob)) {
+                continue;
+            }
+            this.parseObjectLiterals(file, config.constants.exportNames);
+            this.parseArrayConstants(file);
+        }
+    }
+    resolve(expr) {
+        if (!expr)
+            return null;
+        if (Node.isStringLiteral(expr) || Node.isNoSubstitutionTemplateLiteral(expr)) {
+            return expr.getLiteralText();
+        }
+        if (Node.isPropertyAccessExpression(expr)) {
+            const objectName = expr.getExpression().getText();
+            const propName = expr.getName();
+            return this.objects.get(objectName)?.get(propName) ?? null;
+        }
+        const text = expr.getText();
+        const match = text.match(/^(\w+)\.(\w+)$/);
+        if (match) {
+            return this.objects.get(match[1])?.get(match[2]) ?? null;
+        }
+        return null;
+    }
+    resolveArray(expr, classDecl) {
+        if (!expr)
+            return [];
+        if (Node.isArrayLiteralExpression(expr)) {
+            const result = [];
+            for (const element of expr.getElements()) {
+                if (Node.isSpreadElement(element)) {
+                    result.push(...this.resolveArray(element.getExpression(), classDecl));
+                    continue;
+                }
+                const resolved = this.resolve(element);
+                if (resolved)
+                    result.push(resolved);
+            }
+            return result;
+        }
+        if (Node.isIdentifier(expr)) {
+            const name = expr.getText();
+            const fromCache = this.arrayConstants.get(name);
+            if (fromCache)
+                return [...fromCache];
+            if (classDecl) {
+                const staticProp = classDecl.getStaticProperty(name);
+                if (staticProp && Node.isPropertyDeclaration(staticProp)) {
+                    const staticInit = staticProp.getInitializer();
+                    if (staticInit) {
+                        return this.resolveArray(staticInit, classDecl);
+                    }
+                }
+            }
+            const sourceFile = expr.getSourceFile();
+            const varDecl = sourceFile.getVariableDeclaration(name);
+            const varInit = varDecl?.getInitializer();
+            if (varInit) {
+                return this.resolveArray(varInit, classDecl);
+            }
+        }
+        return [];
+    }
+    matchesAnyConstantsGlob(filePath, globs) {
+        return globs.some((glob) => this.matchesConstantsGlob(filePath, glob));
+    }
+    matchesConstantsGlob(filePath, glob) {
+        const normalized = filePath.replace(/\\/g, '/');
+        const pattern = glob
+            .replace(/\\/g, '/')
+            .replace(/\*\*/g, '§§')
+            .replace(/\*/g, '[^/]*')
+            .replace(/§§/g, '.*');
+        return new RegExp(`${pattern}$`).test(normalized);
+    }
+    parseObjectLiterals(file, exportNames) {
+        for (const decl of file.getVariableDeclarations()) {
+            const name = decl.getName();
+            if (exportNames.length > 0 && !exportNames.includes(name))
+                continue;
+            const init = decl.getInitializer();
+            if (!init)
+                continue;
+            const objectLiteral = this.unwrapAsConst(init);
+            if (!objectLiteral || !Node.isObjectLiteralExpression(objectLiteral))
+                continue;
+            const props = new Map();
+            for (const prop of objectLiteral.getProperties()) {
+                if (!Node.isPropertyAssignment(prop))
+                    continue;
+                const propInit = prop.getInitializer();
+                if (!propInit)
+                    continue;
+                if (!Node.isStringLiteral(propInit) && !Node.isNoSubstitutionTemplateLiteral(propInit)) {
+                    continue;
+                }
+                props.set(prop.getName(), propInit.getLiteralText());
+            }
+            if (props.size > 0) {
+                this.objects.set(name, props);
+            }
+        }
+    }
+    parseArrayConstants(file) {
+        for (const decl of file.getVariableDeclarations()) {
+            const name = decl.getName();
+            const init = decl.getInitializer();
+            if (!init)
+                continue;
+            const array = Node.isArrayLiteralExpression(init)
+                ? init
+                : Node.isAsExpression(init) && Node.isArrayLiteralExpression(init.getExpression())
+                    ? init.getExpression()
+                    : null;
+            if (!array)
+                continue;
+            const values = this.resolveArray(array, undefined);
+            if (values.length > 0) {
+                this.arrayConstants.set(name, values);
+            }
+        }
+        for (const cls of file.getClasses()) {
+            for (const prop of cls.getStaticProperties()) {
+                if (!Node.isPropertyDeclaration(prop))
+                    continue;
+                const propName = prop.getName();
+                const init = prop.getInitializer();
+                if (!init || !Node.isArrayLiteralExpression(init))
+                    continue;
+                const values = this.resolveArray(init, cls);
+                if (values.length > 0) {
+                    this.arrayConstants.set(`${cls.getName()}.${propName}`, values);
+                    this.arrayConstants.set(propName, values);
+                }
+            }
+        }
+    }
+    unwrapAsConst(expr) {
+        if (Node.isAsExpression(expr)) {
+            return expr.getExpression();
+        }
+        return expr;
+    }
+}

package/dist/lib/facade-resolver.d.ts

@@ -0,0 +1,29 @@
+import type { FacadeConfig } from './graph-config.js';
+import type { CommandRegistration, GraphData } from './graph-parser.js';
+export interface FacadeScope {
+    facadeClassName: string;
+    startupNotification: string;
+    startupCommand: string | null;
+    startupTree: Set<string>;
+    commands: Set<string>;
+    proxies: Set<string>;
+    mediators: Set<string>;
+    listeners: Set<string>;
+}
+export interface UnscopedComponents {
+    commands: Set<string>;
+    proxies: Set<string>;
+    mediators: Set<string>;
+    listeners: Set<string>;
+}
+export interface FacadePartition {
+    facades: Map<string, FacadeScope>;
+    unscoped: UnscopedComponents;
+    classToFacade: Map<string, string>;
+}
+export declare function resolveFacadeConfigs(data: GraphData): FacadeConfig[];
+export declare function expandStartupTree(root: string, macroSubCommands: Map<string, string[]>): Set<string>;
+export declare function buildFacadePartition(data: GraphData): FacadePartition;
+export declare function resolveFacadeForClass(className: string, partition: FacadePartition): string | null;
+export declare function getCommandsForNotificationInScope(data: GraphData, notification: string, scope: FacadeScope): CommandRegistration[];
+export declare function getNotificationsInScope(data: GraphData, scope: FacadeScope): string[];