component-flattening-analysis

Compare original and translation side by side

🇺🇸

Original

English

🇨🇳

Translation

Chinese

Component Flattening Analysis

Component扁平化分析

This skill identifies component hierarchy issues and ensures components exist only as leaf nodes in directory/namespace structures, removing orphaned classes from root namespaces.

本技能可识别组件层级问题，确保组件仅作为目录/命名空间结构中的leaf node存在，移除根命名空间中的orphaned classes。

How to Use

使用方法

Quick Start

快速开始

Request analysis of your codebase:

"Find orphaned classes in root namespaces"
"Flatten component hierarchies"
"Identify components that need flattening"
"Analyze component structure for hierarchy issues"

请求对代码库进行分析：

"查找根命名空间中的orphaned classes"
"扁平化组件层级"
"识别需要扁平化的组件"
"分析组件结构中的层级问题"

Usage Examples

使用示例

Example 1: Find Orphaned Classes

User: "Find orphaned classes in root namespaces"

The skill will:
1. Scan component namespaces for hierarchy issues
2. Identify orphaned classes in root namespaces
3. Detect components built on top of other components
4. Suggest flattening strategies
5. Create refactoring plan

Example 2: Flatten Components

User: "Flatten component hierarchies in this codebase"

The skill will:
1. Identify components with hierarchy issues
2. Analyze orphaned classes
3. Suggest consolidation or splitting strategies
4. Create refactoring plan
5. Estimate effort

Example 3: Component Structure Analysis

User: "Analyze component structure for hierarchy issues"

The skill will:
1. Map component namespace structure
2. Identify root namespaces with code
3. Find components built on components
4. Flag hierarchy violations
5. Provide recommendations

示例1：查找孤立类

User: "Find orphaned classes in root namespaces"

该技能将：
1. 扫描组件命名空间以查找层级问题
2. 识别根命名空间中的orphaned classes
3. 检测基于其他组件构建的组件
4. 提出扁平化策略建议
5. 创建重构计划

示例2：扁平化组件

User: "Flatten component hierarchies in this codebase"

该技能将：
1. 识别存在层级问题的组件
2. 分析orphaned classes
3. 提出合并或拆分策略建议
4. 创建重构计划
5. 评估工作量

示例3：组件结构分析

User: "Analyze component structure for hierarchy issues"

该技能将：
1. 绘制组件命名空间结构
2. 识别包含代码的根命名空间
3. 查找基于其他组件构建的组件
4. 标记层级违规情况
5. 提供优化建议

Step-by-Step Process

分步流程

Scan Structure: Map component namespace hierarchies
Identify Issues: Find orphaned classes and component nesting
Analyze Options: Determine flattening strategy (consolidate vs split)
Create Plan: Generate refactoring plan with steps
Execute: Refactor components to remove hierarchy

扫描结构：绘制组件命名空间层级
识别问题：查找orphaned classes和组件嵌套情况
分析方案：确定扁平化策略（合并 vs 拆分）
创建计划：生成包含步骤的重构计划
执行：重构组件以消除层级问题

When to Use

适用场景

Apply this skill when:

After gathering common domain components (Pattern 2)
Before determining component dependencies (Pattern 4)
When components have nested structures
Finding orphaned classes in root namespaces
Preparing for domain grouping
Cleaning up component structure
Ensuring components are leaf nodes only

在以下场景中应用本技能：

收集通用领域组件之后（模式2）
确定组件依赖之前（模式4）
组件存在嵌套结构时
在根命名空间中查找orphaned classes时
准备进行领域分组时
清理组件结构时
确保组件仅作为leaf node存在时

Core Concepts

核心概念

Component Definition

组件定义

A component is identified by a leaf node in directory/namespace structure:

Leaf Node: The deepest directory containing source files
Component: Source code files in leaf node namespace
Subdomain: Parent namespace that has been extended

Key Rule: Components exist only as leaf nodes. If a namespace is extended, the parent becomes a subdomain, not a component.

Component 由目录/命名空间结构中的 leaf node 识别：

Leaf Node：包含源文件的最深层目录
Component：leaf node命名空间中的源代码文件
Subdomain：已被扩展的父命名空间

