A React Native library providing high-performance animated headers for scroll views (ScrollView, FlatList, SectionList, FlashList). It leverages react-native-reanimated for smooth 60fps animations and supports both absolute and relative header positioning with fade-in/scale effects. The library exports composable components like Header, LargeHeader, FadingView, and ScalingView, plus container components that wrap native scrollable views with header logic. It is fully typed, follows React Native new architecture, and works with Expo. The example app demonstrates multiple real-world patterns including Twitter profile, inverted chat, and blurred surfaces. The core scroll logic is encapsulated in a reusable hook (useScrollContainerLogic) that manages shared values for scroll position, navbar visibility, and auto-fix scrolling behavior.
ember-sortable is an Ember.js addon providing sortable UI primitives for drag-and-drop reordering of lists, grids, and tables. It implements modifiers (sortable-group, sortable-item, sortable-handle) that attach drag-and-drop behavior to DOM elements, with built-in support for mouse, touch, and keyboard input. The architecture centers around a service (ember-sortable-internal-state) that manages state between sortable groups and items, enabling features like visual feedback during drag, automatic container scrolling, and accessibility support including screen reader announcements and keyboard navigation. The library follows Ember addon conventions with a modular structure, clear separation of concerns, and comprehensive test coverage.
This repository is the source code for the NG-NEST Angular UI component library (version 22.0.5), providing over 70 reusable components for building enterprise-grade web applications. The library includes a comprehensive set of UI elements such as buttons, tables, forms, dialogs, trees, date pickers, and more, all built with Angular's latest features including signals, standalone components, and OnPush change detection. The repository also contains a documentation/demo site that showcases each component with live examples in both English and Chinese, along with a full RBAC tutorial demonstrating a real-world admin panel using NestJS and Angular. The architecture follows a monorepo pattern: the library lives under `lib/ng-nest/ui/` with each component as an independent Angular module (with its own `ng-package.json`), while the documentation site resides in `src/` and uses the library itself. Key entry points include `lib/ng-nest/ui/index.ts` for the library and `src/app/app.config.ts` for the application. Data flows are primarily unidirectional via Angular signals and observables, with services like `XRepositoryAbstract` providing a consistent CRUD pattern for backend integration. External dependencies include Angular 22, Angular CDK, RxJS, and PrismJS for syntax highlighting. The library demonstrates strong engineering practices: consistent component property classes, a centralized portal service for overlays, a theme system with CSS variables and dark mode, and full internationalization support with 30+ locales. However, many component tests are disabled (using `xdescribe`), and there is some duplication in example data across language variants. Overall, it is a well-maintained, production-ready UI library with a high degree of reusability.
mapcn is a React map component library and documentation site, not a data project. The product is a single-file MapLibre GL JS wrapper (`src/registry/map.tsx`) that exposes composable components such as Map, MapMarker, MapPopup, MapRoute, MapArc, MapGeoJSON, MapClusterLayer, and MapControls. It is distributed as a shadcn/ui registry: users run `npx shadcn add @mapcn/...` and receive copy-paste source code. The accompanying Next.js 16 app is a showcase and docs portal, rendering live examples, code samples, installation commands, and generated LLM-oriented content via routes under `/llm` and `/llms.txt`. Architecturally, the repo combines a library (registry JSON + map.tsx) with an application shell (Next.js App Router, Tailwind CSS v4, shadcn UI components). The map components use React contexts, portals, forwardRef/useImperativeHandle, and MapLibre style expressions to manage markers, popups, routes, arcs, GeoJSON layers, clustering, and hover states. Blocks under `src/registry/blocks/` demonstrate realistic use cases (analytics maps, store locators, logistics networks, uptime monitoring) with hardcoded sample data and external data sources like OSRM routing and Natural Earth GeoJSON. These demo blocks are primarily illustrations, not data pipelines. Maintenance is active, but the codebase has risks: the core map library is a ~3000-line monolith, the distributable JSON registry duplicates source files, and the stack is heavily bleeding-edge (Next.js 16, React 19.2.3, Tailwind v4). No automated tests appear in the repository. Overall it is a polished, effectively structured component library with a strong distribution model, but its craftsmanship is constrained by the single-file monolith and build fragility.
This repository is a mature, well-structured JavaScript library that dynamically generates HTML forms from JSON Schema definitions. It is a client-side library that can be used as a standalone script or npm package. The core architecture is built on an abstract base class (`AbstractEditor`) with a rich plugin system for editors (string, number, array, object, etc.), themes (Bootstrap 3/4/5, Tailwind, Spectre, etc.), icon libraries, and template engines. It includes a full JSON Schema validator with support for draft-04, 07, and 2020-12 keywords, plus custom validators. The codebase demonstrates strong engineering practices: event-driven communication, extensible resolver patterns, and a modular design that separates concerns. However, the project is explicitly in maintenance mode, with active development moved to a fork (Jedison). This means new features are not expected, but critical bug fixes and security patches are still accepted. The codebase shows some technical drift: several third-party integrations (e.g., SimpleMDE, SignaturePad v1) are outdated, some themes (Foundation 3, Bootstrap 2) are legacy, and the code uses ES5 patterns. The test suite is extensive, with both unit tests (Jasmine) and end-to-end tests (CodeceptJS) covering many edge cases and real-world issues. Overall, it is a high-quality library for its domain, but its maintenance mode status limits its future viability for new projects.
This repository provides a full port of AndroidX ConstraintLayout and MotionLayout for Compose Multiplatform, enabling declarative, constraint-based layouts and keyframe animations across Android, iOS, Desktop, macOS, and Web (Wasm). The library is published as `tech.annexflow.compose:constraintlayout-compose-multiplatform` and includes a complete Kotlin Multiplatform implementation of the core constraint solver, motion engine, JSON5 parser, and Compose DSL. It supports both inline DSL and JSON-based constraint definitions, with experimental MotionLayout for animated transitions between constraint sets, including swipe gestures, keyframes, and custom easing curves. Architecturally, the project is split into a `compose` module containing the Compose-specific composables (`ConstraintLayout`, `MotionLayout`, `ConstraintSet`, `Transition`) and a `core` module that houses the platform-agnostic constraint solving engine (`LinearSystem`, `SolverVariable`, `ConstraintWidget`), motion interpolation (`CurveFit`, `Easing`, `StopLogicEngine`), and a custom JSON5 parser (`CLParser`). The sample app demonstrates various use cases such as collapsible toolbars, carousels, puzzle layouts, and swipe-driven transitions. The codebase is well-tested with extensive unit tests for both the core engine and Compose integration, and includes CI pipelines for building and validation. The library is actively maintained with recent commits and responsive issue triage. While it is a port of an AndroidX library, it has been adapted for multiplatform use with platform-specific expect/actual declarations for logging, weak references, and debug rendering. The code exhibits high craftsmanship in areas like the custom linear solver, motion interpolation algorithms, and the JSON parser, making it a valuable resource for developers needing advanced layout and animation capabilities in Compose Multiplatform projects.
undraw-ui is a Vue 3 UI component library built on top of Element Plus. It provides a set of custom components including Comment, Fold, Search, Chat, Editor, Table, Form, and CRUD interfaces. The repository is structured as a monolithic library with a Vite-based build system and TypeScript support. It includes a demo application for showcasing components and VitePress documentation. The codebase demonstrates a solid implementation of common UI patterns, with a focus on data-heavy components like comments and tables. While it lacks unit tests, the component structure is generally clean, utilizing Vue 3 Composition API and slots for customization.
Layui is a classic web UI component library written in pure HTML, CSS, and JavaScript. It provides a comprehensive set of 20+ interactive components including tables, forms, modals, date pickers, menus, trees, and more. The library follows a modular architecture with ES modules, a core component base class, and a consistent lifecycle (render/reload/destroy). It includes built-in internationalization, a resource loader, a simple front-end router, and a template engine (laytpl, though deprecated). The codebase is actively developed (v3.0.0-alpha.3) with modern build tooling (Rollup, PostCSS, ESLint) but retains some legacy patterns and a dependency on jQuery. The component base class and popup system are well-architected and reusable, while some modules (table, treeTable) are large and monolithic. Testing is incomplete, with unit tests marked as placeholder and visual tests requiring manual execution.
This repository is an 'awesome list' — a curated reference index, not a software application or data pipeline. The only source content is README.md and a cover image; there is no executable code, build system, CI configuration, dependency manifest, or test suite. The README renders on GitHub as a single structured markdown table cataloging roughly 130 design systems from organizations including Adobe, Google, IBM, Microsoft, Shopify, GOV.UK, Salesforce, and many others. Each entry records four attributes: coded Components, Voice & Tone guidance, Designers Kit availability, and public Source code links. Editorial scaffolding includes tag definitions, a note distinguishing design systems from UI/pattern libraries, and a licensing caveat that open-source status does not guarantee free reuse. The closest classification is 'application' as a static documentation/curation artifact, though it is genuinely neither an application nor a data-research repository — the README's table could be parsed as a small dataset, but no pipeline exists around it. Maintenance is demonstrably active: the last commit is recent, only 9 issues are open against 26k stars, and the table contains newly launched design systems (e.g., Cloudflare Kumo, HeroUI, shadcn/ui, Semrush Intergalactic, AWS Cloudscape) that could only have been added recently. The contribution model is pull-request based, and the table format has stayed consistent while the catalog grew. For its genre, editorial quality is good: a consistent column schema, clean symbols, stable anchor links to external documentation, and clearly separated source-code hosts. There are no highlighted components. A markdown table is the entire artifact, so nothing can be extracted as a reusable code module and there is no architecture to assess. The practical reuse value is as a discovery index: an AI agent or engineer could scrape the table to build a design-systems directory dataset, since the format is regular and machine-parseable. Technical drift is low by definition — plain markdown does not age — though a handful of external links point to discontinued projects (e.g., Pivotal, Materialize, Bolt), which is a content-level concern rather than a codebase one. This is a high-value reference resource for frontend engineers and designers, but it is not an engineering codebase.
react-dropdown-tree-select is a React component library that provides a dropdown interface for selecting items from hierarchical tree data. The component supports multiple selection modes (multi-select, simple select, radio select, and hierarchical), displays selected items as tags/pills, includes search functionality with progressive filtering and debouncing, offers keyboard navigation, and implements accessibility features through ARIA attributes. The architecture centers around a DropdownTreeSelect component that uses a TreeManager to handle tree state and operations, with supporting components for rendering trees, nodes, tags, and controls. Performance optimizations include virtualized rendering via react-infinite-scroll-component, search debouncing, and progressive filtering that reduces search scope with each keystroke.
WeUI is a UI library designed to match WeChat's native visual experience for web pages and mini-programs. It provides a comprehensive set of reusable CSS-based components (buttons, cells, forms, dialogs, etc.) with WeChat-specific styling and interactions. The architecture is modular, with core styles written in LESS and organized by component type, accompanied by extensive HTML examples demonstrating usage. The library relies on external tools like Gulp, Less, and Autoprefixer for building and preprocessing, but produces standalone CSS output for consumption in web projects.
mdui is a comprehensive Web Component library implementing Material Design 3 (Material You). It provides over 30 reusable UI components (buttons, dialogs, navigation, forms, etc.) built with Lit, supporting dynamic color theming, dark/light modes, and localization across 60+ languages. The library is framework-agnostic and can be used directly in HTML or with any frontend framework. It includes a bundled jQuery-like utility (@mdui/jq) for DOM manipulation, a Model Context Protocol (MCP) server for AI-assisted development tooling, and IDE plugins for VS Code and JetBrains. The codebase is well-structured with a monorepo managed by pnpm, featuring shared mixins, controllers, and decorators that promote consistency across components. The project is actively maintained with recent commits, comprehensive documentation, and a large demo site.
WPFDevelopers is a comprehensive WPF custom control library (NuGet package `WPFDevelopers`) that provides ~50+ themed UI controls, styles, effects, window chrome customization, system tray integration, screen capture, charts, loading indicators, and utility helpers. It also includes a demo application showcasing each control. The library targets a wide range of .NET versions (4.0 through 10.0) and integrates Win32 interop for advanced shell features. While containing some vendored code (Microsoft Expression Blend SDK) and occasional duplication, the library demonstrates solid engineering practices with reusable controls, attached behaviors, and a consistent theming infrastructure. It is actively maintained with CI builds for multiple frameworks.
This repository provides 40+ icon pack libraries for WPF (and UWP) applications under the MahApps.Metro ecosystem. The core architecture defines base classes (PackIconControlBase, PackIconDataFactory, converters) that each icon pack extends with auto-generated code: an enum of icon identifiers (e.g., PackIconFontAwesome6Kind), a PackIcon control, markup extensions, and converters. Icon path data is embedded as JSON resources and loaded via a singleton factory. The code is predominantly auto-generated from upstream icon sets (Font Awesome, Material Design, Bootstrap, etc.), leading to a highly repetitive structure across packs. The library is actively maintained with recent commits, CI/CD pipelines, and semantic versioning. While the code is well-organized and functional, the heavy reliance on code generation reduces craftsmanship in the per-pack files; the genuinely reusable components are the base classes in the Core project, which implement icon scaling, flip, rotation, spin animation, and data loading patterns.
Material Design Lite (MDL) is a front-end library that implements Google's Material Design in vanilla CSS, JavaScript, and HTML. It provides a collection of reusable UI components such as buttons, cards, text fields, sliders, and layout systems, all styled with BEM-like class names (e.g., `mdl-button`, `mdl-js-button`). The library is designed to be lightweight and dependency-free, with components enhanced via a central `componentHandler` that upgrades static DOM elements with interactive behavior. The project is in maintenance mode; active development has shifted to Material Components for the web (MDC Web). The codebase follows a consistent component pattern: each component defines a JavaScript class with `init()`, `CssClasses_`, and `Constant_` properties, and registers itself with the global `componentHandler`. The ripple effect is a standalone component reused by many other components. Although the library is stable and functionally complete, the codebase shows significant technical drift: it uses prototypal inheritance, Gulp 3, Babel presets for ES2015, and lacks modern module bundling (ES modules, webpack). The documentation site is self-hosted and uses Jekyll, but the hosted version is retired. Templates in `templates/` provide full-page examples (blog, portfolio, dashboard) for quick prototyping.
dayu_widgets is a Python UI component library for PySide2/PySide6/PyQt5, inspired by Ant Design. It provides a cohesive set of themed widgets (buttons, inputs, tables, menus, dialogs, etc.) with light/dark themes and customizable primary colors. The architecture is modular: each widget lives in its own module, a central theme object applies QSS styling, and mixin decorators add cross-cutting behavior. The package is distributed via PyPI and includes a demo launcher (`python -m dayu_widgets`) plus 30+ example scripts. Under the hood, the library implements a QSS template engine with @-variable substitution, an AntDesign-based color palette generator, a Qt Model/View data layer with lazy loading and filtering, and a field-mixin data binding system. These components are the most reusable parts and demonstrate solid engineering. However, test coverage is limited to a subset of widgets, and the codebase contains numerous workarounds for Qt binding differences (PySide2 vs PySide6 vs PyQt5) that add fragility. The project is actively maintained with recent commits, CI, and semantic versioning.
Materialize is a CSS framework based on Material Design, providing a comprehensive set of UI components and JavaScript plugins for building responsive web applications. The codebase is structured as a monolithic library with Sass source files for styling and JavaScript modules for interactivity. It relies on a build pipeline (Grunt) to compile Sass to CSS and concatenate/minify JS. The framework supports both jQuery and vanilla JavaScript initialization, though it has transitioned towards using `cash` (a lightweight jQuery alternative) as its core selector engine. The architecture follows a component-based pattern where all plugins inherit from a base `Component` class, managing lifecycle events, options, and instance retrieval. Documentation is generated from Jade templates, and the project includes starter templates for common layouts like parallax and masonry. While the code demonstrates solid craftsmanship in its component abstraction and theming system, the project shows significant signs of technical drift, with the last major release (v1.0.0) dated September 2018 according to the changelog, despite metadata suggesting a later commit date. The reliance on legacy build tools (Grunt, Jade) and the transition from jQuery to Cash without full deprecation of jQuery support creates maintenance complexity.
Cube UI is a Vue.js 2.x-based mobile UI component library providing reusable components for building mobile/web applications. It offers a comprehensive set of touch-optimized UI elements including buttons, forms, pickers, popups, drawers, and layout components. The library follows Vue plugin patterns with installable components and supports both declarative template usage and programmatic invocation via a create-api pattern. It includes internationalization support, form validation, and integrates with better-scroll for advanced scrolling components. The repository contains source code, build outputs, documentation, examples, and unit tests.
This repository is a web component library focused on accessibility, providing custom HTML elements for building inclusive web applications. It implements alternative input methods including standard mouse/keyboard/touch and pose/body tracking using TensorFlow's PoseNet model. The architecture follows web component principles using LitElement and Polymer, with a clear hierarchy of base classes (AbstractInputElement, AbstractUIElement) and specialized components for various UI patterns. The library emphasizes accessibility features like ARIA support, keyboard navigation, and screen reader compatibility. The codebase demonstrates strong craftsmanship in its utility implementations, particularly in coordinate transformation handling (mouse-position.ts), vector mathematics (vec2.ts), and general-purpose helper functions (utils.ts). The webcam integration (webcam.ts) shows proper resource management and lifecycle handling. However, the library suffers from significant technical drift due to outdated dependencies (lit-element 0.5.2, tfjs 0.13.0, typescript 3.1.6), which would require substantial updates for modern use. While the core architectural patterns are sound, the dependency versions limit practical reusability without migration work.