html-bundler-webpack-plugin is a webpack plugin that processes HTML templates and bundles associated assets (CSS, JS, images, etc.) into output HTML files. It treats HTML as a webpack entry point, resolves dependencies via webpack's module system, and updates asset references to hashed output URLs. The plugin supports multiple template engines (Pug, Handlebars, EJS, Nunjucks, etc.), asset inlining, subresource integrity, hot module replacement, and code splitting. Architecture consists of a main plugin class, loader infrastructure, and modular preprocessors. It integrates with webpack's compilation hooks for asset extraction and HTML modification. Examples demonstrate usage with frameworks like React, Vue, and CSS tools like TailwindCSS.
HTML5 Boilerplate is a professional front-end template for building fast, robust, and adaptable web apps or sites. It provides a minimal, well-structured starting point with sensible defaults, including HTML5 semantics, CSS normalization (via main.css), responsive viewport meta tag, Open Graph placeholders, favicon and touch icon setup, and a simple web app manifest. The repository also includes a build system based on Gulp for packaging the distribution archive, and Webpack configurations for development server and production bundling. The codebase is lean and focused: the actual 'dist' output is a static site skeleton, while the build tooling and tests are the primary active components. The project is well-maintained, follows modern JavaScript standards (ES modules, ESLint flat config), and is easily customizable for any static site or simple web application.
Bundlephobia is a production web application that analyzes the bundle-size cost of npm packages by performing real builds with a bundler. It exposes a public REST API (endpoints for size, exports, history, trends, similar packages) and a rich Next.js frontend with interactive visualizations (treemaps, trends charts, export analysis). The architecture is microservice-oriented: a main Koa/Next.js server orchestrates requests, a Fastify build-service executes package builds with timeout and profiling, a cache-service backed by Firebase and LRU memory stores results, and an installation-service deduplicates npm installs with lease-based concurrency control. The system also includes a separate Kotlin/Gradle sub-project for JVM package analysis (Maven, Android AAR/JAR) and a curated similar-packages catalog maintained via automated AI research workflows. External dependencies include npm registry, GitHub API, Algolia, Contentful, and Amplitude analytics. Key design patterns include a language-agnostic analysis gateway with adapter registration, a middleware pipeline for request processing (caching, rate-limiting, error handling), typed service contracts using Zod schemas, and a queue service with priority and cancellation. The codebase demonstrates strong engineering practices with extensive unit and e2e tests, custom Oxlint lint rules enforcing internal TypeScript standards, and CI/CD automation for package recommendation updates and JVM releases. While primarily an application, the repository also contains data-research elements: a curated similar-packages catalog with weighted tags, trends analysis merging npm downloads and GitHub stars, and automated library research scripts that propose catalog updates. These are integrated into the application's recommendation features.
BetterDiscord is a client modification for Discord that injects into the Electron app to provide a plugin and theme system, custom CSS editor, addon store, updater, and developer tools. The architecture is a monolith within the Discord client, structured as three packages: injector (main process), preload, and renderer. Key entry points include the main process (`src/electron/main/index.ts`), preload script (`src/electron/preload/index.ts`), and renderer initialization (`src/betterdiscord/index.ts`). Data flows involve IPC between main and renderer, webpack module interception for patching Discord's React components, file system access for addons and settings, and GitHub API for updates. External dependencies include Electron, React, Monaco Editor, lucide-react, and react-spring. The codebase is well-structured with TypeScript, has tests, and exposes a comprehensive API (`BdApi`) for plugin developers. However, it heavily relies on Discord's internal webpack modules and hardcoded module IDs, making it brittle and requiring frequent updates as Discord changes. The project is actively maintained with recent commits and responsive issue triage.
Sphinx Book Theme is a Python package implementing a book-style HTML theme for Sphinx documentation builds. It extends pydata-sphinx-theme (pinned to 0.22.0) and adds custom docutils directives (Margin), a build-time transform that rewrites footnotes into Tufte-style side/margin notes, and header-button generators that emit launch links for Binder/Colab/JupyterHub/Deepnote/JupyterLite plus source links for GitHub/GitLab/Bitbucket. It is distributed on PyPI and serves as the default theme for Jupyter Book, making it a foundational component of the scientific Python documentation ecosystem. Despite this research-communication role, it is a software library, not a data tool — it renders and styles documentation rather than analyzing data. This hybrid character is worth noting: the repo does not contain data pipelines, notebooks for analysis, or research outputs; it contains a Sphinx plugin and frontend asset pipeline. The Python layer is thin but carefully engineered. Theme setup in __init__.py registers Sphinx events, directives, nodes, and transforms; header_buttons/ uses a clean per-provider functional abstraction for generating URLs; _compat.py guards against docutils API drift; and _compile_translations.py coordinates a JSON-to-PO/MO translation workflow. The frontend is compiled with Webpack from a 7-1-architecture SCSS codebase with sections for layout, content, and third-party extension overrides. Tests build real sample sites and use pytest-regressions to verify rendered HTML across Python 3.11-3.14 and Sphinx 8-9, which demonstrates solid engineering discipline for a theme project. The README explicitly declares maintenance mode: bug fixes only, no new features. The last commit is recent and CI runs continuously, but the tightly pinned pydata-sphinx-theme dependency, Sphinx 11 deprecation warnings in the test config, and hand-maintained translation files indicate slow technical drift. For engineers looking for reusable pieces, the standout items are the footnote-to-sidenote transform, the header-button provider pattern, and the HTML asset-hashing utility; the Jinja templates and SCSS are heavily theme-specific and not worth extracting.
Nebular is a comprehensive Angular UI component library developed by Akveo. It provides over 40 reusable components (buttons, cards, tables, calendars, dialogs, etc.), a powerful theming engine with four built-in themes (default, dark, cosmic, corporate), and optional modules for authentication (password, OAuth2, Firebase) and role-based security. The repository is structured as a monorepo with multiple npm packages (@nebular/theme, @nebular/auth, @nebular/security, etc.), each with its own build configuration and tests. The library follows consistent patterns: all components use Angular's NgModule system, implement ControlValueAccessor for form integration, and leverage a custom overlay system built on Angular CDK for popups, tooltips, and modals. The codebase is well-organized with extensive unit tests and e2e tests, but shows signs of maintenance drift: the README explicitly states minimal active development (only Angular version bumps), many components still use deprecated Angular patterns (standalone: false, static ViewChild), and e2e tests rely on Protractor (deprecated). Despite this, the library remains functional and widely used, with a large set of documented examples and a dedicated documentation site.
skpm is a Sketch Plugin Manager providing a CLI utility to create, build, test, and publish Sketch plugins. It's structured as a monorepo with specialized packages: skpm (main CLI), builder (build/linking), create-sketch-plugin (plugin scaffolding), test-runner (testing framework), and shared utilities. The system handles the full plugin lifecycle from creation to publishing, including webpack/Babel compilation, asset bundling, GitHub integration for releases, and Sketch-specific features like developer mode toggling and log viewing.
The 21-Points Health application is a full-stack health tracking system built with a Spring Boot backend and an Angular frontend. It allows users to register, log in, and track various health metrics including weight, blood pressure, and activity points (from exercises, meals, and alcohol). Users can set personal preferences such as weekly goals and weight units (kg/lb). The application provides data visualization through lists, calendars, and charts, and includes administrative features for user management. The architecture follows a standard monolithic pattern with a clear separation of concerns. The backend exposes a RESTful API secured with JWT authentication, uses Spring Data JPA for persistence with a PostgreSQL database (H2 for development), and integrates Elasticsearch for search capabilities. The frontend is a modular Angular application that consumes the API, implements reactive state management with RxJS, and uses Bootstrap for responsive styling. The application also includes internationalization (English and French), Docker Compose configurations for development dependencies, and monitoring setups with Prometheus and Grafana. While the application leverages the JHipster generator for much of its boilerplate, it contains several custom components that demonstrate good engineering practices. Notable among these are a custom Logback converter for handling multi-line log messages, a utility service for file operations (base64 encoding and blob downloading), and a pipe for formatting time durations. These components are relatively isolated and could be reused in other projects with minimal modification.
nuxt-purgecss is a Nuxt 3 module that integrates PurgeCSS to remove unused CSS from the final build. It hooks into Nuxt's PostCSS configuration to add the `@fullhuman/postcss-purgecss` plugin with sensible defaults tailored for Vue and Nuxt projects. The module automatically scans common Nuxt directories (components, layouts, pages, composables, app files, plugins, and nuxt.config) for used CSS classes, and includes a safelist of typical Nuxt classes (e.g., transition classes, nuxt-link classes, scoped style attributes) to prevent accidental removal. It also provides a custom default extractor that strips inline `<style>` blocks from Vue Single File Components before extraction, ensuring that only classes used in templates are considered. The module is disabled by default in development mode and can be configured via the `purgecss` key in `nuxt.config`. The codebase is small, well-structured, and includes integration tests using `@nuxt/test-utils` that verify correct purging behavior on a playground Nuxt project. However, the project has seen no releases since September 2022 and relies on outdated dependencies (e.g., Nuxt 3 RC, Node 16 in CI), indicating it is no longer actively maintained.
kyt is a deprecated monorepo CLI toolkit from The New York Times for scaffolding and developing JavaScript web applications. It encapsulates build tooling (Webpack 4, Babel 7), linting (ESLint 7), testing (Jest 27), and provides starter templates for React apps with client-only, server-only, or universal (isomorphic) rendering. The core package provides three primary commands: `kyt dev` (hot-reloading dev server), `kyt build` (production builds), and `kyt setup` (project scaffolding). Architecture: monorepo with Lerna + Yarn Workspaces; the CLI entry is `packages/kyt-core/src/index.js`; configuration is centralized in `kyt.config.js`, and runtime support (dynamic imports, SSR resolution) is provided by `packages/kyt-runtime`. The tool is no longer maintained and uses dependencies that are significantly behind modern versions (Webpack 4, React 17, Jest 27, ESLint 7). Its value lies in its clean composition of presets, configs, and custom ESLint rules that can be extracted and reused independently.
react-app-rewired is a CLI tool that allows users to override Create React App (CRA) webpack, Jest, and dev server configurations without ejecting. It works by intercepting react-scripts commands (start, build, test) through a drop-in replacement bin script. The tool loads a user-defined config-overrides.js, then monkey-patches the original CRA configuration modules in Node's require.cache before executing the real react-scripts scripts. This approach is fragile, relies on internal CRA module paths, and is tied to CRA 2.x (react-scripts ^2.1.3). The codebase is simple and functional but lacks its own test suite, uses outdated peer dependencies, and the pattern of monkey-patching is not recommended for modern development. The project is effectively in maintenance mode with the community recommending alternatives like craco or rescripts.
This repository is a Webpack plugin that integrates Google Lighthouse for running performance and quality audits during the build process. After Webpack emits assets, the plugin triggers Lighthouse against a specified URL, collects the report, and optionally saves artifacts like screenshots and traces. The codebase consists of two main parts: a Webpack-specific plugin that taps into the compiler's afterEmit hook, and a reusable Lighthouse runner module that handles Chrome lifecycle management, audit execution, and result processing. The project is explicitly marked as deprecated in the README, advising users to use Lighthouse directly instead.
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.