核心规则：组件仅作为leaf node存在。如果某个命名空间被扩展，其父级将成为子域（subdomain），而非组件。

Root Namespace

根命名空间

A root namespace is a namespace node that has been extended:

Extended: Another namespace node added below it
Example:
```
ss.survey
```
extended to
```
ss.survey.templates
```
Result:
```
ss.survey
```
becomes a root namespace (subdomain)

Root namespace 是已被扩展的命名空间节点：

Extended：在其下方添加了另一个命名空间节点
示例：
```
ss.survey
```
扩展为
```
ss.survey.templates
```
结果：
```
ss.survey
```
成为根命名空间（子域）

Orphaned Classes

孤立类

Orphaned classes are source files in root namespaces:

Location: Root namespace (non-leaf node)
Problem: No definable component associated with them
Solution: Move to leaf node namespace (component)

Example:

ss.survey/              ← Root namespace (extended by .templates)
├── Survey.js           ← Orphaned class (in root namespace)
└── templates/          ← Component (leaf node)
    └── Template.js

Orphaned classes 是位于根命名空间中的源文件：

位置：根命名空间（非leaf node）
问题：没有可定义的组件与之关联
解决方案：移动到leaf node命名空间（组件）

示例：

ss.survey/              ← Root namespace (extended by .templates)
├── Survey.js           ← Orphaned class (in root namespace)
└── templates/          ← Component (leaf node)
    └── Template.js

Flattening Strategies

扁平化策略

Strategy 1: Consolidate Down

Move code from leaf nodes into root namespace
Makes root namespace the component
Example: Move
```
ss.survey.templates
```
→
```
ss.survey
```

Strategy 2: Split Up

Move code from root namespace into new leaf nodes
Creates new components from root namespace

Example: Split

ss.survey

→

ss.survey.create

ss.survey.process

Strategy 3: Move Shared Code

Move shared code to dedicated component
Creates
```
.shared
```
component
Example:
```
ss.survey
```
shared code →
```
ss.survey.shared
```

策略1：向下合并

将leaf node中的代码移动到根命名空间
使根命名空间成为组件
示例：将
```
ss.survey.templates
```
→
```
ss.survey
```

策略2：向上拆分

将根命名空间中的代码移动到新的leaf node
从根命名空间创建新组件

示例：将

ss.survey

拆分为

ss.survey.create

ss.survey.process

策略3：移动共享代码

将共享代码移动到专用组件
创建
```
.shared
```
组件
示例：将
```
ss.survey
```
中的共享代码 →
```
ss.survey.shared
```

Analysis Process

分析流程

Phase 1: Map Component Structure

阶段1：绘制组件结构

Scan directory/namespace structure to identify hierarchy:

Map Namespace Tree
- Build tree of all namespaces
- Identify parent-child relationships
- Mark leaf nodes (components)
Identify Root Namespaces
- Find namespaces that have been extended
- Mark as root namespaces (subdomains)
- Note which namespaces extend them
Locate Source Files
- Find all source files in each namespace
- Map files to their namespace location
- Identify files in root namespaces

Example Structure Mapping:

markdown

undefined

扫描目录/命名空间结构以识别层级：

绘制命名空间树
- 构建所有命名空间的树状结构
- 识别父子关系
- 标记leaf node（组件）
识别根命名空间
- 查找已被扩展的命名空间
- 标记为根命名空间（子域）
- 记录哪些命名空间扩展了它们
定位源文件
- 查找每个命名空间中的所有源文件
- 将文件映射到其所在的命名空间
- 识别根命名空间中的文件

结构绘制示例：

markdown

undefined

Component Structure Map


ss.survey/ ← Root namespace (extended)
├── Survey.js ← Orphaned class
├── SurveyProcessor.js ← Orphaned class
└── templates/ ← Component (leaf node)
├── EmailTemplate.js
└── SMSTemplate.js

ss.ticket/ ← Root namespace (extended)
├── Ticket.js ← Orphaned class
├── assign/ ← Component (leaf node)
│ └── TicketAssign.js
└── route/ ← Component (leaf node)
└── TicketRoute.js

undefined


