react-draggable is a mature, well-maintained React library that provides two components for making elements draggable: `<Draggable>` (a high-level, state-managed component that applies CSS transforms) and `<DraggableCore>` (a low-level, stateless primitive that fires raw drag events). The library handles mouse and touch events, supports axis constraints, bounds (parent, selector, or numeric), grid snapping, scaling, and controlled/uncontrolled position modes. It uses CSS transforms for positioning, avoiding conflicts with CSS layout. The codebase was recently migrated from Flow to TypeScript (v4.6.0), ships CommonJS, ESM, and UMD builds, and includes a comprehensive test suite (unit tests in jsdom + browser tests via Puppeteer). The architecture is clean: `Draggable` wraps `DraggableCore`, adding state management and transform application, while utility modules (`domFns`, `positionFns`, `getPrefix`, `shims`) handle DOM operations, position calculations, browser prefix detection, and general helpers. The library is actively maintained with recent commits, a thorough CI pipeline, and detailed documentation including a CSP nonce feature and React 19 compatibility.
This repository is a high-quality, production-ready React Native library for building interactive bottom sheets. It provides a highly customizable component (`BottomSheet`) that supports gesture-driven snapping, dynamic sizing, keyboard handling, and modal presentation. The architecture is built on `react-native-reanimated` for performant animations on the UI thread and `react-native-gesture-handler` for gesture recognition. The library includes a rich set of pre-integrated scrollable components (FlatList, ScrollView, SectionList, VirtualizedList, FlashList), a modal variant (`BottomSheetModal`), and a context-based provider system for managing multiple sheets. The codebase is well-structured with TypeScript, clear separation of concerns, and extensive documentation. It is actively maintained with frequent releases and a large community (9k+ stars). The primary entry point is `src/index.ts`, which exports all components, hooks, and utilities. The library is not an application but a reusable UI component library, and it demonstrates strong engineering practices with reusable patterns like gesture handler providers, animated detent management, and scrollable component factories.
Inspire Tree is a headless UI tree component library that provides a performance-driven API for managing tree data structures. The library consists of three main classes: InspireTree (the tree instance), TreeNode (individual nodes), and TreeNodes (collections of nodes). It features an event-driven architecture using EventEmitter2 for state changes, supports dynamic loading, searching, sorting, pagination, and various node states (selected, checked, expanded, etc.). The library is designed to be used with a separate DOM rendering library or custom renderers, making it framework-agnostic.
This repository contains a React Native library that provides pinch-to-zoom functionality with advanced gesture handling. The core implementation uses React Native Reanimated and Gesture Handler to deliver smooth 60fps/120fps animations for zoom, pan, and double-tap interactions. The library offers both a ready-to-use `<Zoom>` component and a `useZoomGesture` hook for custom implementations, featuring Apple Photos-style physics including rubber band effects, focal point tracking, and seamless gallery navigation. The implementation demonstrates sophisticated gesture coordination and performance optimization through proper use of worklets to keep animations on the UI thread. The useZoomGesture hook encapsulates complex logic for managing shared values, handling simultaneous gestures (tap, pan, pinch), and implementing physics-based responses like rubber band effects and spring animations. It carefully handles edge cases such as boundary conditions, momentum preservation, and platform-specific behaviors to ensure a polished user experience. Key features include configurable zoom limits, double-tap zoom with customizable scales, optional JS bridge callbacks for less performance-critical use cases, and advanced gallery swipe navigation that enables seamless transitions between images in a flat list while zoomed—just like the native iOS Photos app. The library is designed with performance in mind, minimizing JavaScript bridge communication by leveraging worklet-based animations for the core interaction logic.
This repository is a highly configurable, feature-rich React date picker component library published as `react-datepicker`. It provides a single entry point (`DatePicker`) that supports single date, date range, multiple dates, week, month, quarter, and year picker modes, along with time selection, timezone handling, localization via `date-fns`, and extensive keyboard navigation and ARIA accessibility. Internally, the library uses a class-component architecture with a clear separation of concerns: a `Calendar` component manages month/year navigation, `Month` renders days or month/quarter grids, `Day` handles individual cell rendering with selection and focus management, and `Time`/`InputTime` handle time input. Positioning of the calendar popover is delegated to `@floating-ui/react` via a `withFloating` HOC, and rendering can be redirected to a portal (including shadow DOM) for overlay scenarios. The component exposes over 60 props for customization, including custom input elements, headers, and day rendering. The library is mature and widely adopted, with a comprehensive test suite (Jest + React Testing Library) covering interactions, keyboard navigation, edge cases, and accessibility (axe tests). The build pipeline uses Rollup to produce UMD, CJS, and ES module bundles, and CSS is provided in both standard and CSS Modules variants.
This is a mature, cross-platform React Native bottom sheet library (`@lodev09/react-native-true-sheet`) that provides native-feeling sheets on iOS (UISheetPresentationController), Android (BottomSheetBehavior + CoordinatorLayout), and Web (forked Vaul drawer). It is built exclusively for React Native's New Architecture (Fabric) with shared C++ shadow nodes for synchronous per-detent layout. The library offers an imperative API via refs and a global static method registry, plus optional integrations with React Navigation (custom stack router and sheet navigator), Expo Router (Sheet layout), and Reanimated (worklet-driven position tracking). Key features include automatic detent sizing, peek detents, header/footer overlays, keyboard avoidance, stacked sheets, dimming, and a portal-based overlay for toasts/dialogs. The codebase demonstrates high craftsmanship with clean native delegates, extensive event handling, and thorough test mocks. It is actively maintained with multiple example apps, CI/CD, Maestro E2E tests, and a documentation site.
ngx-gantt is a mature Angular library for implementing interactive Gantt charts in web applications. It provides a comprehensive set of features including task visualization with drag-and-drop resizing, dependency linking, hierarchical data structures, virtual scrolling for large datasets, internationalization support, and extensive customization through templates. The library follows Angular best practices with a modular architecture, service-based design patterns, and utilizes modern Angular features like signals. It includes a robust test suite, documentation, and automated release processes.
Grid.js is a TypeScript table library that renders interactive HTML tables with features like sorting, searching, pagination, and row/cell selection. It follows a modular architecture with clear separation of concerns: core grid functionality, configuration system, data pipeline for processing data through stages (extraction, transformation, filtering, sorting, limiting), storage abstraction for client/server data sources, UI components built with Preact, and a plugin system for extensibility. Data flows from user-provided sources through storage adapters, then through pipeline processors that handle server initiation, data extraction, format transformation, filtering, sorting, and pagination before reaching the view layer for rendering. User interactions trigger pipeline reprocessing to update the display.
This repository provides a full‑screen modal view controller for cropping and rotating images on iOS, implemented as a reusable UIKit component library. The core controller (`TOCropViewController` in Objective‑C, `CropViewController` in Swift) manages a gesture‑driven crop view, a toolbar with rotation/reset/aspect‑ratio controls, a configurable grid overlay, and animated present/dismiss transitions. It supports both rectangular and circular cropping, aspect‑ratio locking, and device‑aware layout that adapts to safe areas, notches, and orientation changes. The architecture follows a classic MVC pattern within UIKit: `TOCropView` handles image display, crop‑box manipulation, pan/zoom, and rotation; `TOCropToolbar` provides adaptive button layouts; `TOCropOverlayView` draws the grid; and `TOCropScrollView` manages touch‑based scrolling. Image‑level crop and rotate operations are delegated to the `UIImage+CropRotate` extension, which performs pixel‑level transformations. The Swift wrapper uses bridging headers and closures to map the Objective‑C delegate protocol to Swift callbacks, demonstrating a clean cross‑language integration pattern. The library is distributed as a framework via CocoaPods and Carthage, includes unit tests (XCTest), CI/CD pipelines (GitHub Actions, Buildkite), and localization in over 30 languages. It depends only on UIKit and the iOS SDK, with no external runtime dependencies. The codebase is mature (first commit 2015) and actively maintained, though it contains iOS‑version‑specific conditionals (e.g., iOS 26 glass effects) and some deprecated APIs that indicate moderate technical drift. Several components are self‑contained and reusable: the `UIImage+CropRotate` extension for image processing, the `TOCropViewControllerTransitioning` animation controller, the `TOCropOverlayView` grid overlay, and the Swift bridging pattern. These can be extracted into other iOS projects with minimal modification.
This repository is a robust Android library designed for debugging applications by providing a user-friendly interface to view system logs (logcat). It functions as a standalone framework that integrates into an Android app via Gradle dependency. The core functionality involves capturing logs from the system logcat process, parsing them using regex patterns, filtering them based on user-defined rules (TAG, level, search keywords), and displaying them in a RecyclerView with features like auto-merging, highlighting, and saving to file. The architecture relies on a ContentProvider for automatic initialization, a Foreground Service to maintain the log capture process (handling Android 8+ and 14+ restrictions), and a Floating Window/Notification for user interaction. The code demonstrates strong engineering practices, particularly in handling Android version fragmentation (e.g., specific handling for Android 12's Foreground Service restrictions and Android 14's targetSdk 34 requirements). It includes OOM protection mechanisms by limiting the number of displayed logs and uses MD5 hashing to prevent duplicate log entries when restarting the capture stream.
react-native-linear-gradient is a mature, well-maintained React Native library that provides a `<LinearGradient>` component for rendering linear gradients on iOS and Android. The library supports both the old (Paper) and new (Fabric) React Native architectures, with native implementations in Objective-C/C++ (iOS) and Java (Android). It offers configurable start/end points, color stops, angle-based gradients, and automatic handling of border radii on Android. The codebase is cleanly structured with TypeScript types, proper prop validation, and a Jest mock for testing. The example app demonstrates various use cases including simple gradients, angle gradients, animated gradient transitions, and gradient buttons. The library is actively maintained with CI/CD pipelines, recent commits, and support for React Native 0.75+.
This repository contains a mentions plugin for the Lexical text editor, along with a Next.js demo application. The plugin provides advanced mentions functionality including customizable triggers, multiple trigger support, automatic spacing, async query functions, customizable styling, and programmatic manipulation of mentions. The architecture consists of a core plugin implementation in the 'plugin' directory and a demonstration application in the 'www' directory. The plugin follows a modular design with separate concerns for UI components, state management, text processing, and editor integration. Key features include mention detection via regex, custom node implementation for Lexical, and hooks for managing asynchronous data fetching with proper loading states.
SortableJS is a mature, standalone JavaScript library for creating reorderable drag-and-drop lists and grids. It supports mouse, touch, and pointer events across modern browsers and legacy browsers like IE11 and Edge. The library is designed as a modular system with a core (Sortable class) and optional plugins (AutoScroll, Swap, MultiDrag, OnSpill) that can be mounted selectively. It exports UMD and ESM builds, integrates with major frameworks (React, Vue, Angular) via separate adapter packages, and provides a rich API with options for grouping, animation, handles, filtering, and custom events. The codebase demonstrates a well-thought-out plugin architecture, event dispatching, and animation state management, though some build tooling and browser workarounds show its age.
Multiple Select is a mature jQuery plugin that transforms native HTML `<select>` elements into feature-rich dropdowns with checkboxes, supporting single and multiple selection, optgroups, filtering, virtual scrolling for large datasets, localization, and full keyboard accessibility. The library is architecturally structured as a monolith jQuery-fn extension with a core class (`MultipleSelect.js`), separate utilities (`utils/index.js`), constants, virtual scroll implementation, and a Bootstrap 5 theme. It also provides Vue 2/3 wrappers (`src/vue/`) and is distributed as UMD modules via npm and CDN. The codebase demonstrates solid engineering practices: ES6+ modules, Rollup/Vite build system, comprehensive linting (ESLint, Stylelint, cspell), and a configurable options/events/methods API. While tightly coupled to jQuery, the utility functions and virtual scroll component are potentially reusable standalone. The plugin is actively maintained with recent releases and a responsive issue tracker.
Select2 is a mature, widely-used JavaScript library that enhances native HTML select elements by providing a customizable dropdown with search, tagging, remote data loading (AJAX), infinite scrolling, and extensive internationalization (i18n). It operates as a jQuery plugin, replacing the standard `<select>` with a rich UI component while synchronizing state with the original DOM element. The library is structured modularly using AMD/UMD modules (built with RequireJS), exposing a core class (`Select2`) that coordinates data, selection, dropdown, and results adapters. It employs a decorator pattern (`Utils.Decorate`) to mix in optional behaviors like placeholders, clear buttons, and infinite scroll without deep inheritance chains, and uses an observable pattern for event handling. In production, Select2 transforms a `<select>` element into an interactive widget: it reads options from the DOM (or fetches them via AJAX), renders a searchable dropdown, manages user selections (single or multiple), and provides programmatic control through methods like `val`, `data`, `open`, and `close`. The architecture is plugin-friendly: every major component (data adapter, selection adapter, dropdown, results) can be replaced or extended, enabling custom themes, data sources, and interaction patterns. Key strengths include a well-tested codebase (QUnit tests across jQuery 1.x–4.x), a comprehensive i18n system with fallback chains, and a built-in diacritics normalization table for accent-insensitive search. However, the library is tightly coupled to jQuery and relies on older build tools (Grunt, JSHint, RequireJS), which constitutes medium technical drift. Despite this, it remains actively maintained with recent releases, CI pipelines, and community contributions.
NippleJS is a vanilla virtual joystick library for touch and mouse interfaces, designed for mobile games, remote controls, and interactive web applications. The core library in `packages/nipplejs/` provides a lightweight, dependency-free joystick with three modes (dynamic, semi, static), multitouch support, and extensive event-driven APIs. The architecture is built around a Factory singleton managing Collections, each of which manages multiple Joystick instances. The library is written in TypeScript, with thorough unit tests and Playwright end-to-end tests covering event accuracy, mode behavior, cleanup, and edge cases. The repository also includes a documentation site built with Astro, featuring five interactive game demos that showcase library features, along with a monorepo structure for tools and tests. While the core library is modern and well-tested, some tooling (ESLint 8, Husky v4) and the workspace Yarn version mismatch indicate minor technical drift.
This repository contains FlipView, an Android library that extends ViewFlipper to provide animated view flipping capabilities similar to Gmail's swipe actions. The core component is a custom ViewGroup that manages front and rear views with configurable animations, layouts, and images. It supports auto-flipping at intervals, user-triggered flips, initial cascade animations for multiple views, and SVG image support. The library includes sophisticated animation coordination to avoid visual glitches and provides extensive customization through XML attributes. A sample application demonstrates usage in various configurations including RecyclerView integration.
GravitySnapHelper is a mature Android library that extends LinearSnapHelper to snap RecyclerView items to an edge (START, END, TOP, BOTTOM) or CENTER. It provides configurable fling distance limits, scroll speed, snap-to-padding support, and a snap listener. The library also includes GravitySnapRecyclerView, a drop-in RecyclerView subclass that wires up the snap helper with XML attributes, and OrientationAwareRecyclerView to resolve nested RecyclerView touch conflicts. The sample app demonstrates various configurations including horizontal and vertical snapping, decoration-aware snapping, and pager-like behavior. The code is clean, well-documented, and makes effective use of Android's RecyclerView API. It has a strong following (nearly 5000 stars) and receives active maintenance.
This is a Flutter package for creating step-by-step showcase/onboarding tours. It highlights widgets with tooltips, supports custom tooltip widgets, auto-play, animations, and multiple scopes. The architecture uses a service locator pattern (ShowcaseService) to manage independent showcase scopes without requiring BuildContext. The overlay system uses a custom ShapeClipper to cut out holes around target widgets. The code is well-organized and actively maintained, though it lacks unit tests.
TLPhotoPicker is an iOS library providing a customizable photo and video picker UI similar to Facebook's picker. It wraps the Photos framework (PHAsset, PHAssetCollection) and offers a configurable grid view with support for smart albums, live photos, video playback, iCloud download, and camera capture. The architecture follows a service-oriented pattern with separate classes for photo library access, selection logic, camera handling, and video playback, all coordinated by a central view controller. The library includes a builder pattern for configuration, async/await support for image loading, and comprehensive delegate callbacks. It is distributed via CocoaPods and Swift Package Manager, targeting iOS 13.0+. The codebase is well-structured but shows some technical drift, notably continued use of the deprecated UIImagePickerController for camera capture instead of the modern PHPickerViewController.