Skip to content

CONCEPTS.md

Latest commit

 

History

History
567 lines (468 loc) · 44.3 KB

CONCEPTS.md

File metadata and controls

567 lines (468 loc) · 44.3 KB

CLAUDEDB - Concept Map

Purpose: Concept → multi-step implementation path Rule: Each concept links to a learning path (basic → advanced)

Reactium Concepts

Component Development

Learning Path:

  1. Reactium: Component System - Basic component creation
  2. hookableComponent: Overview - Replaceable components concept
  3. hookableComponent: Component Registry - Registry architecture
  4. hookableComponent: Registration Pattern - How to register
  5. hookableComponent: Usage Patterns - How to use
  6. Patterns: Domain-Driven Organization - Best practices
  7. Gotchas: Component Registration Timing - Common issues

Related: CLI Tools, DDD Structure, Hookable Components, Component Registry

Responsive Design & Breakpoints

Learning Path:

  1. Window/Breakpoint: Architecture Overview - System overview
  2. Window/Breakpoint: SSR-Safe Access - Safe window/document access
  3. Window/Breakpoint: Breakpoint System - Default configuration
  4. Window/Breakpoint: useWindowSize Hook - Reactive dimensions
  5. Window/Breakpoint: Responsive Patterns - Real-world usage
  6. Window/Breakpoint: SCSS Integration - SCSS synchronization
  7. Window/Breakpoint: Best Practices - Guidelines
  8. Window/Breakpoint: Common Gotchas - Avoid mistakes

Related: SCSS breakpoints, Media queries, Mobile-first design, SSR compatibility

Utility Helpers (cxFactory & SplitParts)

Learning Path:

  1. Utility Helpers: Overview - Purpose and use cases
  2. Utility Helpers: cxFactory Overview - BEM-style classname generation
  3. Utility Helpers: cxFactory Usage Patterns - Real-world component examples
  4. Utility Helpers: SplitParts Overview - Token-based templates
  5. Utility Helpers: SplitParts Usage Patterns - i18n and dynamic content
  6. Utility Helpers: Comparison with Alternatives - When to use each
  7. Utility Helpers: Best Practices - Naming conventions, React integration
  8. Utility Helpers: Common Gotchas - Avoid mistakes

Related: BEM naming, CSS Modules, i18n, template literals, classnames library

Routing System

Learning Path:

  1. Routing System: Overview - Complete architecture
  2. Routing System: File Discovery & Manifest Generation - Auto-discovery
  3. Routing System: Route Registration Lifecycle - Initialization
  4. Routing System: The register-route Hook - Hook-based modification
  5. Routing System: Transition State Machine - Page animations
  6. Routing System: Code Splitting Patterns - Performance
  7. Routing System: loadState Pattern - Data loading
  8. Routing System: Best Practices - Patterns
  9. Routing System: Common Gotchas - Avoid mistakes

Related: Navigation, handleId, transitionState, React Router, Code splitting

State Management

Learning Path:

  1. Reactium: State Management - Overview of options
  2. Reactium: useSyncState - Local state
  3. Reactium: Handles - Shared state
  4. Reactium: Global State - App-wide state
  5. Patterns: Handle-Based Shared State - Best practices
  6. Gotchas: useSyncState Is Not useState - Common mistakes
  7. Gotchas: useHandle vs useSyncHandle - Subscription patterns

Related: Observable state, Reactive programming, Pulse

Persistent Preferences (LocalStorage)

Learning Path:

  1. Prefs System: Architecture Overview - What is Prefs
  2. Prefs System: Core API - get/set/clear/create methods
  3. Prefs System: Common Patterns - Real-world usage
  4. Prefs System: Best Practices - Do's and don'ts
  5. Prefs System: Common Gotchas - NOT reactive, NOT cross-tab
  6. Prefs System: TypeScript Usage - Type-safe preferences
  7. Prefs System: Comparison - When to use

Related: LocalStorage, User preferences, Session persistence, ReactiumSyncState (NOT the same)

Hook System (Reactium)

Learning Path:

  1. Reactium: Hook System - Basic hooks
  2. Reactium: Hook Registration - Register/execute
  3. Reactium: Common Framework Hooks - Lifecycle
  4. Hook Domains Deep Dive - Definition & purpose
  5. Hook Domains: When to Use - Use cases
  6. Hook Domains: API Reference - Functions
  7. Hook Domains: Best Practices - Patterns
  8. Patterns: Hook-Based Plugin Architecture - Architecture
  9. Gotchas: Hook Registration Must Be in IIFE - Common mistakes