ss.survey/ ← Root namespace (extended)
├── Survey.js ← Orphaned class
├── SurveyProcessor.js ← Orphaned class
└── templates/ ← Component (leaf node)
├── EmailTemplate.js
└── SMSTemplate.js

ss.ticket/ ← Root namespace (extended)
├── Ticket.js ← Orphaned class
├── assign/ ← Component (leaf node)
│ └── TicketAssign.js
└── route/ ← Component (leaf node)
└── TicketRoute.js

Phase 2: Identify Orphaned Classes

阶段2：识别孤立类

Find source files in root namespaces:

Scan Root Namespaces
- Check each root namespace for source files
- Identify files that are orphaned
- Count orphaned files per root namespace
Classify Orphaned Classes
- Shared Code: Common utilities, interfaces, abstract classes
- Domain Code: Business logic that should be in component
- Mixed: Combination of shared and domain code
Assess Impact
- How many files are orphaned?
- What functionality do they contain?
- What components depend on them?

Example Orphaned Class Detection:

markdown

undefined

查找根命名空间中的源文件：

扫描根命名空间
- 检查每个根命名空间中的源文件
- 识别孤立文件
- 统计每个根命名空间中的孤立文件数量
分类孤立类
- 共享代码：通用工具、接口、抽象类
- 领域代码：应属于组件的业务逻辑
- 混合代码：共享代码与领域代码的组合
评估影响
- 有多少个孤立文件？
- 它们包含哪些功能？
- 哪些组件依赖于它们？

孤立类检测示例：

markdown

undefined

Orphaned Classes Found

Root Namespace: ss.survey

Orphaned Files (5 files):

Survey.js (domain code - survey creation)
SurveyProcessor.js (domain code - survey processing)
SurveyValidator.js (shared code - validation)
SurveyFormatter.js (shared code - formatting)
SurveyConstants.js (shared code - constants)

Classification:

Domain Code: 2 files (should be in components)
Shared Code: 3 files (should be in .shared component)

Dependencies: Used by ss.survey.templates component

undefined

Orphaned Files (5 files):

Survey.js (domain code - survey creation)
SurveyProcessor.js (domain code - survey processing)
SurveyValidator.js (shared code - validation)
SurveyFormatter.js (shared code - formatting)
SurveyConstants.js (shared code - constants)

Classification:

Domain Code: 2 files (should be in components)
Shared Code: 3 files (should be in .shared component)

Dependencies: Used by ss.survey.templates component

undefined

Phase 3: Analyze Flattening Options

阶段3：分析扁平化方案

Determine best flattening strategy for each root namespace:

Option 1: Consolidate Down
- Move leaf node code into root namespace
- Makes root namespace the component
- Use when: Leaf nodes are small, related functionality
Option 2: Split Up
- Move root namespace code into new leaf nodes
- Creates multiple components from root
- Use when: Root namespace has distinct functional areas
Option 3: Move Shared Code
- Extract shared code to
```
.shared
```
  component
- Keep domain code in root or split
- Use when: Root namespace has shared utilities

Example Flattening Analysis:

markdown

undefined

为每个根命名空间确定最佳扁平化策略：

方案1：向下合并
- 将leaf node代码移动到根命名空间
- 使根命名空间成为组件
- 适用场景：leaf node规模小、功能相关
方案2：向上拆分
- 将根命名空间代码移动到新的leaf node
- 从根命名空间创建多个组件
- 适用场景：根命名空间包含不同的功能区域
方案3：移动共享代码
- 将共享代码提取到
```
.shared
```
  组件
- 将领域代码保留在根命名空间或拆分
- 适用场景：根命名空间包含共享工具

扁平化分析示例：

markdown

undefined

Flattening Options Analysis

Root Namespace: ss.survey

Current State:

Root namespace: 5 orphaned files
Leaf component: ss.survey.templates (7 files)

Option 1: Consolidate Down ✅ Recommended

Move templates code into ss.survey
Result: Single component ss.survey
Effort: Low (7 files to move)
Rationale: Templates are small, related to survey functionality

Option 2: Split Up

Create ss.survey.create (2 files)
Create ss.survey.process (1 file)
Create ss.survey.shared (3 files)
Keep ss.survey.templates (7 files)
Effort: High (multiple components to create)
Rationale: More granular, but may be over-engineering

