leaferjs/leafer-ui

Features

• 2D Vector Graphics Libraries - Provides a comprehensive API for drawing and animating 2D shapes, paths, and text with layering and masking.
• Scene Organizations - Organizes vector graphics and paths within a hierarchical scene tree to control collective transformations and rendering.
• High Performance Rendering - Uses a hierarchical scene-tree and high-performance rendering pipeline to create complex visual tools and infinite canvases.
• Graphic Design Editors - Supplies the fundamental tools for building graphic design editors, including element selection, scaling, and rotation.
• Touch-to-Canvas Coordinate Mapping - Maps raw browser interaction coordinates back into the canvas world space to align input events.
• Canvas Rendering - Allows direct manipulation of pixels on a drawing surface for manual rendering and baking graphics.
• Cross-Platform Graphics Frameworks - Provides a decoupled rendering backend to deploy a single graphics codebase across web, mobile, and server environments.
• Shape Drawing - Provides tools for programmatically defining and rendering geometric shapes like circles, ellipses, and arcs.
• Fill and Stroke Styles - Applies colors, gradients, and patterns to define the interior and boundaries of vector shapes.
• Multi-Threaded Rendering - Distributes rendering and scene logic across multiple threads to ensure a high-performance, responsive user experience.
• Canvas Rendering Engines - Implements a high-performance rendering engine that translates vector graphics into pixel-based images on canvas.
• Infinite Canvas Environments - Implements a virtual space that allows users to navigate across expansive coordinates using panning and zooming.
• Backend-Agnostic Rendering Pipelines - Implements a rendering architecture that decouples core logic from specific graphics APIs to support multiple platforms.
• Rendering Backends - Decouples core logic from rendering implementations to support different platforms and graphics APIs.
• Graphic Element Grouping - Supports grouping drawing operations to apply collective transformations like scaling, rotation, and clipping.
• Shape Rendering - Implements comprehensive tools for defining and rendering geometric primitives and vector paths.
• SVG Path Rendering - Provides high-performance rendering of 2D shapes using SVG path notation and builder objects.
• Vector Path Construction - Renders custom vector paths and pen-tool drawings with support for varying colors and styles.
• Web-Worker Threading - Offloads heavy scene-tree logic and drawing operations to Web Workers to prevent main-thread blocking.
• Offscreen Canvas Rendering - Executes scene-tree logic and drawing operations in a web worker using offscreen canvas APIs.
• Background Rendering Workers - Executes the entire scene-tree and rendering pipeline in background threads to maintain a fluid interface.
• Vector Scene Graph Hierarchies - Organizes vector graphics in a nested tree structure to handle collective transformations and clipping.
• Coordinate Space Mappers - Implements utilities to convert points between world, page, local, and box spaces using transformation matrices.
• Coordinate Space Transformations - Maps points between world, page, and local coordinate spaces to ensure accurate element positioning.
• Cross-Platform UI Toolkits - Offers a cross-platform toolkit that abstracts drawing APIs to work across web, mobile, and server environments.
• Element Stacking - Controls the stacking order, opacity, and visibility of elements to organize depth and transparency.
• Layout Containers - Implements versatile box containers for arranging graphic elements with customizable styles and structure.
• Interaction and Event Handling - Provides frameworks and logic to manage how pointer and touch actions trigger specific responses.
• Event Bubbling Mechanisms - Processes pointer and touch events using a capture and bubble mechanism for precise hit detection.
• Hit Detection Systems - Provides pixel-perfect interaction logic to determine if pointer events hit an element or its children.
• Infinite Canvas Engines - Provides the foundational components required to build zoomable and pannable infinite visual interfaces.
• Infinite Canvas SDKs - Acts as a high-performance engine for creating zoomable, reactive infinite canvas interfaces.
• Interaction Handle Configuration - Implements pixel-perfect hit detection to determine how complex visual elements respond to pointer events.
• Interactive Graphics - Enables direct manipulation of visual objects, such as dragging and moving elements within a scene.
• Canvas Element Interactions - Provides a specialized system for managing user interactions specifically for 2D canvas shapes and groups.
• Touch and Drag Interactions - Handles high-speed processing of dragging, scaling, and multi-touch inputs for immediate visual feedback.
• Visual Element Transforms - Provides capabilities to rotate, scale, skew, and translate visual elements within a coordinate space.
• Canvas Navigation - Implements continuous panning and zooming interactions for navigating large-scale or infinite virtual workspaces.
• Cross-Platform Graphics Frameworks - Enables the same graphics codebase to run across web, server, mobile, and mini-program environments.
• Gaming and Game Development - Provides an integrated set of plugins and rendering tools tailored for real-time game development.
• Content Formats and Exporting - Renders scene elements into images, JSON, or canvas formats supporting screenshots and slicing.
• Graphic Interaction Toolkits - Provides a dedicated plugin with tools for scaling, rotating, moving, and multi-selecting graphic elements.
• Environment Logic Adapters - Supports new environments by overriding platform-specific global variable bindings and adapter code.
• 2D Game Engine Components - Integrates animation, motion paths, and interactive state management for creating high-performance small-scale games.
• 2D Game Frameworks - Offers tools for building 2D games using sprite sheets, motion paths, and real-time animation loops.
• Interactive Game Frameworks - Provides a framework for creating high-performance interactive 2D games and experiences within mini-apps.
• Canvas Dimensioning - Sets canvas dimensions as fixed, adaptive to a parent container, or automatically growing to fit content.
• Canvas Exporters - Converts canvas elements into images or JSON files using snapshots and slicing.
• Layer Management - Organizes content into separate engine layers based on update frequency to optimize redraws in complex tools.
• Vector Graphics Editors - Provides the libraries and tools necessary to build interactive environments for creating and managing vector graphics.
• Interactive Canvases - Provides a programmable canvas environment with built-in support for zooming, panning, and pinch gestures.
• Reactive Framework Integrations - Allows rendering scene-trees as components in reactive frameworks by bypassing data proxies to maintain performance.
• Vector Graphics Editors - Provides specialized tools and plugins for creating interactive software focused on vector-based shapes and diagrams.
• Scene Element Queries by Criteria - Allows for the targeted retrieval and removal of scene nodes based on specific attribute criteria like tags or IDs.
• Keyframe Animations - Produces transition, keyframe, and path animations using delays, loops, and seek controls.
• Large-Scale Element Rendering - Maintains performance and stability when displaying a massive number of visual elements on a canvas.
• Layered Render Optimizations - Divides content into separate layers based on update frequency to minimize canvas redraw overhead.
• State Transition Animators - Executes high-performance transitions and tweening to drive dynamic visual changes between states.
• Mixed Media Renderers - Displays both raster and vector images with specialized logic to maintain visual clarity during scaling.
• Path Animation Utilities - Moves elements along predefined trajectories and triggers stroke-based growth animations.
• Vector Bounding Box Calculations - Calculates the exact dimensions and spatial coordinates of vector elements for alignment and collision detection.
• Vector Element Animations - Creates transitions, keyframe animations, and motion paths to move canvas elements and change styles.
• WebGL Canvas Integrations - Embeds the rendering system within a DOM structure to manage viewport sizing and input events.
• Mobile Gesture Interactions - Maps touch gestures to element manipulation and provides hooks for customizing mobile interactions.
• Canvas Scene Lifecycle Hooks - Manages the lifecycle of a scene-tree and graphic elements within reactive architectures to maintain performance.
• Non-Reactive State Optimization - Provides high-performance rendering by preventing internal engine states from being wrapped in framework reactive proxies.
• Custom Component States - Supports creating named states for elements to trigger complex visual changes based on application or game logic.
• Visual State Transitions - Smooths the visual shift between different element states using transition effects for fluid animations.
• Flexbox Canvas Layouts - Arranges graphic elements using a flexible box model for responsive positioning within the canvas.
• Automatic Element Alignment - Automatically calculates the position and size of canvas elements based on alignment, direction, and spacing rules.
• Dirty Region Redraw Optimizations - Implements dirty-region tracking to update only changed areas of the canvas, maintaining high performance for many objects.
• Property Interpolation Animators - Creates smooth transitions and keyframe animations for element properties along predefined motion paths.
• Responsive Layout Engines - Uses a flexible box model to arrange canvas elements responsively across different screen sizes.
• Element Locators - Provides utilities for identifying and selecting specific graphic elements using identifiers or spatial coordinates.
• Element Masks - Defines specific elements within a group to act as clipping masks or erasers for complex cutouts.
• Visual - Defines visual styles for hover, press, focus, and selected states to provide immediate user feedback.
• Interactive Applications - Enables the development of high-performance web applications combining complex vector graphics with real-time touch gestures.
• Interaction Behavior Configurations - Configures draggability, movement bounds, and cursor styles to define precise user interaction with graphics.
• Visual State Management - Manages the switching of styles for hover, press, focus, and disabled states to provide immediate visual feedback.
• Interactive Element Styling - Provides styling for interactive states such as hover, focus, and disabled status for canvas elements.
• Off-Main-Thread Editor Logic - Executes graphic editing and viewport controls in a multi-threaded background environment to keep the UI responsive.
• Rendering Lifecycle Hooks - Provides hooks to execute custom logic in response to property updates and layout shifts during the rendering process.
• Canvas Graphics Renderers - Provides the ability to generate images and drawings within server-side environments for background processing or static asset creation.
• Graphics Rendering - Supports generating images and visual assets on a server by running rendering logic in a headless environment.

Star history