@bovinphang/frontend-craft 2.8.0 → 3.0.0

package/skills/fec-refactoring/references/workflow.md

@@ -0,0 +1,7 @@
+# Frontend refactoring validation
+
+Execution order, rollback and proof verdicts follow the [common method](common/refactoring.md).
+
+Choose checks by risk: nearest types/static checks → utilities/hooks/components → Router/Provider/Store integration → full lint/types/tests → build and affected SSR, E2E, accessibility, visual or performance checks.
+
+Record actual project commands, UI/state/network observations, baseline failures, per-step changes and rollback boundaries. Pure structural refactoring does not invent new behavioral failures or revert unrelated user work.

package/skills/fec-refactoring-api/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: fec-refactoring-api
+description: Use when behavior-preserving frontend refactoring focuses on function API shape, flags, dependencies, mutability, construction, or command/function trade-offs, and the selected technique needs family-specific mechanics, risks, and JavaScript/TypeScript/React/Vue adaptation.
+---
+
+# API Refactorings
+
+## Overview
+Use this family after evidence identifies a fitting structural transformation. Apply one primary technique at a time and verify immediately.
+
+## Procedure
+1. Confirm the selected technique and its preconditions in [API Refactorings](references/api-refactorings.md).
+2. Record affected behavior and a diff budget.
+3. Apply only the selected technique's smallest viable step.
+4. Verify the step before composing another transformation.
+5. Stop and reassess when public contracts, lifecycle, state identity, or actual scope exceed expectations.
+
+## Quick Reference
+The family reference contains 10 canonical techniques with intent, signals, avoid conditions, mechanics, preservation checkpoints, smell links, composition hints, JavaScript/TypeScript notes, React/Vue notes, adaptation guidance, and original frontend examples.
+
+## Common Mistakes
+- Choosing a technique by name without checking its preconditions.
+- Combining several structural intentions in one diff.
+- Assuming a classical class-based form is mandatory in modern frontend code.
+- Treating passing tests as proof when the relevant behavior is not covered.

package/skills/fec-refactoring-api/references/api-refactorings.md

