This repository is a monorepo React UI component library consisting of two main packages: `smarthr-ui` (core UI components) and `@smarthr/smarthr-ui-charts` (charting components). It provides a comprehensive set of accessible, internationalizable UI components built with TypeScript, Tailwind CSS, and modern React patterns. The library emphasizes accessibility, theming, and developer experience, with extensive testing (unit, visual regression, E2E) and Storybook documentation. Key architectural features include a design token system, custom hooks for common patterns (useLatest, usePortal), and a focus on composability.
This is a production-grade React library that wraps Airbnb's lottie-web to render After Effects animations. It provides declarative React components (<Lottie>, <LottieSvg>, <LottieLight>), hooks (useLottie, useLottieSvg, useLottieLight), a full player UI with play/pause/seek/speed controls (LottieControls), and an interactivity layer for scroll-driven or visibility-triggered animations. The library ships three build variants optimized for bundle size, all with 100% statement coverage and strict TypeScript types. It supports both React 18 and 19, is SSR and React Server Component safe, and enforces per-import size budgets via CI. The codebase demonstrates an unusually rigorous engineering culture with no technical debt shortcuts.
Chakra UI is a React component library that provides accessible, customizable UI components with a design system foundation. The monorepo contains the core component library (@chakra-ui/react), styling system (Emotion-based with Panda CSS preset), CLI tools for project scaffolding and codemods for migration, a Next.js documentation site, an interactive example gallery, framework sandboxes for Next.js/Remix/Vite integration, and an MCP server for AI tool access. The architecture emphasizes composable APIs, theme-driven design via design tokens, and comprehensive accessibility coverage. Key entry points include the core library index, styled system factory, CLI commands, documentation layout, example compositions, and MCP server entry point.
Radix Themes is a monorepo containing a React component library built on Radix UI primitives and a Next.js playground application for demonstration and testing. The library provides accessible, themeable UI components with support for responsive values, variant styling, and a flexible theme system. The architecture separates concerns through a prop definition system, helper utilities for style extraction and merging, and a theme context. The playground showcases components and includes visual regression testing via Playwright.
react-native-reusables is a React Native UI component library that adapts the shadcn/ui copy-paste component model to React Native. It is a pnpm/Turborepo monorepo containing a Next.js/Fumadocs documentation site (apps/docs), an Expo SDK 56 showcase app for live cross-platform previews (apps/showcase), a scaffolding CLI built on Effect-TS (apps/cli), and a shared registry package (packages/registry) with roughly 30 styled components — Button, Dialog, Select, Accordion, Dropdown Menu, Tooltip, and others — plus higher-level authentication blocks (sign-in, sign-up, forgot/reset password, verify email) with optional Clerk integration. There is no data science or analytics code; it is purely a component library and developer-tooling project. The central architectural decision is dual styling-engine support: every component is implemented twice, once for Nativewind and once for Uniwind, both wrapping @rn-primitives (Radix-style primitives ported to React Native). Components use class-variance-authority for variant management, a Slot primitive for asChild composition, a TextClassContext that propagates text styles down component hierarchies (a non-obvious workaround for React Native's lack of CSS style cascading), and a portal/overlay system that uses iOS FullWindowOverlay on native platforms and fragments on web. The target platforms are iOS, Android, and web via Expo. Component source is serialized into shadcn-compatible registry JSON files (public/r/nativewind/*.json and public/r/uniwind/*.json) consumed by both the docs site and the CLI, with catalogs.dev YAML metadata driving publishing and discoverability. The CLI's init/add/doctor commands wrap the shadcn installation machinery with additional project intelligence: the doctor command validates dependencies and detects deprecated file patterns, and project-config.ts parses a project's metro.config.js to determine whether Nativewind or Uniwind is active before writing components.json. The add command delegates component installation to shadcn. Several auth blocks contain explicit TODO placeholders for navigation and form-submission logic that consumers must implement. The dominant maintenance burden is the deliberate duplication across the two styling engines — every API or visual change must be mirrored in both variants, and the generated registry JSON can drift from source files. Dependencies (Expo SDK 56, React Native 0.85.3, Nativewind 4.2.2, Uniwind 1.6.3) are current, and the repo tracks its ecosystem proactively.
PrimeFaces is a mature, widely adopted UI component library for Jakarta Faces (JSF). In production it provides server-side JSF components (DataTable, Tree, DatePicker, Menu, Dialog, etc.) paired with client-side JavaScript/TypeScript widgets, enabling AJAX-driven, themeable web UIs for Java enterprise applications. The architecture is a multi-module Maven project: the core `primefaces` module contains component classes, renderers, models, events, validators, and utilities; `primefaces-cdk` is a custom annotation-driven code generation kit that produces component base implementations and taglib metadata; `primefaces-showcase` is a demo web application; and `primefaces-integration-tests` plus `primefaces-selenium` provide a Selenium-based testing framework with reusable page-object components. The library is distributed as a JAR and consumed by embedding it in JSF web applications, with entry points being the JSF component tags and the `PrimeFaces` JavaScript API.
This repository is a Next.js application that serves both as a documentation site and a registry server for a retro 8-bit styled UI component library, built on top of shadcn/ui primitives. It provides dozens of copy-paste components (buttons, cards, dialogs, health bars, etc.) and pre-built page blocks (heroes, features, pricing, gaming HUDs) distributed via a shadcn-style registry (`shadcn add @8bitcn/...`). The project also includes two full, playable arcade games (Brick Breaker and Crate Pusher) used as creative 404 pages, with well-tested, deterministic game engines. The codebase demonstrates strong engineering practices: pure immutable game state reducers, fixed-timestep physics, accessibility-focused UI, and a custom cold-path benchmarking harness used to optimize development compilation times by 27.7%. The architecture is a monorepo-like structure within a single Next.js app, with the component library living as source files that are copied into user projects via the registry mechanism.
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.
Patina is a local-first desktop time tracking application built with the Tauri framework (React frontend + Rust backend). It automatically monitors foreground application and web usage, providing activity classification, data visualization through dashboards and heatmaps, productivity tools (Pomodoro timer, reminders), and data export/backup capabilities. The application emphasizes privacy with local-first data storage while offering optional remote backup via WebDAV. It features a modular architecture with clear separation between frontend/UI, backend/services, and platform abstractions, communicating through Tauri IPC.
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 React-based UI component library (@alifd/next) designed for building enterprise backend systems. It provides over 50 reusable UI components (Button, Input, Table, Form, etc.) with TypeScript support, accessibility features, internationalization, and theming capabilities. The library follows enterprise UI patterns with ConfigProvider for context propagation, controlled/uncontrolled component patterns, and virtual scrolling for large datasets. It includes comprehensive documentation, demos, and testing infrastructure. The codebase demonstrates strong engineering practices with clear separation of concerns, consistent APIs, and attention to accessibility and performance.
Spectrum UI is a comprehensive React component library built with Next.js, Tailwind CSS, and Framer Motion. It provides over 250 animated, accessible components that can be installed via CLI or copied directly into projects. The repository includes a documentation site, marketing pages, a pro/template dashboard, and an MCP server for AI-assisted component discovery and installation. The architecture follows a monorepo structure with shared utilities, a component registry, and separate sections for docs, marketing, and user-facing features. Key technical strengths include a robust class-merging utility, reusable animation presets, a live-preview documentation system, and well-abstracted UI primitives. However, the codebase exhibits some maintenance challenges due to dependency volatility, duplication between registry and source components, and tight coupling with external services like Supabase and PostHog.
ember-cli-materialize is an Ember.js addon that provides Materialize CSS components as Ember components. It allows developers to use Materialize UI elements (buttons, cards, modals, forms, etc.) in Ember applications by wrapping them in Ember-friendly components. The addon imports Materialize CSS and fonts, provides a comprehensive set of UI components, and handles the integration between Ember's runloop and Materialize's JavaScript plugins. It follows Ember CLI addon conventions with components, templates, styles, initializers, and services organized in standard directories.
This is a React component library and showcase application built with Vite. It provides interactive examples of various UI components including accordions, buttons, cards, carousels, controls, dropdowns, modals, navbars, sidebars, tables, and widgets. The application uses react-router-dom for client-side routing, with each component example accessible via a dedicated route. The architecture follows a standard React SPA pattern with components organized by type in the src/components directory. Each component includes its implementation file, example usage file, and associated styles. The project demonstrates modern React practices including functional components with hooks, proper state management, and integration with animation libraries like GSAP and Framer Motion.
This repository is a full-stack web application starter kit built with Vue 3, TypeScript, and Vite. It includes a reusable UI component library (@x/ui), a mock backend (Fastify) for development, and end-to-end tests (Playwright). The application demonstrates common patterns for admin dashboards, including authentication, form validation, data tables, charts, and internationalization. The UI library provides over 50 components (buttons, forms, tables, notifications, etc.) and utilities (HTTP request handling, queue guard, static table operations) designed for reuse in other projects. The monorepo structure (using pnpm workspace) separates the frontend application, UI library, and mock backend, enabling modular development.
Taro UI is a multi-platform UI component library designed for the Taro framework, enabling developers to build applications that run on WeChat Mini Program, H5, React Native, Alipay, and other platforms with a single codebase. The library provides over 40 reusable UI components (including form controls, layout elements, navigation tools, and feedback mechanisms) with consistent APIs across platforms. Architecture follows a monorepo structure with core components in packages/taro-ui/src, platform-specific adaptations in packages/taro-ui/rn, documentation built with VitePress, and multiple demo applications showcasing usage. The library relies on Taro as a peer dependency and utilizes utilities like classnames and dayjs for cross-platform compatibility. Recent active maintenance has included migration to Function Components + Hooks, build system upgrades to tsup, TypeScript 5.3 adoption, and CSS precompilation efforts to address prior technical debt.
This repository is a production-grade cross-platform mobile application scaffold built on uni-app x, Vue 3, and TypeScript. It provides a comprehensive UI component library (cool-ui) with over 50 components covering forms, layout, data display, feedback, navigation, and utilities, all designed for reuse across Web, Android, iOS, and mini-programs. The project includes a full demo app showcasing each component, template pages for e-commerce (shop, cart, address, product detail) and social features (posts, chat, user profile), as well as a settings and i18n system with 7 languages. Core architectural patterns include a reactive service layer with token-refresh support, a custom router with auth guards, a theme system (light/dark), a PassThrough prop pattern for deep component customization, and a plugin system for touch, locale, and device features. The code is well-structured with typed props, hooks, and clear separation of concerns, though it relies on a beta plugin (`@cool-vue/unix`) and extensive platform-specific conditionals (#ifdef) that may introduce future maintenance drift. The repository is primarily an application scaffold, not a data research project. It contains no notebooks, data pipelines, or ML components. Its value lies in being a ready-to-use starter for building multi-platform apps with a rich UI library and common business modules. While not groundbreaking, the code demonstrates solid engineering practices, good modularity, and attention to developer experience (auto-imports, TailwindCSS integration, AI-assisted translation scripts). The library's components are individually reusable and can be extracted with minimal effort, making it a practical resource for app developers targeting the uni-app ecosystem.
Astro Theme Pure is a blog and documentation theme for the Astro static site generator. It provides a comprehensive set of UI components, layouts, and integrations (comment systems, search, SEO) to build content-driven websites. The theme is structured as an Astro integration (`packages/pure/index.ts`) that consumes user configuration from `src/site.config.ts` and enhances Astro's content collections with plugins for markdown processing (reading time, image zoom, tabs, steps). It features a UnoCSS-based styling system, dark/light theme switching, and optional integrations like Waline for comments and Pagefind for search. The architecture emphasizes slot-based composition, utility-first styling, and virtual module injection for build-time configuration.