Option 3: Move Shared Code

Create ss.survey.shared (3 shared files)
Keep domain code in root (2 files)
Keep ss.survey.templates (7 files)
Effort: Medium
Rationale: Separates shared from domain, but still has hierarchy

undefined

Current State:

Root namespace: 5 orphaned files
Leaf component: ss.survey.templates (7 files)

Option 1: Consolidate Down ✅ Recommended

Move templates code into ss.survey
Result: Single component ss.survey
Effort: Low (7 files to move)
Rationale: Templates are small, related to survey functionality

Option 2: Split Up

Create ss.survey.create (2 files)
Create ss.survey.process (1 file)
Create ss.survey.shared (3 files)
Keep ss.survey.templates (7 files)
Effort: High (multiple components to create)
Rationale: More granular, but may be over-engineering

Option 3: Move Shared Code

Create ss.survey.shared (3 shared files)
Keep domain code in root (2 files)
Keep ss.survey.templates (7 files)
Effort: Medium
Rationale: Separates shared from domain, but still has hierarchy

undefined

Phase 4: Create Flattening Plan

阶段4：创建扁平化计划

Generate refactoring plan for each root namespace:

Select Strategy
- Choose best flattening option
- Consider effort, complexity, maintainability
Plan Refactoring Steps
- List files to move
- Identify target namespaces
- Note dependencies to update
Estimate Effort
- Time to refactor
- Risk assessment
- Testing requirements

Example Flattening Plan:

markdown

undefined

为每个根命名空间生成重构计划：

选择策略
- 选择最佳扁平化方案
- 考虑工作量、复杂度、可维护性
规划重构步骤
- 列出需要移动的文件
- 确定目标命名空间
- 记录需要更新的依赖项
评估工作量
- 重构所需时间
- 风险评估
- 测试要求

扁平化计划示例：

markdown

undefined

Flattening Plan

Priority: High

Root Namespace: ss.survey

Strategy: Consolidate Down

Steps:

Move files from ss.survey.templates/ to ss.survey/
- EmailTemplate.js
- SMSTemplate.js
- [5 more files]
Update imports in dependent components
- Update references from ss.survey.templates._ to ss.survey._
Remove ss.survey.templates/ directory
Update namespace declarations
- Change namespace from ss.survey.templates to ss.survey
Run tests to verify changes

Effort: 2-3 days Risk: Low (templates are self-contained) Dependencies: None

undefined

Root Namespace: ss.survey

Strategy: Consolidate Down

Steps:

Move files from ss.survey.templates/ to ss.survey/
- EmailTemplate.js
- SMSTemplate.js
- [5 more files]
Update imports in dependent components
- Update references from ss.survey.templates._ to ss.survey._
Remove ss.survey.templates/ directory
Update namespace declarations
- Change namespace from ss.survey.templates to ss.survey
Run tests to verify changes

Effort: 2-3 days Risk: Low (templates are self-contained) Dependencies: None

undefined

Phase 5: Execute Flattening

阶段5：执行扁平化

Perform the refactoring:

Move Files
- Move source files to target namespace
- Update file paths and imports
Update References
- Update imports in dependent components
- Update namespace declarations
- Update directory structure
Verify Changes
- Run tests
- Check for broken references
- Validate component structure

执行重构操作：

移动文件
- 将源文件移动到目标命名空间
- 更新文件路径和导入语句
更新引用
- 更新依赖组件中的导入语句
- 更新命名空间声明
- 更新目录结构
验证变更
- 运行测试
- 检查是否存在无效引用
- 验证组件结构

Output Format

输出格式

Orphaned Classes Report

孤立类报告

markdown

undefined

markdown

undefined

Orphaned Classes Analysis

Root Namespace: ss.survey

Status: ⚠️ Has Orphaned Classes

Orphaned Files (5 files):

Survey.js (domain code)
SurveyProcessor.js (domain code)
SurveyValidator.js (shared code)
SurveyFormatter.js (shared code)
SurveyConstants.js (shared code)

Leaf Components:

ss.survey.templates (7 files)

Issue: Root namespace contains code but is extended by leaf component

Recommendation: Consolidate templates into root namespace

undefined

