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.
Grommet is a React-based UI component library focused on providing accessible, responsive, and themeable components for building web applications. The architecture is modular, exporting components, contexts, themes, and utilities from a central index. Key entry points include src/js/index.js (main export) and the component directories under src/js/components/. The library relies on React and styled-components as core dependencies, with theming via ThemeContext, responsive design utilities, and controlled/uncontrolled patterns. Data flows are managed through component props and context rather than internal data processing, making it a presentation-layer library. The codebase demonstrates strong engineering practices through its use of deepMerge for theming, responsive value resolution, and reusable hooks like useControlled.
This repository is a WPF control library that ports Microsoft's WinUI3 (Fluent) design language to the Windows Presentation Foundation (WPF) framework. It provides a comprehensive set of modern UI controls—such as NavigationView, CommandBar, InfoBar, TabView, SplitView, NumberBox, ColorPicker, TeachingTip, and many more—each with full theming support (light, dark, high-contrast), accessibility automation peers, and virtualized layout engines for high performance. The library is distributed as a NuGet package (ModernWpfUI) and is accompanied by a gallery demo application (ModernWpf.Gallery) that showcases all controls with live code samples. Architecture: The codebase is organized into two main assemblies: ModernWpf (base infrastructure: theme management, helpers, icon sources, animations, window chrome) and ModernWpf.Controls (all ported controls with their XAML templates, property definitions, and automation peers). Controls follow a declarative property system using DependencyProperty registration, and many leverage a recycling element factory (RecyclePool) for efficient item rendering in repeaters and lists. The library integrates with WPF's native theming via ResourceDictionaryEx and FluentControlsResources, merging platform Fluent dictionaries with custom theme resources. Key entry points: For consumers, the library is used by adding the ModernWpf.Controls assembly and referencing the namespace http://schemas.modernwpf.com/2019 in XAML. The gallery application entry point is ModernWpf.Gallery/App.xaml.cs. Test infrastructure includes ModernWpfTestApp and dedicated unit tests under test/ that use a custom WpfTestHost. External dependencies: WPF (System.Windows), .NET runtime, and Win32 native methods for window management (NativeMethods.cs). The build system supports multiple .NET targets (net462, net8.0-windows7.0, net10.0-windows7.0) with conditional compilation. The project maintains strict parity with upstream WinUI3 through source-audit tests that pin specific commit hashes and verify code patterns. This ensures the WPF port remains faithful to the original Fluent design, but also creates maintenance overhead when upstream changes. The library is in preview status (1.x release candidate) with a frozen 0.9.x line; API is not yet frozen.
Headless UI is a library of completely unstyled, fully accessible UI components for React and Vue. It provides behavior-only primitives like Combobox, Listbox, Dialog, Popover, Tabs, RadioGroup, and Switch, with no built-in styling, allowing consumers to own the visual layer. The architecture is a monorepo with parallel React and Vue packages that share identical component APIs, test suites, and accessibility patterns, ensuring feature parity across frameworks. Components use render props (React) and slots (Vue) to expose state like open, active, selected, and disabled, plus an `as` prop for polymorphic rendering and a Transition component for enter/leave animations. The codebase is heavily tested with thousands of test cases covering keyboard navigation, focus management, ARIA attributes, form integration, and edge cases like dynamic children and virtual scrolling. Key entry points include the Combobox, Listbox, and Dialog components in both React and Vue, along with shared test utilities for accessibility assertions and interaction simulation. The library is actively maintained with a focus on accessibility-first design, headless composition, and cross-framework consistency.
react-native-haptic-feedback is a React Native library providing comprehensive haptic feedback capabilities for iOS and Android. It implements a dual-tier fallback chain on both platforms: iOS uses Core Haptics (CHHapticEngine) with UIKit generator fallback, while Android uses View.performHapticFeedback constants and VibrationEffect API. The library offers both simple trigger methods and complex pattern-based haptic sequences, includes cross-platform AHAP file playback with Android fallbacks, and provides React-first APIs like the useHaptics hook and TouchableHaptic component. Architecture features platform-specific native modules bridged via React Native's TurboModule system, with TypeScript source and auto-linking support.
Foblex Flow is an Angular-native library for building visual node editors, workflow builders, diagram editors, and AI pipeline UIs. It provides a comprehensive set of components and directives (f-flow, f-canvas, f-node, f-connection, f-connector, f-draggable, f-minimap, f-selection-area, etc.) along with plugins for managed state (undo/redo), accessibility (keyboard navigation), layout engines (dagre, elk), reflow-on-resize, and control schemes. The repository is a monorepo (NX) containing the core library, layout packages, a markdown renderer, a documentation portal with SSR, and multiple example applications (call center, schema designer, tournament bracket, UML diagram, marketing automation). The library is production-ready, actively maintained, and demonstrates high craftsmanship with decoupled architecture (mediator pattern), signal-based state management, Web Worker offloading for connection rendering, and extensive E2E testing.
This repository is the Windows Forms (WinForms) UI framework, a comprehensive library for building native Windows desktop applications in .NET. It provides a rich set of controls (DataGridView, ListView, TreeView, ComboBox, ToolStrip, PropertyGrid, etc.), layout managers, event handling, data binding, accessibility (UIA), printing, and drag-and-drop. The framework also includes a visual designer infrastructure for IDE integration, with property editors, serialization (CodeDom), and designer behaviors. It is the direct successor to the .NET Framework's WinForms, reimplemented for modern .NET with custom language extensions (ref struct, using for resource management) and conditional compilation for multiple .NET versions. The architecture is a monolith of tightly integrated modules: System.Windows.Forms (core controls and application framework), System.Windows.Forms.Design (design-time support), System.Drawing.Common (graphics, imaging, printing), System.Windows.Forms.Primitives (low-level Win32 interop), and System.Private.Windows.Core (binary serialization, value packing, COM helpers). Key entry points are the Application class (entry point for running forms) and the Form base class. The designer is accessed via the Design namespace and is used in visual form editors. Primary data flows involve user input propagating through delegate-based event handlers, data binding connecting UI controls to data sources, and binary serialization (MS-NRBF) for clipboard and drag-and-drop operations. The framework relies heavily on Win32 APIs (GDI+, COM, User32) and is Windows-only. It also includes a custom binary format serializer for legacy compatibility and a value union for efficient storage of variant types. While primarily an application framework, the repository contains notable data-oriented components such as the binary format serializer, run-length encoding, and value packing utilities. These are in service of the UI framework but are self-contained and reusable in other projects.
GKD is an open-source Android application that automates UI interactions, primarily to skip ads, auto-confirm dialogs, and perform custom click actions. It operates as an accessibility service, using a custom selector language (similar to CSS) to match UI nodes and execute actions defined in remote subscription rules. The app is built with Kotlin and Jetpack Compose, leveraging Room for local persistence, Ktor for HTTP, and Coroutines/Flow for reactive state management. It also integrates with Shizuku for privileged operations like input injection and screenshot capture. The architecture is modular: the main `gkd-app` module contains the UI, services, and rule engine; `gkd-selector` is a Kotlin Multiplatform library for parsing and matching the custom selector syntax; `gkd-db` provides a multiplatform database layer; and `gkd-hidden-api` contains stubs for Android hidden APIs used for automation. Key entry points include the accessibility service (`A11yService`), the subscription repository (`SubscriptionRepository`), and the snapshot capture system. Data flows involve downloading subscription rules, parsing them into internal representations, matching against accessibility node trees, and executing actions (click, swipe, etc.). External dependencies include AndroidX libraries, Ktor, Kotlin Serialization, Coil, and the Shizuku privilege library. The codebase demonstrates strong engineering practices with extensive unit tests, a well-defined selector engine, and reusable patterns like `Loadable` for async state and `MutexState` for concurrency. However, it relies heavily on hidden Android APIs and a custom DSL, which introduces maintenance risk. Overall, it is a high-quality, actively maintained project with significant reuse potential in its selector engine and utility components.
Video.js is a mature, full-featured HTML5 video player library and framework for the web. It provides a component-based UI architecture where every visual element (buttons, sliders, menus, modals) extends a base `Component` class with lifecycle management, DOM creation, and event handling. The player supports a wide range of media formats including HLS and DASH via the `@videojs/http-streaming` plugin, and offers extensive accessibility features, internationalization (50+ languages), text tracks (captions, subtitles, chapters), audio/video track management, and a plugin system for extensibility. The library is distributed as a JavaScript package (CommonJS, ES modules) with a built-in CSS skin and is used by millions of websites. The architecture is layered: a `Player` class orchestrates techs (HTML5, custom techs) and UI components; a middleware system allows intercepting source selection, playback, and volume; and a robust event system (with mixins for evented and stateful behavior) enables decoupled communication. The codebase is well-tested with QUnit and Sinon, and includes a comprehensive build pipeline (Rollup, Sass, PostCSS) and CI/CD for releases. While the library is actively maintained (v8.24.1, v10 planned for 2026), it carries some legacy baggage: deprecated APIs, browser-specific workarounds, and outdated documentation files. Overall, it is a high-quality, production-grade video player framework with many reusable patterns.
This repository is a frontend UI kit (MDBootstrap) that extends Bootstrap 5 with Material Design components and utilities. It provides a library of interactive UI elements (buttons, modals, dropdowns, etc.) built with JavaScript and SCSS, designed for easy integration into web projects. The architecture follows a modular pattern with separate directories for utilities, DOM helpers, components, and initialization logic. The library includes several reusable low-level components, such as a set of DOM utility functions (for data association, event handling, and element manipulation), a custom perfect scrollbar implementation, and a Material Design ripple effect. These utilities are designed to be isolated and have minimal dependencies, making them suitable for extraction and reuse in other projects. While the project is actively maintained and shows signs of being up-to-date with Bootstrap 5, there is some technical drift risk due to the maintenance of both standard Bootstrap components and MDB-prefixed variants, which may lead to duplication and synchronization challenges. Despite this, the codebase demonstrates solid engineering practices and is widely adopted in the industry.
Heroicons is a MIT-licensed SVG icon library providing 16x16, 20x20, and 24x24 pixel icons in outline and solid styles. The system consists of source SVG files that are optimized via SVGO and converted to framework-specific React and Vue components through a sophisticated build process. The library emphasizes tree-shakability, proper theming via currentColor, and accessibility attributes. It's distributed as separate npm packages (@heroicons/react, @heroicons/vue) with a base package containing raw SVGs.
Pa11y is a mature, widely-used automated accessibility testing tool that runs via command-line interface or Node.js API. It drives a headless Chrome browser (via Puppeteer) to load web pages, execute optional user interactions (actions), and then run one or more accessibility test runners (HTML_CodeSniffer and axe-core) against the page. Results are reported in multiple formats (CLI, CSV, JSON, HTML, TSV) and can be filtered by severity, ignored rules, or threshold. The architecture is a monolith library with a thin CLI wrapper, but the runner and reporter systems are modular and extensible via npm packages or local files. Key entry points are `bin/pa11y.js` for CLI and `lib/pa11y.js` for programmatic use. The data flow: launch Chrome, navigate to URL, run actions, inject runner scripts into the page, evaluate accessibility, collect and process issues, output via selected reporter. External dependencies include Puppeteer, axe-core, @pa11y/html_codesniffer, commander, and several utility libraries. The codebase is well-structured, thoroughly tested (unit and integration), and follows modern Node.js practices with async/await and ES6+ features.
This repository implements the Salesforce Lightning Design System (SLDS) as a reusable React component library. It provides over 60 accessible UI components including buttons, modals, tooltips, data tables, and layout elements that follow SLDS guidelines. The library emphasizes accessibility with quarterly audits, includes comprehensive documentation via Storybook, and provides utilities for common React patterns like ARIA prop handling and DOM portal management. Components are designed to be composable and customizable while maintaining visual and behavioral consistency with the Salesforce design system.
BlazorBlueprint is a comprehensive Blazor UI component library inspired by shadcn/ui, providing over 112 styled components and 28 headless primitives. It targets .NET 8 across Server, WebAssembly, and Auto render modes, with full accessibility (ARIA, keyboard navigation), theming via CSS custom properties (compatible with shadcn CSS variables), and zero Tailwind/Node setup. The library is split into two layers: Primitives (headless, behavioral components with focus management, positioning, and portal services) and Components (styled, ready-to-use widgets like DataGrid, charts, forms, dialogs, and navigation). It ships with four icon libraries (5,200+ icons) and 11 chart types via Apache ECharts. The architecture emphasizes composability through cascading contexts, a consistent form-field pattern, and a utility-first approach with the ClassNames.cn helper for Tailwind class merging. The codebase demonstrates strong engineering practices: extensive use of generics, expression trees for filtering, JS interop with guarded disposal, and a localization system with 200+ string keys. However, the large API surface, heavy JS interop, and limited test coverage (only a few unit tests for DataGrid and hierarchy utilities) present maintenance risks.
Sard Uniapp is a UI component library built on Uniapp + Vue 3 framework providing 117+ reusable components for cross-platform application development. The library follows a modular architecture where each component includes implementation, type definitions, styling, and unit tests. Key features include tree shaking support, TypeScript integration, theme customization, internationalization, dark mode support, and >80% unit test coverage. The library is designed for multi-end compatibility targeting H5, WeChat mini-program, Alipay mini-program, and native Apps (excluding nvue/uvue).
This repository is a production-grade Model Context Protocol (MCP) server that bridges AI assistants to Figma. It exposes 100+ MCP tools for reading and manipulating Figma files, variables, components, styles, FigJam boards, Slides, version history, tokens, and accessibility audits. The architecture is dual-mode: a local Node.js server (`src/local.ts`) communicates over stdio to AI clients and via WebSocket to a bundled Figma Desktop Bridge plugin, while a Cloudflare Workers variant (`src/index.ts`) supports cloud sessions with OAuth and a Durable Object WebSocket relay. The Desktop Bridge is the primary data channel, with Figma REST API fallbacks for scenarios where the plugin is unavailable or limited to certain plans. Beyond basic Figma CRUD, the codebase contains substantial engineering investment in design-token synchronization: canonical DTCG-aligned token documents round-trip through parsers and formatters for CSS variables, Tailwind v3/v4, SCSS, TypeScript modules, Style Dictionary, and Tokens Studio. A separate extraction engine (`src/core/extraction/`) mines production codebases for styling conventions and scaffolds design-system packages, while a scoring engine produces weighted design-system health dashboards. These components give the repo a hybrid quality: it is fundamentally an application, but its token pipeline and codebase-analysis subsystems are data-engineering-like assets that could be reused independently. The codebase demonstrates strong engineering practices: strict Zod schemas, consistent tool registration factories, connector abstraction, extensive Jest test coverage, atomic file writes, adaptive response compression, and careful caching/invalidation. However, it also carries meaningful debt: some token parsers are unimplemented stubs, a few files are monolithic (`figma-tools.ts`, `src/local.ts`), local/cloud connector implementations must be kept in sync manually, and some documentation references outdated internal paths. Overall, this is a mature, feature-rich MCP server with several genuinely reusable components for anyone building design-tool pipelines, token bridges, or local process-lifecycle infrastructure.
Slick is a mature, feature-rich jQuery carousel library that enables developers to create responsive, touch-enabled sliders with minimal configuration. The core implementation in slick/slick.js provides a comprehensive set of options (over 50 settings), events, and methods for controlling slide behavior, including infinite looping, center mode, variable width, vertical orientation, lazy loading, and responsive breakpoints. The library emphasizes accessibility with ARIA attributes, keyboard navigation, and focus management. The code is well-structured as a jQuery plugin with AMD/CommonJS module support, and includes fallback mechanisms for CSS transitions and transforms. The accompanying SCSS/LESS stylesheets offer customizable theming through variables. While the library is tightly coupled to jQuery, it remains a robust and widely-used solution for building carousels in jQuery-based projects.
Peekaboo is a mature macOS desktop automation toolkit that provides a CLI, Mac app, and MCP server for screen capture, UI element detection, input synthesis, window management, and AI agent integration. The architecture is modular: a Swift CLI (peekaboo) exposes ~33 commands for interaction, system control, and AI agent orchestration; a Mac app provides a menu bar interface, session management, and visualizer overlays; a bridge daemon (PeekabooBridge) enables secure remote automation via a versioned socket protocol with operation allowlisting. The MCP server exposes native automation tools to AI clients (Claude, Cursor, etc.) via stdio transport. The agent runtime (PeekabooAgentService) supports multiple AI providers (OpenAI, Anthropic, Ollama, etc.) with streaming, tool calling, and session persistence. The codebase is written in Swift 6.2 with strict concurrency, extensive unit/integration tests, and a focus on safety (fail-closed target validation, honest effect reporting). It is not a data research project; it is a production-grade application for macOS automation.
Sitespeed.io is a mature, open-source web performance testing and monitoring tool that drives real browsers (Chrome, Firefox, Edge, Safari, including mobile) to collect a comprehensive set of performance metrics. It measures Core Web Vitals (LCP, INP, CLS, TTFB, FCP), visual metrics (Speed Index, filmstrip), HAR waterfalls, CPU long tasks, third-party requests, accessibility violations (via axe-core), and sustainability metrics (CO₂ estimates). The tool is used for one-off audits, CI/CD performance budgets, and continuous production monitoring, with results output as rich HTML reports, JSON, JUnit/TAP, and time-series data sent to Graphite/InfluxDB/Grafana. The architecture is plugin-based: a core message queue orchestrates a pipeline of plugins (setup → url → summarize → render). Built-in plugins handle browser testing (via Browsertime), HAR analysis (PageXray), best-practice advice (Coach), accessibility, sustainability, statistical comparison (Mann-Whitney U), performance budgets, and result storage (S3, GCS, SCP, Rsync). The CLI is built with yargs and supports ~600 options organized into topical modules. The tool is primarily delivered as a Docker image (multi-arch amd64/arm64) and an npm package. Key entry points are `bin/sitespeed.js` (CLI), `lib/sitespeed.js` (programmatic API), and `docker/scripts/start.sh` (Docker entrypoint). External dependencies include Browsertime, Coach Core, PageXray, axe-core, and the third-party-web dataset. The project has extensive CI/CD (GitHub Actions), a documentation site built with Eleventy, and a release workflow that publishes npm packages and Docker images with Sigstore signatures and SBOMs.
The BigCommerce Cornerstone theme is a reference implementation for building e-commerce stores on the BigCommerce Stencil platform. It provides a complete frontend solution including product listing and detail pages, shopping cart and checkout functionality, customer account management, and search with faceted filtering. The theme follows a modular architecture with Handlebars templates for markup, SCSS for styling, and JavaScript for interactivity, organized by page type and shared utilities. Key strengths include a strong focus on accessibility (ARIA attributes, focus trapping, keyboard navigation), responsive design, and internationalization support. The theme implements reusable patterns such as a modal system with focus management, a faceted search component that synchronizes state with the URL, and currency/language selectors that persist user preferences. The build process uses both Webpack and Grunt to compile and optimize assets, including an SVG sprite system for icons. While the theme is actively maintained and demonstrates solid engineering practices, it relies heavily on jQuery and uses an older version of the Foundation Sites framework, which may present challenges for modernization. The codebase is well-suited for developers looking to create custom BigCommerce themes, offering a robust foundation that balances functionality with extensibility.