@@ -0,0 +1,496 @@
+# API Refactorings
+
+These cards transform the supplied standard catalog into concise operational guidance for frontend agents. Standard IDs/names are preserved; examples and framework adaptations are original.
+
+## RF-SEPARATE-QUERY-FROM-MODIFIER — Separate Query from Modifier
+
+### Intent
+Separate a function that returns information from the operation that changes state.
+
+### Typical Signals
+- A caller cannot ask for a value without also triggering mutation/effects.
+
+### Avoid When
+- Keep an atomic combined operation when separating it would introduce race conditions or break transactional semantics.
+
+### Preconditions
+- Current observable behavior and affected callers are understood.
+- The target scope is inside a declared diff budget and can be verified after this one primary transformation.
+
+### Mechanics
+1. Identify the returned value and mutation.
+2. Extract a pure/read-only query for the value.
+3. Keep mutation in a command/action.
+4. Migrate callers based on whether they need read, write, or both.
+
+### Behavior-Preservation Checkpoints
+- Compare inputs, outputs, exceptions, side effects, ordering, and public contracts before/after the step.
+- For frontend code, also check UI state, events, focus, network behavior, lifecycle/state transitions, and relevant identity semantics.
+
+### Related Code Smells
+- `SMELL-MUTABLE-DATA`
+
+### Composes Well With
+- Combine only with a separately justified next transformation; no fixed sequence is required.
+
+### JavaScript Notes
+- Preserve arity-sensitive callbacks, `this`, default values, thrown errors, and side-effect timing.
+
+### TypeScript Notes
+- Treat exported function signatures, generics, overloads, DTOs, and public types as compatibility contracts.
+
+### React Notes
+- Props/callback signatures, hooks, loaders/actions, router contracts, and context APIs may be public boundaries.
+
+### Vue Notes
+- Props/emits, composable returns, Pinia actions, route contracts, and injection keys may be public boundaries.
+
+### Frontend-Craft Adaptation
+- Prefer explicit, testable dependencies. Command objects earn their cost only when state/lifecycle such as undo, queue, retry, or audit justifies them.
+
+### Example Transformation
+Before: `getUnreadCountAndMarkSeen()` both reads and mutates. After: expose `getUnreadCount()` and `markSeen()` while preserving workflows that intentionally call both.
+
+## RF-PARAMETERIZE-FUNCTION — Parameterize Function
+
+### Intent
+Replace several near-duplicate functions with one function parameterized by the varying value.
+
+### Typical Signals
+- Functions differ only by a literal, threshold, mode, or other explicit data.
+
+### Avoid When
+- Avoid when the variants represent distinct business concepts whose names are valuable or behavior will diverge.
+
+### Preconditions
+- Current observable behavior and affected callers are understood.
+- The target scope is inside a declared diff budget and can be verified after this one primary transformation.
+
+### Mechanics
+1. Compare implementations and isolate the varying value.
+2. Add a parameter for that variation.
+3. Migrate one old function/caller at a time.
+4. Inline/remove wrappers only when names no longer add domain value.
+
+### Behavior-Preservation Checkpoints
+- Compare inputs, outputs, exceptions, side effects, ordering, and public contracts before/after the step.
+- For frontend code, also check UI state, events, focus, network behavior, lifecycle/state transitions, and relevant identity semantics.
+
+### Related Code Smells
+- No single code smell required; select from concrete structural evidence.
+
+### Composes Well With
+- Combine only with a separately justified next transformation; no fixed sequence is required.
+
+### JavaScript Notes
+- Preserve arity-sensitive callbacks, `this`, default values, thrown errors, and side-effect timing.
+
+### TypeScript Notes
+- Treat exported function signatures, generics, overloads, DTOs, and public types as compatibility contracts.
+
+### React Notes
+- Props/callback signatures, hooks, loaders/actions, router contracts, and context APIs may be public boundaries.
+
+### Vue Notes
+- Props/emits, composable returns, Pinia actions, route contracts, and injection keys may be public boundaries.
+
+### Frontend-Craft Adaptation
+- Prefer explicit, testable dependencies. Command objects earn their cost only when state/lifecycle such as undo, queue, retry, or audit justifies them.
+
+### Example Transformation
+Before: `loadFirstPage()` and `loadNextPage()` differ only by page index. After: `loadPage(page)` if their policies are truly identical.
+
+## RF-REMOVE-FLAG-ARGUMENT — Remove Flag Argument
+
+### Intent
+Replace an argument that selects different behavior with explicit operations or a clearer dispatch API.
+
+### Typical Signals
+- A boolean/enum flag tells a function which branch of behavior to execute.
+
+### Avoid When
+- Do not remove ordinary data booleans that are part of the domain value rather than a control instruction.
+
+### Preconditions
+- Current observable behavior and affected callers are understood.
+- The target scope is inside a declared diff budget and can be verified after this one primary transformation.
+
+### Mechanics
+1. Identify behavior-selecting flags and affected call sites.
+2. Create explicit functions/entry points for meaningful behaviors.
+3. Migrate callers from magic boolean/enum values.
+4. Remove the flag branch after all callers are clear.
+
+### Behavior-Preservation Checkpoints
+- Compare inputs, outputs, exceptions, side effects, ordering, and public contracts before/after the step.
+- For frontend code, also check UI state, events, focus, network behavior, lifecycle/state transitions, and relevant identity semantics.
+
+### Related Code Smells
+- `SMELL-LONG-PARAMETER-LIST`
+
+### Composes Well With
+- Combine only with a separately justified next transformation; no fixed sequence is required.
+
+### JavaScript Notes
+- Preserve arity-sensitive callbacks, `this`, default values, thrown errors, and side-effect timing.
+
+### TypeScript Notes
+- Treat exported function signatures, generics, overloads, DTOs, and public types as compatibility contracts.
+
+### React Notes
+- Props/callback signatures, hooks, loaders/actions, router contracts, and context APIs may be public boundaries.
+
+### Vue Notes
+- Props/emits, composable returns, Pinia actions, route contracts, and injection keys may be public boundaries.
+
+### Frontend-Craft Adaptation
+- Prefer explicit, testable dependencies. Command objects earn their cost only when state/lifecycle such as undo, queue, retry, or audit justifies them.
+
+### Example Transformation
+Before: `send(draft, true)` means schedule. After: `scheduleSend(draft)` and `sendNow(draft)` expose intent.
+
+## RF-PRESERVE-WHOLE-OBJECT — Preserve Whole Object
+
+### Intent
+Pass the source object when a function needs several of its fields instead of unpacking them into a long parameter list.
+
+### Typical Signals
+- Callers extract multiple values from one object solely to pass them together.
+
+### Avoid When
+- Avoid when passing the whole object would create an undesirable dependency on a broad mutable/public structure.
+
+### Preconditions
+- Current observable behavior and affected callers are understood.
+- The target scope is inside a declared diff budget and can be verified after this one primary transformation.
+
+### Mechanics
+1. Identify values originating from one object.
+2. Change the callee to accept the object while keeping calculation unchanged.
+3. Migrate callers.
+4. Narrow to an interface/view if the whole object exposes too much.
+
+### Behavior-Preservation Checkpoints
+- Compare inputs, outputs, exceptions, side effects, ordering, and public contracts before/after the step.
+- For frontend code, also check UI state, events, focus, network behavior, lifecycle/state transitions, and relevant identity semantics.
+
+### Related Code Smells
+- `SMELL-LONG-FUNCTION`
+- `SMELL-LONG-PARAMETER-LIST`
+- `SMELL-DATA-CLUMPS`
+
+### Composes Well With
+- Combine only with a separately justified next transformation; no fixed sequence is required.
+
+### JavaScript Notes
+- Preserve arity-sensitive callbacks, `this`, default values, thrown errors, and side-effect timing.
+
+### TypeScript Notes
+- Treat exported function signatures, generics, overloads, DTOs, and public types as compatibility contracts.
+
+### React Notes
+- Props/callback signatures, hooks, loaders/actions, router contracts, and context APIs may be public boundaries.
+
+### Vue Notes
+- Props/emits, composable returns, Pinia actions, route contracts, and injection keys may be public boundaries.
+
+### Frontend-Craft Adaptation
+- Prefer explicit, testable dependencies. Command objects earn their cost only when state/lifecycle such as undo, queue, retry, or audit justifies them.
+
+### Example Transformation
+Before: `withinRange(room.temp.low, room.temp.high, plan)` becomes `withinRange(room.temp, plan)` with a typed narrow range contract.
+
+## RF-REPLACE-PARAMETER-WITH-QUERY — Replace Parameter with Query
+
+### Intent
+Remove a parameter when the callee can obtain the same value from an appropriate stable source.
+
+### Typical Signals
+- Callers repeatedly compute/pass a value that the callee already can derive.
+
+### Avoid When
+- Avoid when the query introduces hidden dependency, impurity, nondeterminism, or makes testing harder.
+
+### Preconditions
+- Current observable behavior and affected callers are understood.
+- The target scope is inside a declared diff budget and can be verified after this one primary transformation.
+
+### Mechanics
+1. Identify the stable query source.
+2. Read the value inside the function.
+3. Migrate callers and remove the redundant parameter.
+4. Verify dependency visibility and testability.
+
+### Behavior-Preservation Checkpoints
+- Compare inputs, outputs, exceptions, side effects, ordering, and public contracts before/after the step.
+- For frontend code, also check UI state, events, focus, network behavior, lifecycle/state transitions, and relevant identity semantics.
+
+### Related Code Smells
+- `SMELL-LONG-PARAMETER-LIST`
+
+### Composes Well With
+- Combine only with a separately justified next transformation; no fixed sequence is required.
+
+### JavaScript Notes
+- Preserve arity-sensitive callbacks, `this`, default values, thrown errors, and side-effect timing.
+
+### TypeScript Notes
+- Treat exported function signatures, generics, overloads, DTOs, and public types as compatibility contracts.
+
+### React Notes
+- Props/callback signatures, hooks, loaders/actions, router contracts, and context APIs may be public boundaries.
+
+### Vue Notes
+- Props/emits, composable returns, Pinia actions, route contracts, and injection keys may be public boundaries.
+
+### Frontend-Craft Adaptation
+- Prefer explicit, testable dependencies. Command objects earn their cost only when state/lifecycle such as undo, queue, retry, or audit justifies them.
+
+### Example Transformation
+Before: every caller passes `tenant.locale` into a tenant-owned formatter. After: the formatter queries its explicit tenant context when that dependency is appropriate.
+
+## RF-REPLACE-QUERY-WITH-PARAMETER — Replace Query with Parameter
+
+### Intent
+Make a hidden dependency explicit by passing the needed value into a function.
+
+### Typical Signals
+- A function queries global/context state that reduces purity, reuse, determinism, or testability.
+
+### Avoid When
+- Avoid exploding parameter lists or passing values that are truly intrinsic to the receiver’s responsibility.
+
+### Preconditions
+- Current observable behavior and affected callers are understood.
+- The target scope is inside a declared diff budget and can be verified after this one primary transformation.
+
+### Mechanics
+1. Identify the hidden query/dependency.
+2. Add a parameter for the needed value or narrow interface.
+3. Move the query to callers at the right boundary.
+4. Verify callers and avoid duplicating inconsistent query logic.
+
+### Behavior-Preservation Checkpoints
+- Compare inputs, outputs, exceptions, side effects, ordering, and public contracts before/after the step.
+- For frontend code, also check UI state, events, focus, network behavior, lifecycle/state transitions, and relevant identity semantics.
+
+### Related Code Smells
+- No single code smell required; select from concrete structural evidence.
+
+### Composes Well With
+- Combine only with a separately justified next transformation; no fixed sequence is required.
+
+### JavaScript Notes
+- Preserve arity-sensitive callbacks, `this`, default values, thrown errors, and side-effect timing.
+
+### TypeScript Notes
+- Treat exported function signatures, generics, overloads, DTOs, and public types as compatibility contracts.
+
+### React Notes
+- Props/callback signatures, hooks, loaders/actions, router contracts, and context APIs may be public boundaries.
+
+### Vue Notes
+- Props/emits, composable returns, Pinia actions, route contracts, and injection keys may be public boundaries.
+
+### Frontend-Craft Adaptation
+- Prefer explicit, testable dependencies. Command objects earn their cost only when state/lifecycle such as undo, queue, retry, or audit justifies them.
+
+### Example Transformation
+Before: a pure formatter reads global timezone. After: pass the resolved timezone from application context so tests and SSR remain deterministic.
+
+## RF-REMOVE-SETTING-METHOD — Remove Setting Method
+
+### Intent
+Remove mutation APIs for state that should not change after construction/initialization.
+
+### Typical Signals
+- A setter exists but valid usage never changes the value after creation.
+
+### Avoid When
+- Do not remove required edit workflows or framework-controlled setters without replacing the legitimate mutation path.
+
+### Preconditions
+- Current observable behavior and affected callers are understood.
+- The target scope is inside a declared diff budget and can be verified after this one primary transformation.
+
+### Mechanics
+1. Find all writes and establish the intended invariant.
+2. Move required initialization into construction/factory input.
+3. Migrate or reject post-construction writes.
+4. Remove the setter after callers no longer need it.
+
+### Behavior-Preservation Checkpoints
+- Compare inputs, outputs, exceptions, side effects, ordering, and public contracts before/after the step.
+- For frontend code, also check UI state, events, focus, network behavior, lifecycle/state transitions, and relevant identity semantics.
+
+### Related Code Smells
+- `SMELL-MUTABLE-DATA`
+- `SMELL-DATA-CLASS`
+
+### Composes Well With
+- Combine only with a separately justified next transformation; no fixed sequence is required.
+
+### JavaScript Notes
+- Preserve arity-sensitive callbacks, `this`, default values, thrown errors, and side-effect timing.
+
+### TypeScript Notes
+- Treat exported function signatures, generics, overloads, DTOs, and public types as compatibility contracts.
+
+### React Notes
+- Props/callback signatures, hooks, loaders/actions, router contracts, and context APIs may be public boundaries.
+
+### Vue Notes
+- Props/emits, composable returns, Pinia actions, route contracts, and injection keys may be public boundaries.
+
+### Frontend-Craft Adaptation
+- Prefer explicit, testable dependencies. Command objects earn their cost only when state/lifecycle such as undo, queue, retry, or audit justifies them.
+
+### Example Transformation
+Before: an immutable account ID exposes `setAccountId`. After: require it at creation and expose only a getter/read-only field.
+
+## RF-REPLACE-CONSTRUCTOR-WITH-FACTORY-FUNCTION — Replace Constructor with Factory Function
+
+### Intent
+Use a named factory when construction syntax cannot express selection, normalization, caching, or intent clearly.
+
+### Typical Signals
+- Creation needs a meaningful name, subtype/strategy choice, normalization, or controlled instance reuse.
+
+### Avoid When
+- Avoid adding a factory when `new` is already clear and no creation policy exists.
+
+### Preconditions
+- Current observable behavior and affected callers are understood.
+- The target scope is inside a declared diff budget and can be verified after this one primary transformation.
+
+### Mechanics
+1. Create a factory that initially delegates to the constructor.
+2. Migrate call sites incrementally.
+3. Move creation policy behind the factory only as needed.
+4. Restrict direct construction only when the abstraction benefits.
+
+### Behavior-Preservation Checkpoints
+- Compare inputs, outputs, exceptions, side effects, ordering, and public contracts before/after the step.
+- For frontend code, also check UI state, events, focus, network behavior, lifecycle/state transitions, and relevant identity semantics.
+
+### Related Code Smells
+- No single code smell required; select from concrete structural evidence.
+
+### Composes Well With
+- Combine only with a separately justified next transformation; no fixed sequence is required.
+
+### JavaScript Notes
+- Preserve arity-sensitive callbacks, `this`, default values, thrown errors, and side-effect timing.
+
+### TypeScript Notes
+- Treat exported function signatures, generics, overloads, DTOs, and public types as compatibility contracts.
+
+### React Notes
+- Props/callback signatures, hooks, loaders/actions, router contracts, and context APIs may be public boundaries.
+
+### Vue Notes
+- Props/emits, composable returns, Pinia actions, route contracts, and injection keys may be public boundaries.
+
+### Frontend-Craft Adaptation
+- Prefer explicit, testable dependencies. Command objects earn their cost only when state/lifecycle such as undo, queue, retry, or audit justifies them.
+
+### Example Transformation
+Before: `new Client(config, "readonly")` becomes `createReadonlyClient(config)` when the factory captures real creation policy.
+
+## RF-REPLACE-FUNCTION-WITH-COMMAND — Replace Function with Command
+
+### Intent
+Represent a complex operation as an object/context when it benefits from state, lifecycle, undo, queueing, retry, audit, or staged calculation.
+
+### Typical Signals
+- A function carries many temporaries or needs a reusable execution context.
+
+### Avoid When
+- Do not introduce Command objects for simple pure calculations; classes are not inherently superior to functions.
+
+### Preconditions
+- Current observable behavior and affected callers are understood.
+- The target scope is inside a declared diff budget and can be verified after this one primary transformation.
+
+### Mechanics
+1. Create a command/context that captures inputs.
+2. Move the function body into an execute/calculate operation.
+3. Extract internal steps/state only when they clarify the lifecycle.
+4. Migrate callers and preserve result/error semantics.
+
+### Behavior-Preservation Checkpoints
+- Compare inputs, outputs, exceptions, side effects, ordering, and public contracts before/after the step.
+- For frontend code, also check UI state, events, focus, network behavior, lifecycle/state transitions, and relevant identity semantics.
+
+### Related Code Smells
+- `SMELL-LONG-FUNCTION`
+
+### Composes Well With
+- Combine only with a separately justified next transformation; no fixed sequence is required.
+
+### JavaScript Notes
+- Preserve arity-sensitive callbacks, `this`, default values, thrown errors, and side-effect timing.
+
+### TypeScript Notes
+- Treat exported function signatures, generics, overloads, DTOs, and public types as compatibility contracts.
+
+### React Notes
+- Props/callback signatures, hooks, loaders/actions, router contracts, and context APIs may be public boundaries.
+
+### Vue Notes
+- Props/emits, composable returns, Pinia actions, route contracts, and injection keys may be public boundaries.
+
+### Frontend-Craft Adaptation
+- Prefer explicit, testable dependencies. Command objects earn their cost only when state/lifecycle such as undo, queue, retry, or audit justifies them.
+
+### Example Transformation
+Before: a complex upload function manages retry, progress, cancellation, and audit state. After: an UploadCommand/session object owns that lifecycle.
+
+## RF-REPLACE-COMMAND-WITH-FUNCTION — Replace Command with Function
+
+### Intent
+Collapse a command object to a function when its state/lifecycle no longer justifies the extra abstraction.
+
+### Typical Signals
+- A command has one execute method, trivial fields, and no meaningful lifecycle or reuse.
+
+### Avoid When
+- Keep commands that genuinely support state, undo, queueing, retry, auditing, or complex staged work.
+
+### Preconditions
+- Current observable behavior and affected callers are understood.
+- The target scope is inside a declared diff budget and can be verified after this one primary transformation.
+
+### Mechanics
+1. Inline command helpers until the operation is simple.
+2. Convert captured fields to function parameters.
+3. Replace construction + execute with a function call.
+4. Remove the command after callers migrate.
+
+### Behavior-Preservation Checkpoints
+- Compare inputs, outputs, exceptions, side effects, ordering, and public contracts before/after the step.
+- For frontend code, also check UI state, events, focus, network behavior, lifecycle/state transitions, and relevant identity semantics.
+
+### Related Code Smells
+- No single code smell required; select from concrete structural evidence.
+
+### Composes Well With
+- Combine only with a separately justified next transformation; no fixed sequence is required.
+
+### JavaScript Notes
+- Preserve arity-sensitive callbacks, `this`, default values, thrown errors, and side-effect timing.
+
+### TypeScript Notes
+- Treat exported function signatures, generics, overloads, DTOs, and public types as compatibility contracts.
+
+### React Notes
+- Props/callback signatures, hooks, loaders/actions, router contracts, and context APIs may be public boundaries.
+
+### Vue Notes
+- Props/emits, composable returns, Pinia actions, route contracts, and injection keys may be public boundaries.
+
+### Frontend-Craft Adaptation
+- Prefer explicit, testable dependencies. Command objects earn their cost only when state/lifecycle such as undo, queue, retry, or audit justifies them.
+
+### Example Transformation
+Before: a one-shot `TitleFormatterCommand` only stores one string then returns a formatted title. After: use `formatTitle(value)`.