Status: ⚠️ Has Orphaned Classes

Orphaned Files (5 files):

Survey.js (domain code)
SurveyProcessor.js (domain code)
SurveyValidator.js (shared code)
SurveyFormatter.js (shared code)
SurveyConstants.js (shared code)

Leaf Components:

ss.survey.templates (7 files)

Issue: Root namespace contains code but is extended by leaf component

Recommendation: Consolidate templates into root namespace

undefined

Component Hierarchy Issues

组件层级问题

markdown

undefined

markdown

undefined

Component Hierarchy Issues

Root Namespace	Orphaned Files	Leaf Components	Issue	Recommendation
ss.survey	5	1 (templates)	Has orphaned classes	Consolidate down
ss.ticket	45	2 (assign, route)	Large orphaned code	Split up
ss.reporting	0	3 (tickets, experts, financial)	No issue	✅ OK

undefined

Root Namespace	Orphaned Files	Leaf Components	Issue	Recommendation
ss.survey	5	1 (templates)	Has orphaned classes	Consolidate down
ss.ticket	45	2 (assign, route)	Large orphaned code	Split up
ss.reporting	0	3 (tickets, experts, financial)	No issue	✅ OK

undefined

Flattening Plan

扁平化计划

markdown

undefined

markdown

undefined

Flattening Plan

Priority: High

ss.survey → Consolidate Down

Move 7 files from templates to root
Effort: 2-3 days
Risk: Low

ss.survey → Consolidate Down

Move 7 files from templates to root
Effort: 2-3 days
Risk: Low

Priority: Medium

ss.ticket → Split Up

Create ss.ticket.maintenance (30 files)
Create ss.ticket.completion (10 files)
Create ss.ticket.shared (5 files)
Effort: 1 week
Risk: Medium

undefined

ss.ticket → Split Up

Create ss.ticket.maintenance (30 files)
Create ss.ticket.completion (10 files)
Create ss.ticket.shared (5 files)
Effort: 1 week
Risk: Medium

undefined

Analysis Checklist

分析检查清单

Implementation Notes

实现说明

For Node.js/Express Applications

Node.js/Express 应用

Components typically in

services/

directory:

services/
├── survey/              ← Root namespace (extended)
│   ├── Survey.js       ← Orphaned class
│   └── templates/      ← Component (leaf node)
│       └── Template.js

Flattening:

Consolidate: Move
```
templates/
```
files to
```
survey/
```
Split: Create
```
survey/create/
```
and
```
survey/process/
```
Shared: Create
```
survey/shared/
```
for utilities

组件通常位于

services/

services/
├── survey/              ← Root namespace (extended)
│   ├── Survey.js       ← Orphaned class
│   └── templates/      ← Component (leaf node)
│       └── Template.js

扁平化操作:

合并：将
```
templates/
```
文件移动到
```
survey/
```
拆分：创建
```
survey/create/
```
和
```
survey/process/
```
共享：创建
```
survey/shared/
```
用于存放工具类

For Java Applications

Java 应用

Components identified by package structure:

com.company.survey       ← Root package (extended)
├── Survey.java         ← Orphaned class
└── templates/          ← Component (leaf package)
    └── Template.java

Flattening:

Consolidate: Move
```
templates
```
classes to
```
survey
```
package
Split: Create
```
survey.create
```
and
```
survey.process
```
packages
Shared: Create
```
survey.shared
```
package

组件通过包结构识别：

com.company.survey       ← Root package (extended)
├── Survey.java         ← Orphaned class
└── templates/          ← Component (leaf package)
    └── Template.java

扁平化操作:

合并：将
```
templates
```
类移动到
```
survey
```
包
拆分：创建
```
survey.create
```
和
```
survey.process
```
包
共享：创建
```
survey.shared
```
包

Detection Strategies

检测策略

Find Root Namespaces with Code:

javascript

// Find root namespaces containing source files
function findRootNamespacesWithCode(namespaces, sourceFiles) {
  const rootNamespaces = namespaces.filter((ns) => {
    // Check if namespace has been extended
    const hasChildren = namespaces.some((n) => n.startsWith(ns + '.') || n.startsWith(ns + '/'))

    // Check if namespace contains source files
    const hasFiles = sourceFiles.some((f) => f.namespace === ns)

    return hasChildren && hasFiles
  })

  return rootNamespaces
}

