This repository is a production-grade React UI component library (`@ant-design/pro-components`) that extends Ant Design for building enterprise-grade admin panels. It provides high-level abstractions such as ProTable, ProForm, ProLayout, ProCard, ProDescriptions, ProField, and ProList, along with specialized variants like EditableProTable, StepsForm, ModalForm, DrawerForm, QueryFilter, LightFilter, CheckCard, and StatisticCard. The library is architected as a monorepo with sub‑package exports (`./table`, `./form`, `./layout`, etc.), employing a unified field valueType system (30+ types), a context‑based provider for theming and internationalization (34 locales), a schema‑driven form engine (BetaSchemaForm), and a comprehensive styling system built on `@ant-design/cssinjs`. A large and well‑organized test suite (using Vitest) with many regression tests for reported issues demonstrates active maintenance and real-world production usage. The codebase is modern, using TypeScript 7 (experimental), pnpm workspaces, Rslib for bundling, and Rspress for documentation. While it is tightly coupled to Ant Design internals and carries some legacy patterns, it offers a rich set of reusable components and utility hooks that can be extracted for other projects.
ECC (Everything Claude Code) is a comprehensive meta-harness toolkit for AI coding assistants. It provides a universal install system, lifecycle hooks, skill management, multi-agent orchestration, evaluation harnesses, and safety validation across multiple agent IDEs (Claude Code, Codex, Cursor, Gemini, OpenCode, and others). The codebase is primarily a Node.js CLI application (published as `ecc-universal`) with secondary Python and Rust components. It includes a sophisticated hook engine (pre/post bash, session lifecycle, tool use), a manifest-driven installer with ownership tracking and path-safety guards, an eval-harness framework with deterministic replay and effect-class isolation, a skill evolution system with provenance tracking, and a multi-agent proximity coordination system. The repository also bundles a large collection of domain-specific skills (video production, compliance checking, visa document translation, financial market data) and extensive documentation translated into multiple languages. While the core architecture is well-structured and demonstrates high craftsmanship in security-critical components, the codebase suffers from some duplication (e.g., taste-application/taste-distillation skills), legacy shims, and a sprawling surface area that increases maintenance burden. The Rust TUI control-plane (`ecc2/`) is explicitly alpha. Overall, it is a production-grade, actively maintained platform with strong engineering practices in its core modules.
This repository is a comprehensive collection of React interview questions and coding exercises, designed as an educational resource for developers preparing for React interviews. It contains over a dozen standalone React projects built with modern tooling (Vite, TypeScript, React 19), each demonstrating a specific UI pattern or hook implementation. The codebase is well-organized into three main sections: a coding-exercise app with a registry pattern for interactive problem-solving, a coding-hooks library of reusable custom hooks (useDebounce, useFetch, useLocalStorage, etc.), and a set of coding-projects (accordion, autocomplete, carousel, data table, infinite scroll, modal, nested comments, shopping cart, star rating, theme switcher, todo, tree view). The projects are cleanly implemented with TypeScript, proper state management, and accessibility considerations. While primarily educational, the custom hooks and several UI components are production-quality and directly reusable in other projects.
axios-hooks is a React library that provides custom hooks for making HTTP requests using axios, with built-in caching, request cancellation, server-side rendering (SSR) support, and configurable defaults. The library exposes a default `useAxios` hook and a `makeUseAxios` factory to create pre-configured instances with custom axios versions, cache implementations, and default options. The hook manages request lifecycle through React's `useReducer`, automatically executes requests on component mount (unless `manual` is true), and supports manual refetch with optional cache usage. It integrates with `lru-cache` for response caching, allowing both client-side caching and SSR hydration via `serializeCache`/`loadCache`. The architecture is a single-component library with a clean API surface. Key entry points are the default export `useAxios` and named exports `configure`, `makeUseAxios`, `loadCache`, `serializeCache`, and `clearCache`. The primary data flow is: component calls `useAxios(config, options)`, which triggers an axios request (with optional cancellation via `AbortController`), stores the response in cache, and updates component state (`loading`, `data`, `error`, `response`). External dependencies are `axios` (peer), `react` (peer), `lru-cache`, and `dequal` for deep equality checks. The library is well-tested with Jest and includes TypeScript type definitions. The code exhibits quality engineering practices: proper use of React hooks (useMemo, useCallback, useRef, useReducer), deep comparison memoization to avoid unnecessary re-renders, abort controller for request cancellation, and a factory pattern (`makeUseAxios`) that enables multiple independent hook instances. The test suite covers edge cases like cancellation, cache behavior, SSR, and option change detection.
The Network Media Library plugin for WordPress Multisite provides a central media library shared across all sites in the network. It achieves this by designating one site as the central media library and temporarily switching the context to that site during media operations (upload, insertion, editing, etc.). The plugin hooks into numerous WordPress actions and filters to intercept media-related requests and redirect them to the central site. It also includes compatibility layers for popular third-party plugins like Advanced Custom Fields and MultilingualPress to ensure they work correctly with the shared media library. The code is organized into a single main file with several classes encapsulating specific functionalities, such as managing context switches, preserving post thumbnail IDs during save operations, and handling ACF field rendering.
JSONy is a high-performance JSON parsing and serialization library for the Nim programming language. It bypasses the intermediate JSON node step used by the standard library, directly converting between JSON strings and Nim data structures for improved speed and reduced garbage collection pressure. The library features a flexible hook system (newHook, postHook, parseHook, dumpHook, etc.) that allows customization of the serialization and deserialization process for complex scenarios like handling missing fields, renaming fields, processing enums, and working with JSON-in-json. It supports a wide range of Nim types including primitives, sequences, arrays, objects, ref objects, options, enums, tuples, sets, tables, and custom types via hooks. The implementation avoids StringStream overhead by working directly with memory buffers and parses numbers without intermediate string allocations.
TermUI is a comprehensive TypeScript monorepo providing a full-featured terminal UI framework for building rich, interactive command-line applications. It includes a custom JSX runtime with hooks, reconciliation, and portals; a theme engine (TSS) with CSS-like syntax and 26 built-in themes; a widget library spanning layout, input, display, data visualization, and feedback components; a motion system with spring physics and composable animations; a client-side router; a Zustand-like state store; adapters for external integrations (AI, Git, GitHub, clipboard, keychain); real-time system data hooks (CPU, memory, disk, Docker); a CLI scaffolding tool; and a dev server with hot reload. The framework is designed to offer a React-like development experience for terminal UIs, supporting JSX/TSX, keyboard and mouse input, focus management, accessibility (OSC 133), and unicode/ASCII fallbacks across 14+ packages with over 5000 tests.
graphql-hooks is a lightweight React GraphQL client library that provides a set of hooks for querying, mutating, and subscribing to GraphQL endpoints. It is designed as a minimal yet feature-rich alternative to Apollo Client, with a focus on small bundle size (22.9 kB gzipped). The library is organized as a Lerna monorepo containing the core package (`graphql-hooks`), an in-memory cache (`graphql-hooks-memcache`), SSR utilities (`graphql-hooks-ssr`), and a Babel plugin for compile-time GraphQL query extraction (`babel-plugin-extract-gql`). In production, the system operates as a client-side GraphQL executor within React applications. The primary entry points are React hooks: `useQuery`, `useMutation`, `useManualQuery`, and `useSubscription`. These hooks internally use `GraphQLClient` to send HTTP or WebSocket requests, passing through an optional middleware pipeline. The client supports caching via a pluggable interface (defaulting to `graphql-hooks-memcache` with LRU eviction and TTL), automatic refetching after mutations, file uploads via the GraphQL multipart spec, and server-side rendering by pre-fetching query results and injecting initial state into the HTML. Key data flows begin when a React component calls a hook. The hook interacts with `GraphQLClient`, which applies middleware (e.g., Automatic Persisted Queries or custom interceptors) before sending the request. Responses are cached and returned to the component. Mutations can optionally trigger refetches of related queries via an event emitter. The architecture promotes separation of concerns via middleware, a clean cache API, and support for multiple transport layers (HTTP, WebSocket, Full-WS). External dependencies include React (peer), `graphql-ws` or `subscriptions-transport-ws` for subscriptions, and `formdata-node` for file uploads in Node environments.
This repository is a collection of 14 small to medium React projects, built as part of a popular Spanish YouTube course (midudev). Each project focuses on a specific React concept or real-world pattern: from basic component state and effects (Twitter follow card, tic-tac-toe, mouse follower) to advanced topics like custom hooks, fetching data, complex state management with useReducer and useContext, TypeScript integration, routing (including a custom router), Redux Toolkit, React Query, Zustand, and CSS-in-JS with vanilla-extract. The projects are self-contained, well-structured, and progressively build complexity, making this an excellent learning resource for intermediate React developers. The code quality is professional: modern React (18), functional components, hooks, TypeScript in later projects, and some tests (Playwright, Vitest). The custom router (midu-router) is published as an npm package and demonstrates non-trivial patterns like dynamic route matching with path-to-regexp, lazy loading, and i18n. Other reusable gems include a generic debounce hook, a Redux middleware for optimistic updates with rollback, and a Zustand store with persistence. While not a single production application, the repository serves as a practical textbook of React patterns. Developers can extract individual components or hooks into their own projects with minimal adaptation.
This is a TypeScript-first React library (`react-unity-webgl`) that embeds Unity WebGL builds into React applications. The `module/source` directory contains the actual npm package: a `Unity` forward-ref component that mounts a canvas and manages the Unity instance lifecycle, plus custom hooks (`useUnityContext`, `useUnityLoader`, `useEventSystem`, `useUnityMetricsInfo`) that encapsulate script loading, two-way Unity↔React event bridging, fullscreen/pointer-lock/screenshot controls, and performance metric polling. The repo is a monorepo with a Docusaurus documentation site (versioned v5 through current) and a Vite + React integration-test harness backed by two prebuilt Unity test projects (2022.1 and 6000.1). Architecturally, Unity instances push events to React through a global `dispatchReactUnityEvent` function wired into the hook-level event system; React sends messages back through `UnityInstance.SendMessage`. The library has no runtime dependencies beyond React peer support, relying on Unity's generated loader/framework/wasm output and on browser WebGL, IndexedDB, and sensor APIs. A notable implementation detail is a cleanup-on-unmount routine that swaps in a temporary detached canvas to safely call Unity's `Quit()` method. The codebase is well organized and strongly typed, with clear separation between components, hooks, and types. CI workflows for CodeQL, module validation, and documentation validation are present, and the last commit is recent. However, there are no automated unit tests (only a manual integration app), the lint script is a placeholder, CI uses older action versions, and the Unity version-specific bridge code will need maintenance as Unity evolves.
Wirebrowser is an Electron desktop application that provides an integrated runtime instrumentation platform for web applications, built entirely on the Chrome DevTools Protocol (CDP). In production, it acts as a unified debugger, memory inspector, network interceptor, and automation runner for JavaScript running in Chromium-based browsers. The application launches a headless or headful Chrome instance via Puppeteer-core, attaches CDP debuggers to multiple pages, and presents a rich GUI (React, Ant Design, Monaco Editor, AG Grid) through an Electron window. The architecture follows a modular event-driven design: core back-end modules (Heap, Debugger, Network, Automation) are loaded by a ModuleManager and communicate with the front-end via custom DOM events and Electron IPC. The debugger module implements a sophisticated hook system that injects user-defined JavaScript callbacks on function entry/leave/return without monkeypatching, using CDP breakpoints and a state machine to serialize asynchronous events. The heap module supports both live object search (via injected QueryObjects) and offline snapshot analysis with object similarity matching (Jaccard/Dice/SimHash) for origin tracing. Key data flows include user-defined automation scripts (Node-side or browser-side) that interact with pages through the WB.Node and WB.Browser APIs, network requests that can be intercepted and modified in real-time, and memory snapshots that are queried for structural matches across multiple snapshots (BDHS). External dependencies are heavy: Puppeteer (bundled Chrome), AG-Grid (community), Monaco Editor, Ant Design, lowdb, and several CDP-specific features that lock the tool to Chromium. The project is primarily targeted at security researchers, reverse engineers, and advanced frontend developers who need introspection beyond standard DevTools.
This repository is the documentation site for Factory, an AI-native software development platform centered on the Droid CLI. It contains bilingual (English and Japanese) documentation covering CLI usage, enterprise deployment, integrations, skills, hooks, and benchmarks. The repository also includes CI/CD workflows, changelog automation scripts, and a translation pipeline. While no application source code is present, the documentation is highly structured and includes reusable patterns for skill definitions, hooks, and plugin packaging. The codebase is actively maintained with frequent updates, but exhibits moderate technical drift due to rapid version churn, model name instability, and bilingual documentation divergence.
This is a React library for feature toggle management, providing components and higher-order components to conditionally render UI based on enabled features. The library exposes a `FeatureToggles` provider, a `Feature` consumer component (with render prop or component swapping), a `configureFeature` curried HOC for creating pre-configured feature components, a `withFeatures` HOC to inject the features list, and a `useFeatures` hook for functional components. The code is well-structured, thoroughly tested, and follows a clean context-based architecture. However, the repository is clearly unmaintained: it targets Node 8, uses outdated Babel 6 presets, React 16, and has no dependency updates in years. The technical drift is high, making it risky for new projects without significant modernization. Despite this, the core patterns remain valid and could be extracted or used as a reference for implementing feature toggles in modern React.
Geist UI is an archived React UI component library and design system inspired by Vercel's design language. It provides a comprehensive set of 40+ components (Button, Card, Modal, Table, Input, Select, etc.), a flexible theming system with light/dark presets and custom theme creation, a proprietary scaling system for responsive sizing, and utility hooks (useClipboard, useClickAway, useKeyboard, useToasts, etc.). The repository also contains a full documentation site built with Next.js and MDX, featuring interactive playgrounds, attribute tables, and bilingual content (English/Chinese). The library is published as @geist-ui/core and supports tree-shaking, server-side rendering, and integration with Next.js, Remix, Create React App, and webpack. However, the project is archived and no longer receives active updates; its reliance on styled-jsx, deprecated test utilities (Enzyme), and older dependency versions pose compatibility risks for modern React and bundler ecosystems. The codebase demonstrates solid engineering practices with compound components, context-driven state management, and well-isolated hooks, making many parts reusable despite the project's dormant status.
This repository is a Vue.js single-page application that demonstrates the use of the Composition API via the @vue/composition-api plugin in a Vue 2 project. It fetches data from the CNode API to display a list of topics, includes a search bar for filtering, and uses WeUI for styling. The application consists of a few components (Header, Search, Panel) and a simple global store for state management. While the code is functional and correctly implements the Composition API patterns, it suffers from tight coupling to the global store, outdated dependencies, and a lack of error handling or loading states, making it suitable for learning but not for production use without significant improvements.