Related: Events, Lifecycle, Plugins, Priority, Domains

Plugin System (Reactium)

Learning Path:

  1. Reactium: Plugin System - Overview
  2. Reactium: Plugin Lifecycle - Initialization
  3. Reactium: Creating a Plugin - Implementation
  4. Patterns: Hook-Based Plugin Architecture - Architecture
  5. Plugin CLI Extensibility: Overview - Custom install/publish workflows
  6. Plugin CLI Extensibility: arcli-install.js Pattern - Post-install setup
  7. Plugin CLI Extensibility: arcli-publish.js Pattern - Pre-publish build
  8. Plugin CLI Extensibility: Common Use Cases - Real patterns
  9. Plugin CLI Extensibility: Best Practices - Guidelines
  10. Plugin CLI Extensibility: Common Gotchas - Avoid mistakes

Related: Hooks, DDD, Components, Priority, CLI Extensibility, ActionSequence

ActionSequence Pattern (Sequential Workflows)

Learning Path:

  1. ActionSequence: Overview - What is ActionSequence
  2. ActionSequence: Core API - Function signature, parameters
  3. ActionSequence: Action Function Signature - Parameter structure
  4. ActionSequence: Error Handling Patterns - Reject, exit, conditional
  5. ActionSequence: Pattern 1 - Generator Wrapper - CLI standard
  6. ActionSequence: Pattern 2 - Middleware Registration - Priority-based
  7. ActionSequence: Pattern 3 - Plugin Post-Install - Dynamic actions
  8. ActionSequence: Pattern 4 - Multi-Step Workflow - User feedback
  9. ActionSequence: Best Practices - Naming, spinner, options
  10. ActionSequence: Common Gotchas - Sequential not parallel
  11. ActionSequence: Comparison - vs Promise.all, async/await, Hooks

Related: CLI commands, Middleware system, Plugin lifecycle, Promise chains, Error propagation

CLI Command System

Learning Path:

  1. CLI Command System: Overview - What is ARCLI
  2. CLI: Command Discovery Locations - Multi-location discovery
  3. CLI: Two-Phase Initialization - Performance optimization
  4. CLI: Command Module Structure - Required exports
  5. CLI: Command Structure Pattern - Standard anatomy
  6. CLI: Hook-Driven Extensibility - Global & command hooks
  7. CLI: ActionSequence Pattern - Multi-step generation
  8. ActionSequence: Overview - Complete ActionSequence docs
  9. CLI: Real-World Usage Patterns - Project commands, NPM packages, extending core
  10. CLI: Best Practices - Naming, organization, error handling
  11. CLI: Common Gotchas - Discovery issues, path problems

Related: Commander.js, Globby, Hook system, DDD extensibility, Tooling, ActionSequence

Zone System

Learning Path:

  1. Zone System Deep Dive - Complete architecture
  2. Zone System Quick Reference - API reference
  3. Zone System: Core Architecture - How it works
  4. Zone System: Filters, Mappers, Sorters - Transformations
  5. Zone System: Common Patterns - Use cases
  6. Zone System: Performance - Optimization

Related: Dynamic UI, Component composition, Registry

Registry System

Learning Path:

  1. Registry System: Overview - What is Registry
  2. Registry System: When Registry Is Used - Framework usage patterns
  3. Registry System: Registry Modes - CLEAN vs HISTORY
  4. Registry System: Core API - Methods & properties
  5. Registry System: Real-World Usage Patterns - Implementation examples
  6. Registry System: Best Practices - Do's and don'ts
  7. Registry System: Common Gotchas - Avoid mistakes

Related: Priority system, Plugin extensibility, Middleware, Routing, Webpack

hookableComponent System

Learning Path:

  1. hookableComponent: Overview - Replaceable components concept
  2. hookableComponent: Component Registry - ReactiumSyncState singleton
  3. hookableComponent: useHookComponent Hook - Retrieval mechanism
  4. hookableComponent: hookableComponent Factory - Wrapper pattern
  5. hookableComponent: Registration Pattern - Core & plugin registration
  6. hookableComponent: Component Replacement Strategy - Override patterns
  7. hookableComponent: Integration with Routing - String component resolution
  8. hookableComponent: Real-World Use Cases - Theming, A/B testing, feature flags
  9. hookableComponent: Best Practices - Do's and don'ts
  10. hookableComponent: Common Gotchas - Avoid mistakes (priority bug, non-reactive updates)