package/skills/fec-refactoring-catalog/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: fec-refactoring-catalog
+description: Use when selecting or composing behavior-preserving refactoring techniques after structural evidence is known, especially when multiple candidate transformations, preconditions, or ordering choices must be compared.
+---
+
+# Refactoring Catalog Selection
+
+## Overview
+Use the complete catalog as a decision aid, not as a list of automatic recipes. Select the smallest technique whose preconditions fit the evidence and behavior contract.
+
+## Workflow
+1. Locate the standard technique in [the catalog index](references/catalog-index.md).
+2. If starting from a smell or symptom, use [the selection guide](references/selection-guide.md) to compare causes and alternatives.
+3. If several transformations are needed, use [the composition guide](references/composition-guide.md) to order only the prerequisites that fit the current code.
+4. Load the referenced family detail only when the technique is selected.
+
+## Selection Rules
+- A smell can have several valid candidates; determine the actual cause first.
+- Prefer reversible, local transformations over broad redesign.
+- Check public API, routing, state ownership, async/lifecycle, persistence, and SSR boundaries before execution.
+- Treat composition edges as conditional relationships, never mandatory pipelines.
+
+## Quick Reference
+| Need | Reference |
+| --- | --- |
+| All 61 techniques | [Catalog index](references/catalog-index.md) |
+| Choose by symptom/cause | [Selection guide](references/selection-guide.md) |
+| Order related techniques | [Composition guide](references/composition-guide.md) |