Find Orphaned Classes:

javascript

// Find orphaned classes in root namespaces
function findOrphanedClasses(rootNamespaces, sourceFiles) {
  const orphaned = []

  rootNamespaces.forEach((rootNs) => {
    const files = sourceFiles.filter((f) => f.namespace === rootNs)
    orphaned.push({
      rootNamespace: rootNs,
      files: files,
      count: files.length,
    })
  })

  return orphaned
}

查找包含代码的根命名空间:

javascript

// Find root namespaces containing source files
function findRootNamespacesWithCode(namespaces, sourceFiles) {
  const rootNamespaces = namespaces.filter((ns) => {
    // Check if namespace has been extended
    const hasChildren = namespaces.some((n) => n.startsWith(ns + '.') || n.startsWith(ns + '/'))

    // Check if namespace contains source files
    const hasFiles = sourceFiles.some((f) => f.namespace === ns)

    return hasChildren && hasFiles
  })

  return rootNamespaces
}

查找孤立类:

javascript

// Find orphaned classes in root namespaces
function findOrphanedClasses(rootNamespaces, sourceFiles) {
  const orphaned = []

  rootNamespaces.forEach((rootNs) => {
    const files = sourceFiles.filter((f) => f.namespace === rootNs)
    orphaned.push({
      rootNamespace: rootNs,
      files: files,
      count: files.length,
    })
  })

  return orphaned
}

Fitness Functions

适配函数

After flattening components, create automated checks:

扁平化组件后，创建自动化检查：

No Source Code in Root Namespaces

根命名空间中无源代码

javascript

// Alert if source code exists in root namespace
function checkRootNamespaceCode(namespaces, sourceFiles) {
  const violations = []

  namespaces.forEach((ns) => {
    // Check if namespace has been extended
    const hasChildren = namespaces.some((n) => n.startsWith(ns + '.') || n.startsWith(ns + '/'))

    if (hasChildren) {
      // Check if namespace contains source files
      const files = sourceFiles.filter((f) => f.namespace === ns)

      if (files.length > 0) {
        violations.push({
          namespace: ns,
          files: files.map((f) => f.name),
          issue: 'Root namespace contains source files (orphaned classes)',
        })
      }
    }
  })

  return violations
}

javascript

// Alert if source code exists in root namespace
function checkRootNamespaceCode(namespaces, sourceFiles) {
  const violations = []

  namespaces.forEach((ns) => {
    // Check if namespace has been extended
    const hasChildren = namespaces.some((n) => n.startsWith(ns + '.') || n.startsWith(ns + '/'))

    if (hasChildren) {
      // Check if namespace contains source files
      const files = sourceFiles.filter((f) => f.namespace === ns)

      if (files.length > 0) {
        violations.push({
          namespace: ns,
          files: files.map((f) => f.name),
          issue: 'Root namespace contains source files (orphaned classes)',
        })
      }
    }
  })

  return violations
}

Components Only as Leaf Nodes

组件仅作为leaf node存在

javascript

// Ensure components exist only as leaf nodes
function validateComponentStructure(namespaces, sourceFiles) {
  const violations = []

  // Find all leaf nodes (components)
  const leafNodes = namespaces.filter((ns) => {
    return !namespaces.some((n) => n.startsWith(ns + '.') || n.startsWith(ns + '/'))
  })

  // Check that all source files are in leaf nodes
  sourceFiles.forEach((file) => {
    if (!leafNodes.includes(file.namespace)) {
      violations.push({
        file: file.name,
        namespace: file.namespace,
        issue: 'Source file not in leaf node (component)',
      })
    }
  })

  return violations
}

javascript

// Ensure components exist only as leaf nodes
function validateComponentStructure(namespaces, sourceFiles) {
  const violations = []

  // Find all leaf nodes (components)
  const leafNodes = namespaces.filter((ns) => {
    return !namespaces.some((n) => n.startsWith(ns + '.') || n.startsWith(ns + '/'))
  })

  // Check that all source files are in leaf nodes
  sourceFiles.forEach((file) => {
    if (!leafNodes.includes(file.namespace)) {
      violations.push({
        file: file.name,
        namespace: file.namespace,
        issue: 'Source file not in leaf node (component)',
      })
    }
  })

  return violations
}