Related: Component Registry, Component.register, useHookComponent, RegisteredComponents, AppParent, NotFound, Router

Component Event System

Learning Path:

  1. ComponentEvent System: Overview - Event foundation for framework
  2. ComponentEvent System: Core Architecture - ComponentEvent class design
  3. ComponentEvent System: Payload Flattening - Convenient event property access
  4. ComponentEvent System: Integration with ReactiumSyncState - State event lifecycle
  5. ComponentEvent System: useEventEffect Hook - React subscription pattern
  6. ComponentEvent System: Real-World Usage Patterns - Practical examples
  7. ComponentEvent System: Best Practices - Do's and don'ts
  8. ComponentEvent System: Common Gotchas - Avoid mistakes

Related: ReactiumSyncState events, Handle system, useEventEffect, Global State, Component registry communication

ReactiumSyncState

Learning Path:

  1. ReactiumSyncState: Core Concept - Observable state foundation
  2. ReactiumSyncState: Architecture Overview - Internal structure
  3. ReactiumSyncState: Event System - Event types and lifecycle
  4. ReactiumSyncState: Core API - get, set, del, insert methods
  5. ReactiumSyncState: Smart Merging System - Merge behavior and customization
  6. ReactiumSyncState: Integration with Framework - useSyncState, Global State, Handles
  7. ReactiumSyncState: Real-World Examples - Component state, routing sync
  8. ReactiumSyncState: Best Practices - Choosing events, namespacing, cleanup
  9. ReactiumSyncState: Common Gotchas - Array merging, reset(), direct mutation

Related: useSyncState, Component registry, Handle system, Global State, ComponentEvent

Handle System

Learning Path:

  1. Handle System: Overview - Global component communication
  2. Handle System: Core Architecture - Handle registry singleton
  3. Handle System: React Hook Integration - Provider and consumer patterns
  4. Handle System: useRegisterHandle - Provider pattern
  5. Handle System: useHandle vs useSyncHandle - Consumer patterns (critical difference)
  6. Handle System: useRegisterSyncHandle - Observable state provider
  7. Handle System: useSelectHandle - Performance optimization
  8. Handle System: Real-World Patterns - Global state, routing, plugin APIs
  9. Handle System: Best Practices - Naming, types, documentation
  10. Handle System: Common Gotchas - useHandle vs useSyncHandle confusion

Related: ReactiumSyncState, Global state, Plugin communication, Route data, object-path addressing

Style Partial System

Learning Path:

  1. Style Partial System: Overview - Auto-discovery and aggregation
  2. Style Partial System: Priority Levels - Atomic Design hierarchy
  3. Style Partial System: Naming Patterns - Directory-based vs DDD-based
  4. Style Partial System: File Discovery Process - Registry, hooks, sorting
  5. Style Partial System: Real-World Usage - Component styles, variables, plugins
  6. Style Partial System: Compilation Workflow - Build process and watch mode
  7. Style Partial System: Best Practices - Naming, priorities, organization
  8. Style Partial System: Common Gotchas - Priority confusion, workspace paths

Related: SCSS, Gulp build system, Registry pattern, DDD structure, Atomic Design, Plugin styles

AppContext Provider System

Learning Path:

  1. AppContext: Overview - React Context integration
  2. AppContext: Core Architecture - Registry pattern for providers
  3. AppContext: Lifecycle Integration - Hook timeline and timing
  4. AppContext: Registration API - How to register providers
  5. AppContext: Nesting Order & Priority - Provider wrapping hierarchy
  6. AppContext: Common Use Cases - Apollo, Redux, Material-UI
  7. AppContext: Best Practices - Initialize deps, naming, priority
  8. AppContext: Common Gotchas - Name collisions, priority confusion

Related: React Context, Apollo Client, Redux, Material-UI, Plugin integration, Priority system

Component Binding System

Learning Path:

  1. Component Binding: Overview - Multi-root React architecture
  2. Component Binding: Lifecycle Integration - Hook timeline
  3. Component Binding: data-reactium-bind Attribute - Bind point pattern
  4. Component Binding: React 18 Multi-Root Pattern - Root management
  5. Component Binding: Adding Custom Bind Points - Server and client registration
  6. Component Binding: Real-World Use Cases - Dev tools, admin UI, widgets
  7. Component Binding: SSR Hydration Pattern - Server and client flow
  8. Component Binding: Best Practices - Use zones vs bind points
  9. Component Binding: Common Gotchas - Timing, registration, discovery

Related: React 18 roots, hookableComponent, AppContexts, Zone system, SSR, Plugin UI injection

