facebook/componentkit

Features

• Reusable UI Components - Builds interfaces by composing small, self-contained components rather than subclassing views.
• Component-Powered Collection Views - Renders collection views where each cell is generated by a pure, thread-safe model-to-component transform.
• UI Components - Breaks complex components into smaller, focused sub-components composed together for readability.
• View-Backed Components - Creates native view subclasses automatically and reuses views across component updates.
• Stack-Allocated Component Trees - Builds component trees on the stack using value semantics to minimize memory allocation overhead.
• Asynchronous Layout Calculation - Computes UI layout positions on background threads to prevent blocking user interaction.
• Component Controller Attachments - Provides a mechanism to attach persistent controllers to components for state management across updates.
• Component Collection Rendering - Renders components in a collection view by generating and laying them out from changesets.
• Lifecycle Event Hooks - Provides lifecycle event hooks for mount, update, unmount, and view acquisition phases.
• Component Context Sharing - Shares mutable context between component generations, preventing reuse bugs through derived values.
• Collection View Batch Operations - Enqueues batch UI changes for collection views, applying multiple operations atomically.
• Component Data Passing - Passes data through the component tree implicitly, avoiding manual prop threading at every level.
• Component State Managers - Creates components that manage internal state to determine rendered content and behavior.
• Pure Components - Builds view components as pure functions that transform input data into component trees without side effects.
• Declarative UI Frameworks - Describes UI elements using a declarative API based on immutable inputs, leaving rendering to the framework.
• Model-Driven Component Updates - Triggers component re-renders when the model or context object changes via the hosting view.
• Model-to-Component Transforms - Defines stateless class methods that map models and immutable contexts to components.
• Hierarchy Flattening - Flattens the view tree by removing redundant nested containers to reduce rendering depth.
• Parameterized Component Customizations - Passes configuration values like colors as constructor arguments instead of overriding methods in subclasses.
• Declarative UI Components - Provides a declarative API for composing reusable view components from immutable inputs.
• Flexbox Layout Engines - Includes a flexbox layout engine for declaring child components inline with automatic nil dropping.
• Component Events - Wraps method selectors and targets so child components signal events up the responder chain.
• State-Driven Animations - Triggers animations by regenerating the component tree after state or props updates.
• Animation Transition Components - Animates component entry onto the screen by wrapping it in an animation component.
• Changeset Application - Applies changesets to collection data, computing components and updating the view asynchronously.
• Nil-Safe Children - Provides nil-safe child arrays that eliminate conditional branching in component composition.
• Sub-Component Compositions - Wraps components inside new ones to hide internal implementation and expose simpler public interfaces.
• View Recycling - Reuses off-screen view objects to minimize allocation and improve rendering performance.
• State-Driven Insertion Tracking - Tracks insertion positions from component state to avoid race conditions with the list view.
• Small Component Composition - Encourages splitting oversized component files into smaller composite components for maintainability.
• Declarative Layout Modifiers - Ships a declarative builder API for adjusting component padding, alignment, and child composition.
• View Mutation Hooks - Provides lifecycle hooks to mutate the underlying UIView for animations and delegate integration.
• Viewless Components - Supports viewless components that position subviews without allocating native views.
• Concise Component Tree Syntax - Builds component trees with minimal boilerplate using C++ aggregate initialization and default-valued fields.
• Lifecycle-Synchronized Data Sources - Synchronizes the data source lifecycle with the list view to prevent crashes from out-of-sync content.
• Ordered Collection Updates - Implements ordered batch updates to collection views, processing deletions before insertions.
• Named Field Initializers - Supports named field initialization for structs, improving code readability and safety.
• Component Inspection Tools - Provides component inspection tools for examining the visual layout of components in the hierarchy.
• Standalone Component Hosts - Renders single components outside collection views via hosting views that manage layout and updates.
• Component Type Mismatch Detection - Catches component type mismatches at compile time using C++ type safety instead of runtime errors.
• Style Parameter Struct Grouping - Groups optional parameters into a plain struct to keep component initializers small and callers set only needed fields.
• Index Path Model Queries - Queries the data source for models by index path, maintaining accuracy during asynchronous updates.
• Index Path Model Retrieval - Retrieves models from the data source by index path, maintaining the datasource as the single source of truth.
• Explicit Action Target Binding - Binds actions to explicit component targets to ensure messages reach the intended receiver.
• Automatic Property Animations - Animates component properties by automatically inferring start and end values from state changes.
• Parallel Property Animations - Runs several property animations in parallel on the same component for simultaneous visual changes.
• Child Component Change Animations - Animates layout or property changes on a child component by returning an animation from the parent.
• Component-to-Controller Data Exposure - Exposes component properties to controllers for reading during initialization and state changes.
• Explicit Action Selector Passing - Passes action selectors explicitly between components to prevent hidden coupling and runtime errors.
• Relative Parent Sizing - Sizes components as a percentage of their parent container for responsive full-width layouts.
• Hierarchy Traversers - Sends actions upward through the mounted component hierarchy until a handler is found.
• Single Designated Initializers - Exposes all parameters in a single designated initializer to avoid method overrides.
• Component Sizing Utilities - Provides size range providers that calculate bounding sizes based on available space.
• Controller-Initiated State Updates - Allows controllers to trigger component state changes by calling update methods with new values.
• Cross-Axis Stretching - Stretches child components to fill the parent's cross-axis width in flexbox layouts.
• Responder Chain Delegate Proxies - Forwards view delegate callbacks into the component responder chain to avoid lifecycle issues.
• State Comparison Animation Triggers - Compares current and previous state to decide which property animations to return, avoiding unnecessary work.
• Co-located Controller Definitions - Encourages co-locating controller logic with component definitions for local state management clarity.

Star history