package/skills/fec-refactoring-catalog/references/catalog-index.md

@@ -0,0 +1,99 @@
+# Refactoring Catalog Index
+
+The 61 stable IDs preserve the supplied Chapters 6–12 catalog. Detailed mechanics live in family references and are loaded only when needed.
+
+## Functions — 11
+
+| ID | Standard Name | Family | Detail |
+| --- | --- | --- | --- |
+| `RF-EXTRACT-FUNCTION` | Extract Function | `functions` | [Detail](../../fec-refactoring-functions/references/function-refactorings.md) |
+| `RF-INLINE-FUNCTION` | Inline Function | `functions` | [Detail](../../fec-refactoring-functions/references/function-refactorings.md) |
+| `RF-EXTRACT-VARIABLE` | Extract Variable | `functions` | [Detail](../../fec-refactoring-functions/references/function-refactorings.md) |
+| `RF-INLINE-VARIABLE` | Inline Variable | `functions` | [Detail](../../fec-refactoring-functions/references/function-refactorings.md) |
+| `RF-CHANGE-FUNCTION-DECLARATION` | Change Function Declaration | `functions` | [Detail](../../fec-refactoring-functions/references/function-refactorings.md) |
+| `RF-ENCAPSULATE-VARIABLE` | Encapsulate Variable | `functions` | [Detail](../../fec-refactoring-functions/references/function-refactorings.md) |
+| `RF-RENAME-VARIABLE` | Rename Variable | `functions` | [Detail](../../fec-refactoring-functions/references/function-refactorings.md) |
+| `RF-INTRODUCE-PARAMETER-OBJECT` | Introduce Parameter Object | `functions` | [Detail](../../fec-refactoring-functions/references/function-refactorings.md) |
+| `RF-COMBINE-FUNCTIONS-INTO-CLASS` | Combine Functions into Class | `functions` | [Detail](../../fec-refactoring-functions/references/function-refactorings.md) |
+| `RF-COMBINE-FUNCTIONS-INTO-TRANSFORM` | Combine Functions into Transform | `functions` | [Detail](../../fec-refactoring-functions/references/function-refactorings.md) |
+| `RF-SPLIT-PHASE` | Split Phase | `functions` | [Detail](../../fec-refactoring-functions/references/function-refactorings.md) |
+
+## Encapsulation — 9
+
+| ID | Standard Name | Family | Detail |
+| --- | --- | --- | --- |
+| `RF-ENCAPSULATE-RECORD` | Encapsulate Record | `encapsulation` | [Detail](../../fec-refactoring-encapsulation/references/encapsulation-refactorings.md) |
+| `RF-ENCAPSULATE-COLLECTION` | Encapsulate Collection | `encapsulation` | [Detail](../../fec-refactoring-encapsulation/references/encapsulation-refactorings.md) |
+| `RF-REPLACE-PRIMITIVE-WITH-OBJECT` | Replace Primitive with Object | `encapsulation` | [Detail](../../fec-refactoring-encapsulation/references/encapsulation-refactorings.md) |
+| `RF-REPLACE-TEMP-WITH-QUERY` | Replace Temp with Query | `encapsulation` | [Detail](../../fec-refactoring-encapsulation/references/encapsulation-refactorings.md) |
+| `RF-EXTRACT-CLASS` | Extract Class | `encapsulation` | [Detail](../../fec-refactoring-encapsulation/references/encapsulation-refactorings.md) |
+| `RF-INLINE-CLASS` | Inline Class | `encapsulation` | [Detail](../../fec-refactoring-encapsulation/references/encapsulation-refactorings.md) |
+| `RF-HIDE-DELEGATE` | Hide Delegate | `encapsulation` | [Detail](../../fec-refactoring-encapsulation/references/encapsulation-refactorings.md) |
+| `RF-REMOVE-MIDDLE-MAN` | Remove Middle Man | `encapsulation` | [Detail](../../fec-refactoring-encapsulation/references/encapsulation-refactorings.md) |
+| `RF-SUBSTITUTE-ALGORITHM` | Substitute Algorithm | `encapsulation` | [Detail](../../fec-refactoring-encapsulation/references/encapsulation-refactorings.md) |
+
+## Moving Features — 9
+
+| ID | Standard Name | Family | Detail |
+| --- | --- | --- | --- |
+| `RF-MOVE-FUNCTION` | Move Function | `move-features` | [Detail](../../fec-refactoring-move-features/references/moving-refactorings.md) |
+| `RF-MOVE-FIELD` | Move Field | `move-features` | [Detail](../../fec-refactoring-move-features/references/moving-refactorings.md) |
+| `RF-MOVE-STATEMENTS-INTO-FUNCTION` | Move Statements into Function | `move-features` | [Detail](../../fec-refactoring-move-features/references/moving-refactorings.md) |
+| `RF-MOVE-STATEMENTS-TO-CALLERS` | Move Statements to Callers | `move-features` | [Detail](../../fec-refactoring-move-features/references/moving-refactorings.md) |
+| `RF-REPLACE-INLINE-CODE-WITH-FUNCTION-CALL` | Replace Inline Code with Function Call | `move-features` | [Detail](../../fec-refactoring-move-features/references/moving-refactorings.md) |
+| `RF-SLIDE-STATEMENTS` | Slide Statements | `move-features` | [Detail](../../fec-refactoring-move-features/references/moving-refactorings.md) |
+| `RF-SPLIT-LOOP` | Split Loop | `move-features` | [Detail](../../fec-refactoring-move-features/references/moving-refactorings.md) |
+| `RF-REPLACE-LOOP-WITH-PIPELINE` | Replace Loop with Pipeline | `move-features` | [Detail](../../fec-refactoring-move-features/references/moving-refactorings.md) |
+| `RF-REMOVE-DEAD-CODE` | Remove Dead Code | `move-features` | [Detail](../../fec-refactoring-move-features/references/moving-refactorings.md) |
+
+## Data — 5
+
+| ID | Standard Name | Family | Detail |
+| --- | --- | --- | --- |
+| `RF-SPLIT-VARIABLE` | Split Variable | `data` | [Detail](../../fec-refactoring-data/references/data-refactorings.md) |
+| `RF-RENAME-FIELD` | Rename Field | `data` | [Detail](../../fec-refactoring-data/references/data-refactorings.md) |
+| `RF-REPLACE-DERIVED-VARIABLE-WITH-QUERY` | Replace Derived Variable with Query | `data` | [Detail](../../fec-refactoring-data/references/data-refactorings.md) |
+| `RF-CHANGE-REFERENCE-TO-VALUE` | Change Reference to Value | `data` | [Detail](../../fec-refactoring-data/references/data-refactorings.md) |
+| `RF-CHANGE-VALUE-TO-REFERENCE` | Change Value to Reference | `data` | [Detail](../../fec-refactoring-data/references/data-refactorings.md) |
+
+## Conditional Logic — 6
+
+| ID | Standard Name | Family | Detail |
+| --- | --- | --- | --- |
+| `RF-DECOMPOSE-CONDITIONAL` | Decompose Conditional | `control` | [Detail](../../fec-refactoring-control/references/conditional-refactorings.md) |
+| `RF-CONSOLIDATE-CONDITIONAL-EXPRESSION` | Consolidate Conditional Expression | `control` | [Detail](../../fec-refactoring-control/references/conditional-refactorings.md) |
+| `RF-REPLACE-NESTED-CONDITIONAL-WITH-GUARD-CLAUSES` | Replace Nested Conditional with Guard Clauses | `control` | [Detail](../../fec-refactoring-control/references/conditional-refactorings.md) |
+| `RF-REPLACE-CONDITIONAL-WITH-POLYMORPHISM` | Replace Conditional with Polymorphism | `control` | [Detail](../../fec-refactoring-control/references/conditional-refactorings.md) |
+| `RF-INTRODUCE-SPECIAL-CASE` | Introduce Special Case | `control` | [Detail](../../fec-refactoring-control/references/conditional-refactorings.md) |
+| `RF-INTRODUCE-ASSERTION` | Introduce Assertion | `control` | [Detail](../../fec-refactoring-control/references/conditional-refactorings.md) |
+
+## API — 10
+
+| ID | Standard Name | Family | Detail |
+| --- | --- | --- | --- |
+| `RF-SEPARATE-QUERY-FROM-MODIFIER` | Separate Query from Modifier | `api` | [Detail](../../fec-refactoring-api/references/api-refactorings.md) |
+| `RF-PARAMETERIZE-FUNCTION` | Parameterize Function | `api` | [Detail](../../fec-refactoring-api/references/api-refactorings.md) |
+| `RF-REMOVE-FLAG-ARGUMENT` | Remove Flag Argument | `api` | [Detail](../../fec-refactoring-api/references/api-refactorings.md) |
+| `RF-PRESERVE-WHOLE-OBJECT` | Preserve Whole Object | `api` | [Detail](../../fec-refactoring-api/references/api-refactorings.md) |
+| `RF-REPLACE-PARAMETER-WITH-QUERY` | Replace Parameter with Query | `api` | [Detail](../../fec-refactoring-api/references/api-refactorings.md) |
+| `RF-REPLACE-QUERY-WITH-PARAMETER` | Replace Query with Parameter | `api` | [Detail](../../fec-refactoring-api/references/api-refactorings.md) |
+| `RF-REMOVE-SETTING-METHOD` | Remove Setting Method | `api` | [Detail](../../fec-refactoring-api/references/api-refactorings.md) |
+| `RF-REPLACE-CONSTRUCTOR-WITH-FACTORY-FUNCTION` | Replace Constructor with Factory Function | `api` | [Detail](../../fec-refactoring-api/references/api-refactorings.md) |
+| `RF-REPLACE-FUNCTION-WITH-COMMAND` | Replace Function with Command | `api` | [Detail](../../fec-refactoring-api/references/api-refactorings.md) |
+| `RF-REPLACE-COMMAND-WITH-FUNCTION` | Replace Command with Function | `api` | [Detail](../../fec-refactoring-api/references/api-refactorings.md) |
+
+## Inheritance — 11
+
+| ID | Standard Name | Family | Detail |
+| --- | --- | --- | --- |
+| `RF-PULL-UP-METHOD` | Pull Up Method | `inheritance` | [Detail](../../fec-refactoring-inheritance/references/inheritance-refactorings.md) |
+| `RF-PULL-UP-FIELD` | Pull Up Field | `inheritance` | [Detail](../../fec-refactoring-inheritance/references/inheritance-refactorings.md) |
+| `RF-PULL-UP-CONSTRUCTOR-BODY` | Pull Up Constructor Body | `inheritance` | [Detail](../../fec-refactoring-inheritance/references/inheritance-refactorings.md) |
+| `RF-PUSH-DOWN-METHOD` | Push Down Method | `inheritance` | [Detail](../../fec-refactoring-inheritance/references/inheritance-refactorings.md) |
+| `RF-PUSH-DOWN-FIELD` | Push Down Field | `inheritance` | [Detail](../../fec-refactoring-inheritance/references/inheritance-refactorings.md) |
+| `RF-REPLACE-TYPE-CODE-WITH-SUBCLASSES` | Replace Type Code with Subclasses | `inheritance` | [Detail](../../fec-refactoring-inheritance/references/inheritance-refactorings.md) |
+| `RF-REMOVE-SUBCLASS` | Remove Subclass | `inheritance` | [Detail](../../fec-refactoring-inheritance/references/inheritance-refactorings.md) |
+| `RF-EXTRACT-SUPERCLASS` | Extract Superclass | `inheritance` | [Detail](../../fec-refactoring-inheritance/references/inheritance-refactorings.md) |
+| `RF-COLLAPSE-HIERARCHY` | Collapse Hierarchy | `inheritance` | [Detail](../../fec-refactoring-inheritance/references/inheritance-refactorings.md) |
+| `RF-REPLACE-SUBCLASS-WITH-DELEGATE` | Replace Subclass with Delegate | `inheritance` | [Detail](../../fec-refactoring-inheritance/references/inheritance-refactorings.md) |
+| `RF-REPLACE-SUPERCLASS-WITH-DELEGATE` | Replace Superclass with Delegate | `inheritance` | [Detail](../../fec-refactoring-inheritance/references/inheritance-refactorings.md) |