Manifest System

Learning Path:

  1. Reactium: Manifest System - What it is
  2. Reactium: DDD Structure - File naming
  3. Reactium: Manifest Regeneration - How to update
  4. Gotchas: The Manifest is Sacred - Critical rules

Related: Auto-discovery, Convention over configuration, Build system

Build System

Learning Path:

  1. Reactium: Build System - Overview
  2. Reactium: Build Process - How it works
  3. ReactiumWebpack SDK - Webpack customization
  4. ReactiumWebpack: Architecture - SDK design
  5. ReactiumWebpack: Core Methods - API reference
  6. ReactiumWebpack: Hook System - Extensibility
  7. ReactiumWebpack: Migration Guide - From old patterns
  8. Gotchas: Build System - Common issues

Related: Gulp, Webpack, Babel, HMR, Manifest, reactium-webpack.js

Actinium Concepts

Real-Time Communication (Socket.io)

Learning Path:

  1. Actinium IO: Architecture Overview - What is Actinium IO
  2. Actinium IO: Server-Side Architecture - Initialization and configuration
  3. Actinium IO: Client Registry Pattern - Tracking connected clients
  4. Actinium IO: Connection Lifecycle Hooks - io.config, io.init, io.connection, io.disconnecting
  5. Actinium IO: Browser-Side Integration - Client setup and connection
  6. Actinium IO: Real-World Patterns - Broadcasting, rooms, targeting
  7. Actinium IO: Hook Integration Patterns - CORS, auth, presence
  8. Actinium IO: Best Practices - Validation, rooms, authentication
  9. Actinium IO: Common Gotchas - Path mismatch, auto-connect, CORS

Related: WebSocket, Parse LiveQuery, Real-time updates, Event broadcasting, Presence tracking

Collection Registration & Schema Management

Learning Path:

  1. Collection Registration: Overview - What is Collection Registration
  2. Collection Registration: Core API - API signature and parameters
  3. Collection Registration: CLP Generation Mechanism - How capabilities map to CLPs
  4. Collection Registration: Registration Pattern - Real-world examples
  5. Collection Registration: Schema Field Management - Add/modify/delete fields
  6. Collection Registration: Hook Integration - Customization hooks
  7. Collection Registration: Dynamic CLP Updates - Auto-reload on capability changes
  8. Collection Registration: Best Practices - Index strategy, capability ordering
  9. Collection Registration: Common Gotchas - Field type changes, public settings
  10. Collection Registration: Migration Patterns - Schema evolution

Related: Parse Server, Capabilities, Cloud Functions, ACL, Indexes, Schema evolution

Express Settings System (Actinium)

Learning Path:

  1. Express Settings: Overview - What is Actinium.Exp
  2. Express Settings: Architecture - Initialization sequence (before middleware)
  3. Express Settings: Core Implementation - How it works (app.set wrapper)
  4. Express Settings: Configuration - ENV.EXPRESS_OPTIONS, runtime, hook patterns
  5. Express Settings: Common Settings Reference - View engine, trust proxy, security
  6. Express Settings: Hook Integration - Dynamic config via init hook
  7. Express Settings: Real-World Usage Patterns - Load balancers, templates, environments
  8. Express Settings: Integration with Middleware System - Timing requirements
  9. Express Settings: Best Practices - Trust proxy, security, environment config
  10. Express Settings: Common Gotchas - Settings too late, JSON parsing, trust proxy

Related: Express, Middleware system, init hook, ENV.EXPRESS_OPTIONS, View engines, Load balancers

Middleware System (Actinium)

Learning Path:

  1. Actinium Middleware: Architecture Overview - System design
  2. Actinium Middleware: Discovery Pattern (DDD) - File discovery via glob
  3. Actinium Middleware: Registration API - register, registerHook, replace, unregister
  4. Actinium Middleware: Priority-Based Ordering - Execution order
  5. Actinium Middleware: Lifecycle Integration - Bootstrap sequence
  6. Actinium Middleware: Common Patterns - NPM wrapper, router-based, conditional, hook-driven, async
  7. Actinium Middleware: Real-World Examples - Parse Server, CORS, static, body-parser
  8. Actinium Middleware: Best Practices - Priority strategy, promise returns, routing
  9. Actinium Middleware: Common Gotchas - Timing, replacement, hook access, priority confusion

Related: Express, Parse Server, Hook system, Plugin system, ENV.GLOB_MIDDLEWARE, ActionSequence

Plugin System (Actinium)