Best Practices

最佳实践

Do's ✅

建议 ✅

Ensure components exist only as leaf nodes
Remove orphaned classes from root namespaces
Choose flattening strategy based on functionality
Consolidate when functionality is related
Split when functionality is distinct
Extract shared code to
```
.shared
```
components
Update all references after flattening
Verify changes with tests

确保组件仅作为leaf node存在
移除根命名空间中的orphaned classes
根据功能选择扁平化策略
功能相关时进行合并
功能不同时进行拆分
将共享代码提取到
```
.shared
```
组件
扁平化后更新所有引用
通过测试验证变更

Don'ts ❌

禁忌 ❌

Don't leave orphaned classes in root namespaces
Don't create components on top of other components
Don't skip updating imports after moving files
Don't flatten without analyzing impact
Don't mix flattening strategies inconsistently
Don't ignore shared code when flattening
Don't skip testing after refactoring

不要在根命名空间中保留orphaned classes
不要在其他组件之上创建组件
移动文件后不要跳过更新导入语句
不要在未分析影响的情况下进行扁平化
不要不一致地混合使用扁平化策略
扁平化时不要忽略共享代码
重构后不要跳过测试

Common Patterns

常见模式

Pattern 1: Simple Consolidation

模式1：简单合并

Before:

ss.survey/
├── Survey.js           ← Orphaned
└── templates/          ← Component
    └── Template.js

After:

ss.survey/              ← Component (leaf node)
├── Survey.js
└── Template.js

合并前:

ss.survey/
├── Survey.js           ← Orphaned
└── templates/          ← Component
    └── Template.js

合并后:

ss.survey/              ← Component (leaf node)
├── Survey.js
└── Template.js

Pattern 2: Functional Split

模式2：功能拆分

Before:

ss.ticket/              ← Root namespace
├── Ticket.js           ← Orphaned (45 files)
├── assign/             ← Component
└── route/              ← Component

After:

ss.ticket/              ← Subdomain
├── maintenance/        ← Component
│   └── Ticket.js
├── completion/        ← Component
│   └── TicketCompletion.js
├── assign/             ← Component
└── route/              ← Component

拆分前:

ss.ticket/              ← Root namespace
├── Ticket.js           ← Orphaned (45 files)
├── assign/             ← Component
└── route/              ← Component

拆分后:

ss.ticket/              ← Subdomain
├── maintenance/        ← Component
│   └── Ticket.js
├── completion/        ← Component
│   └── TicketCompletion.js
├── assign/             ← Component
└── route/              ← Component

Pattern 3: Shared Code Extraction

模式3：共享代码提取

Before:

ss.survey/              ← Root namespace
├── Survey.js           ← Domain code
├── SurveyValidator.js  ← Shared code
└── templates/          ← Component

After:

ss.survey/              ← Component
├── Survey.js
└── shared/             ← Component
    └── SurveyValidator.js

提取前:

ss.survey/              ← Root namespace
├── Survey.js           ← Domain code
├── SurveyValidator.js  ← Shared code
└── templates/          ← Component

提取后:

ss.survey/              ← Component
├── Survey.js
└── shared/             ← Component
    └── SurveyValidator.js

Next Steps

后续步骤

After flattening components:

Apply Determine Component Dependencies Pattern - Analyze coupling
Create Component Domains - Group components into domains
Create Domain Services - Extract domains to services

扁平化组件后：

应用组件依赖确定模式 - 分析耦合关系
创建组件领域 - 将组件分组到领域中
创建领域服务 - 将领域提取为服务

Notes

注意事项

Components must exist only as leaf nodes
Root namespaces with code are problematic
Flattening improves component clarity
Choose flattening strategy based on functionality
Shared code should be in dedicated components
Always update references after moving files
Test thoroughly after flattening

组件必须仅作为leaf node存在
包含代码的根命名空间存在问题
扁平化可提升组件清晰度
根据功能选择扁平化策略
共享代码应存放在专用组件中
移动文件后务必更新引用
扁平化后需彻底测试