Learning Path:

  1. Actinium: Plugin System - Overview
  2. Actinium Quick Ref: Essential Plugin Structure - Basic structure
  3. Actinium: Plugin Discovery - How plugins load
  4. Actinium: Plugin Registration - Implementation
  5. Actinium: Plugin Gating - Cloud function protection
  6. Patterns: Plugin SDK Pattern - Best practices
  7. Patterns: Plugin Dependency Management - Dependencies
  8. Gotchas: Plugin Function Must Execute - Common mistakes

Related: Hooks, Cloud Functions, SDK pattern, Order/Priority

Hook System (Actinium)

Learning Path:

  1. Actinium: Hook System - Overview
  2. Actinium Quick Ref: Hook Registration Patterns - Basic usage
  3. Actinium Quick Ref: Common Lifecycle Hooks - Key hooks
  4. Hook Domains Deep Dive - Definition & purpose
  5. Hook Domains: Plugin Lifecycle Management - Primary use case
  6. Hook Domains: Best Practices - Patterns
  7. Patterns: Hook-Based Data Validation - Use cases

Related: Events, Lifecycle, beforeSave, afterSave, Priority, Domains

Cloud Functions

Learning Path:

  1. Cloud Functions: Overview - What are cloud functions
  2. Cloud Functions: Registration Pattern - Basic structure
  3. Cloud Functions: Request Object - req.params, req.user, req.master
  4. Cloud Functions: Security & Authorization - CloudRunOptions, MasterOptions
  5. Cloud Functions: CloudCapOptions - Capability-based escalation
  6. Cloud Functions: CloudHasCapabilities - Permission gates
  7. Cloud Functions: ACL Management - CloudACL, AclTargets
  8. Cloud Functions: Parameter Validation - Validation patterns
  9. Cloud Functions: Error Handling - Error patterns
  10. Cloud Functions: Hook Integration - beforeSave, afterSave triggers
  11. Cloud Functions: Testing Strategies - Manual testing
  12. Cloud Functions: Best Practices - Do's and don'ts
  13. Cloud Functions: Common Gotchas - Avoid mistakes

Related: API endpoints, Parse.Cloud.run, req.params, Capabilities, Master key, Session tokens, ACLs

Capabilities System

Learning Path:

  1. Actinium: Capabilities System - Complete guide
  2. Actinium Quick Ref: Capability Checking - Usage patterns
  3. Patterns: Capability-Based Authorization - Best practices
  4. Integration: Authentication - Integration

Related: Permissions, Roles, Authorization, CloudHasCapabilities, ACL

Database & Schema

Learning Path:

  1. Actinium Quick Ref: Database Schema Definition - Basic schema
  2. Actinium: Framework Architecture - Parse integration
  3. Patterns: Schema Initialization Pattern - Best practices
  4. Patterns: Hook-Based Data Validation - Validation
  5. Gotchas: Schema Changes Require Restart - Common issues

Related: Collections, Parse.Object, Query, MongoDB

Content Type System (CMS)

Learning Path:

  1. Content Type: Overview - What is the Type system
  2. Content Type: Type Definition Structure - Core properties
  3. Content Type: UUID Generation - Namespace-based UUIDs
  4. Content Type: Collection Name Generation - Auto-naming
  5. Content Type: Field Configuration - Field structure
  6. Content Type: Type CRUD Operations - Create/retrieve/update/delete
  7. Content Type: Schema Management - Automatic schema creation
  8. Content Type: Capabilities and Permissions - Security model
  9. Content Type: Hooks - type-saved, type-deleted, type-retrieved
  10. Content Type: Best Practices - Patterns to follow
  11. Content Type: Common Gotchas - Avoid mistakes

Related: Parse Schema, Collections, Capabilities, machineName, UUID v5, fieldTypes, regions

Pagination Strategies

Learning Path:

  1. Pagination: Overview - Three pagination patterns
  2. Pagination: Skip-Based Pagination - Framework default
  3. Pagination: Load-All Pattern - Batch processing
  4. Pagination: Cursor-Based Pagination - Scalable pattern
  5. Pagination: Performance Comparison - When to use each
  6. Pagination: Best Practices - Choosing the right strategy
  7. Pagination: Common Gotchas - Avoid mistakes

Related: hookedQuery, Parse Query, skip(), limit(), greaterThan(), objectId, createdAt, MongoDB performance

Middleware

Learning Path:

  1. Actinium: Middleware System - Overview
  2. Patterns: Middleware Priority Pattern - Execution order
  3. Actinium: Framework Architecture - How it fits

Related: Express, HTTP, CORS, Body parsing, Priority

Initialization & Lifecycle

Learning Path:

  1. Actinium: Initialization Sequence - Complete sequence
  2. Actinium Quick Ref: Common Lifecycle Hooks - Key hooks
  3. Actinium: Framework Architecture - Design

Related: init, start, running, schema, install, activate

Integration Concepts

Full-Stack Data Flow

Learning Path:

  1. Integration: Data Flow Patterns - Overview
  2. Integration: Cloud Function Integration - Backend calls
  3. Routing System: loadState Pattern - Route data loading
  4. Routing System: Handle Persistence - State management
  5. Patterns: Static Method Data Loading - Best practices
  6. Patterns: Optimistic UI Updates - UX patterns

Related: Parse SDK, Cloud Functions, State management, Handles

Authentication

Learning Path:

  1. Integration: Authentication & Session Management - Complete guide
  2. Actinium: Capabilities System - Authorization
  3. Patterns: Capability-Based Authorization - Patterns
  4. Gotchas: Session Tokens - Common issues

Related: Parse.User, Login, Roles, Capabilities, Session management

Real-Time Communication

Learning Path:

  1. Integration: Real-Time Communication - Complete guide
  2. Integration: Parse Live Query Setup - Configuration
  3. Actinium: Framework Architecture - Server setup

Related: Live Query, WebSocket, Subscriptions, Parse queries

File Uploads

Learning Path:

  1. Integration: File Uploads - Complete guide
  2. Actinium: Framework Architecture - File handling

Related: Parse.File, Cloud Functions, Frontend forms

Deployment

Learning Path:

  1. Integration: Deployment - Production setup
  2. Environment Config: Architecture Overview - Configuration system
  3. Environment Config: Multi-Environment Workflow - Dev/staging/prod
  4. Environment Config: Docker Deployment - Container setup
  5. Environment Config: Best Practices - Security & deployment
  6. Integration: Development Workflow - Local dev
  7. Reactium: Build System - Build process

Related: Production, Environment variables, CORS, Build, Docker, TLS, Parse Server configuration

Environment Configuration

Learning Path:

  1. Environment Config: Architecture Overview - How config loads
  2. Environment Config: File Resolution - ACTINIUM_ENV_FILE/ID priority
  3. Environment Config: Merge Strategy - File + process.env
  4. Environment Config: PORT Resolution - Complex PORT logic
  5. Environment Config: Parse Server Configuration - Parse integration
  6. Environment Config: Security Configuration - Master key, TLS, IP whitelist
  7. Environment Config: Real-World Examples - Dev/staging/prod configs
  8. Environment Config: Common Gotchas - Troubleshooting

Related: Deployment, ACTINIUM_ENV_FILE, ACTINIUM_ENV_ID, DATABASE_URI, PORT, SERVER_URI, MASTER_KEY, TLS, Docker, Parse Server

Cross-Cutting Concepts

Priority & Execution Order

Learning Path:

  1. Actinium Quick Ref: Priority Constants - Constants
  2. Gotchas: Priority Numbers Are Counterintuitive - How it works
  3. Patterns: Middleware Priority Pattern - Use cases

Related: Hooks, Middleware, Plugins, Order

Convention Over Configuration

Learning Path:

  1. Reactium: DDD Structure - File naming
  2. Reactium: Manifest System - Auto-discovery
  3. Actinium: Plugin Discovery - Backend patterns
  4. Patterns: Domain-Driven Organization - Best practices

Related: Manifest, Auto-discovery, DDD, File patterns

Event-Driven Architecture

Learning Path:

  1. Reactium: Hook System - Frontend hooks
  2. Actinium: Hook System - Backend hooks
  3. Hook Domains Deep Dive - Advanced patterns
  4. Reactium: Pulse - Pub/sub
  5. Patterns: Hook-Based Plugin Architecture - Architecture

Related: Hooks, Events, Lifecycle, Plugins

Performance Optimization

Learning Path:

  1. Patterns: Performance Patterns - Overview
  2. Patterns: Code Splitting - Bundle size
  3. Patterns: Backend Caching - Caching
  4. Patterns: Pagination - Large datasets
  5. Patterns: Debounced Queries - API calls
  6. Zone System: Performance - Zone optimization

Related: Optimization, Caching, Code splitting, Lazy loading

Usage: Find concept → Follow learning path → Build understanding step-by-step Coverage: 32+ major framework concepts with multi-step learning paths