This is an ESLint plugin (`eslint-plugin-functional`) that enforces functional programming patterns in JavaScript and TypeScript code. It provides 20 actively maintained rules targeting immutability, functional parameters, no classes, no exceptions, no statements, and other FP principles. The plugin deeply integrates with TypeScript's type system via `@typescript-eslint/utils` and libraries like `is-immutable-type` for type-aware immutability checks. It offers multiple configuration presets (strict, recommended, lite, etc.) and supports ESLint 9 and 10 flat configs. The codebase is well-structured with a consistent rule factory (`createRule`), shared utilities (type guards, option overrides), and an extensive test suite using snapshot testing. It is actively maintained with frequent releases, a comprehensive CI pipeline, and semantic versioning.
This is a highly configurable module resolution library used as the core resolver inside webpack. It implements a plugin pipeline based on the tapable hook system, allowing third-party extensions. The library supports standard Node.js resolution (relative, absolute, node_modules), package.json exports/imports fields, TypeScript tsconfig path mapping, aliases, symlinks, PnP (Yarn Berry), and browser field resolution. The codebase is meticulously optimized for performance with custom caching layers (CachedInputFileSystem, per-field WeakMap caches, char-code-based path classification) and includes extensive benchmarks tracked by CodSpeed. It has broad runtime support including Node.js, Deno, Bun, and browser environments via shims. The architecture is modular with each resolution step implemented as a separate plugin, making it both extensible and testable.
This is Prisma 8, a next-generation ORM framework written in TypeScript. It provides a contract-driven schema definition system where a 'contract' (JSON + TypeScript types) defines the data model, codecs, extensions, and capabilities. From this contract, the framework generates migrations, a type-safe query builder, and runtime execution for multiple database targets (PostgreSQL, SQLite, MongoDB). The architecture follows a multi-plane design with clear separation between the control plane (schema definition, migration planning, CLI) and the runtime plane (query execution, codec encoding/decoding). The monorepo is organized into layers: foundation (contract IR, canonicalization), core (config, framework components), authoring (PSL parser, contract builder), tooling (CLI, emitter, migration tools), family-specific packages (SQL family, Mongo family), target adapters (Postgres, SQLite, Mongo), and extensions (pgvector, postgis, supabase, etc.). Key entry points include the CLI (packages/1-framework/3-tooling/cli/src/bin.ts), contract definition via defineContract, migration base class, runtime creation (createPostgresRuntime, createMongoRuntime), and the ORM client (Collection). Data flows from contract source (PSL or TypeScript) to contract IR, emission (contract.json + contract.d.ts), migration planning, DDL execution, runtime query building, codec encoding/decoding, and database execution. External dependencies include PostgreSQL (via pg driver), SQLite (via better-sqlite3 or WASM), MongoDB (via mongodb driver), various extensions (pgvector, postgis, etc.), and Node.js/Bun runtimes.
Puter is a full-stack, self-hosted 'internet computer' — a browser-based desktop environment (file manager, app launcher, AI services, static-site hosting, serverless workers) backed by a Node.js kernel. The repo is a monorepo of five interlocking sub-packages: a TypeScript backend kernel (`src/backend`), a browser GUI (`src/gui`), a published JavaScript SDK (`src/puter-js`), a CLI (`src/cli`), and a Cloudflare-Worker port (`src/worker`) plus an MCP connector (`src/mcp-connector`). The kernel is the centerpiece: it layers clients (MySQL/Postgres/SQLite, DynamoDB, S3, Redis, email, alarms), stores (user, app, FS entry, session, share, permission, group, KV, OIDC, notification, subdomain), services (auth, FS, metering, permission, ACL, broadcast, notification, OIDC, app-icon, health), controllers (REST + WebDAV + WISP + Peer endpoints), and drivers (AI chat/TTS/STT/image/video/OCR, KV, apps, subdomains, notifications, workers) behind a custom `PuterServer` that wires them together with ordered peer-dependency construction. Configuration is a three-tier deep-merge (config.default.json → config.json → PUTER_CONFIG_PATH) computed at startup. The backend is well-tested with vitest unit, integration, and benchmark suites; the SDK ships with Playwright e2e tests. The GUI is a large, jQuery-based desktop UI with its own webpack build and a component system. Notable engineering: a type-safe permission/ACL system with rewriters and implicators, a metering/subscription model in microcents, a multi-engine database abstraction with ordered migrations, a driver pattern with per-operation cost tables, a token v1→v2 silent-migration path, a reauth coordinator with shared in-flight promises, and a worker-types package that provides template-literal route-param inference for the worker runtime. The codebase is actively maintained (June 2026), uses current Node 24 / TypeScript 5.9 / Express 5 tooling, and has CI for backend tests, docs builds, release-please, and Docker image publishing.
Phaser is a client-side 2D game engine/framework distributed as a JavaScript library. In production it provides the runtime systems game developers assemble into browser games: scene lifecycle management, game-object factories and component mixins, display lists, input processing (pointer/touch/keyboard/gamepad), asset loading/caching, tweens, animation state machines, tilemap parsing/rendering, Arcade and Matter.js physics, audio, and a dual Canvas/WebGL rendering pipeline. The engine is event-driven: core, scene, camera, physics, loader, and sound subsystems communicate through named event constants, and game objects expose component-based behavior via mixed-in plain objects. Entry points include src/phaser.js (UMD bundle), src/phaser-esm.js (ESM), src/phaser-arcade-physics.js, and src/phaser-no-physics.js build variants; package.json exposes the main library and TypeScript declarations. Architecture is modular CommonJS with heavy JSDoc. The main data flow: developer configures Phaser.Game; Config boots core systems, SceneManager instantiates scenes and injects plugins; scenes create GameObjects through factory/creator registries; game objects are added to DisplayList/UpdateList; each frame TimeStep emits STEP, camera systems transform, renderers submit object batches to WebGL drawing contexts or Canvas contexts; loader uses XHR/fetch in browser to populate texture/audio/cache managers. Runtime dependency is minimal (eventemitter3); WebGL, Canvas, WebAudio, and device APIs are browser-native; Matter.js is vendored inside src/physics/matter-js. There is no data/research content; type definitions and constants are not analytical models. The codebase is large but well-modularized: many small single-purpose utility modules (math, geometry, color, arrays) are safely reusable outside Phaser. The most notable reusable pieces are polygon triangulation, the R-tree spatial index, and seeded RNG. Maintenance is active; however the repository carries legacy API vestiges (e.g. deprecated aliases, vendor-prefixed browser checks, mixed Jasmine/Vitest test conventions) and a renderer transition from older Canvas batching to the newer WebGL render-node pipeline, so technical drift is moderate despite recent commits.
Medusa is a headless commerce platform built as a modular monorepo. It provides a comprehensive backend with REST APIs for admin and storefront operations, a React-based admin dashboard, a workflow engine for orchestrating business processes (orders, returns, claims, etc.), and a plugin system for extending functionality. The architecture is domain-driven: each commerce domain (cart, order, product, pricing, payment, fulfillment, inventory, tax, promotion, customer, region, etc.) is an independent module with its own models, migrations, services, and workflows. The admin dashboard is a React SPA using TanStack Query, react-hook-form, and a custom data grid with virtual cells and clipboard support. The platform relies on PostgreSQL (via MikroORM) and optionally Redis for caching and workflow execution. It includes a design system with SVG icons and UI components, a JS SDK for client-side integration, and extensive documentation sites built with Next.js. The monorepo also contains CLI tools for project scaffolding, code generation, and API reference generation.
The Motion repository is a comprehensive library for creating complex animations and interactions for JavaScript, React, and Vue applications. It supports various features such as animation sequencing, spring animations, layout animations, gesture handling, and scroll-linked animations. The library is actively maintained, with a large number of commits and updates in the changelogs. The code is well-structured, and several reusable components and patterns are demonstrated in the examples.
GSAP (GreenSock Animation Platform) is a mature, high-performance JavaScript animation library designed for creating complex animations in web applications. It features a plugin-based architecture where the core tweening engine is extended by plugins for specific animation types such as CSS, scroll-based motions, SVG morphing, and physics effects. The library is framework-agnostic and supports animation of CSS properties, SVG attributes, canvas objects, and JavaScript objects. The source code reveals a well-structured codebase with clear separation of concerns. Core animation logic resides in gsap-core.js, while utilities (matrix operations, string handling, path parsing, velocity tracking) are isolated in the utils directory. Plugins follow a consistent registration pattern and demonstrate attention to cross-browser compatibility, performance optimization (including requestAnimationFrame usage and tree shaking protection), and modular design. The library is actively maintained with recent updates and extensive TypeScript support.
The Vercel AI SDK is a comprehensive TypeScript monorepo providing a unified, provider-agnostic interface for building AI-powered applications. It abstracts interactions with dozens of LLM providers (OpenAI, Anthropic, Google, Mistral, Cohere, xAI, etc.) behind a consistent API for text generation, streaming, structured output, image/video generation, speech, transcription, embeddings, and tool calling. The architecture is modular: a core `ai` package exposes high-level functions (`generateText`, `streamText`, `generateImage`, `embed`, `transcribe`, `ToolLoopAgent`, `HarnessAgent`) and a middleware system, while separate `@ai-sdk/provider` packages define versioned model interfaces (v2–v4) and `@ai-sdk/provider-utils` provides shared utilities for schema validation, error handling, and HTTP. Each provider lives in its own package (e.g., `@ai-sdk/openai`, `@ai-sdk/anthropic`) with model-specific options and error handlers. The SDK also includes a harness/agent framework (`@ai-sdk/harness`) for integrating external coding agents (Claude Code, Codex, Cursor, GitHub Copilot, etc.) with sandboxed execution and workflow orchestration, plus UI integrations for React, Vue, Svelte, and Angular. Key data flows involve constructing prompts, calling provider APIs via fetch, streaming responses as Server-Sent Events or ReadableStreams, and transforming messages between model and UI formats. External dependencies include provider API endpoints, Zod for schema validation, and OpenTelemetry for telemetry.
ChakraCore is a standalone, community-maintained JavaScript engine originally developed by Microsoft. It implements the full ECMAScript specification (ES5/ES6/ES7+), WebAssembly, and Asm.js, with a high-performance JIT compiler supporting x64, x86, ARM, and ARM64 architectures. The engine includes a generational garbage collector (Recycler), a bytecode interpreter, a parser, and a comprehensive debugger with time-travel debugging support. It is designed to be embedded via a C API (Jsrt) and also ships with a lightweight command-line host (`ch`). The codebase is highly modular, with clear separation between the runtime, backend, parser, and platform abstraction layer (PAL). It contains an extensive test suite covering language features, optimizer edge cases, and regression tests. While the original Microsoft support ended in 2021, the community actively maintains the project, with recent commits and ongoing issue triage. The engine is production-grade and has been used in various applications, including Node.js (prior to the move to V8) and Windows applications.
GridStack.js is a production-grade TypeScript library for building responsive, drag-and-drop dashboard layouts. The core GridStack class manages widget lifecycle, DOM placement, responsive column switching, nested grids, serialization, and eventing, while GridStackEngine performs collision and positioning math without touching the DOM. The library ships its own drag-and-drop subsystem rather than depending on HTML5 drag-and-drop or jQuery, and it has zero runtime dependencies. Architecturally, the repository is a multi-package collection: a framework-agnostic core, a SCSS styling layer, and official Angular, React, and Vue wrappers. The wrappers integrate through callback hooks such as addRemoveCB, saveCB, and updateCB, plus DOM-stamped host APIs, allowing each framework to dynamically create and destroy widgets while keeping item content mounted during cross-grid drags. Demo applications under demo/, angular/projects/demo, react/src, and vue/src exercise the public API and serve as integration references. The project is actively maintained with a comprehensive Vitest and Playwright test suite, issue-numbered regression tests, and frequent releases. Its main technical debt is the large monolithic gridstack.ts (roughly 3100 lines) and the need to keep three framework wrappers synchronized with core API changes. The Angular wrapper is intentionally pinned to an older Angular major and some legacy build artifacts remain, but the core engine/UI separation, clean utility layer, and callback-based framework integration make many parts genuinely reusable.
MQTT.js is a comprehensive MQTT protocol client library for Node.js and browsers, implementing MQTT 3.1.1 and 5.0 specifications. It provides core functionality for connecting to brokers, publishing/subscribing with QoS levels, keepalive management, and offline message queuing. The architecture features modular transport abstraction (TCP/TLS/WebSocket/platform-specific), event-driven design with TypedEventEmitter, and pluggable persistence via Store. Entry points include the main library (src/mqtt.ts), CLI tools (src/bin/*), and platform-specific adapters. The codebase demonstrates strong craftsmanship in handling protocol complexities, cross-platform concerns, and maintainable abstractions.
Two.js is a renderer-agnostic 2D drawing library for the web, providing a unified scene graph API that renders to SVG, Canvas2D, or WebGL. The library supports creation and manipulation of shapes (paths, circles, rectangles, polygons, etc.), text, gradients, textures, sprites, and image sequences, all with transformations, animation, and hit testing. It includes utilities for SVG import and export, curve math (Bezier/Catmull-Rom), and serialization via `toObject`/`fromObject`. The architecture is modular: a core `Two` class manages the scene and animation loop, with a hierarchy of elements (Element → Shape → Path/Text/Points), a Group container for scene graph nesting, and separate renderer implementations for each target. Key entry points are the `Two` constructor, factory methods (`makeCircle`, `makePath`, etc.), `update()`, `play()`, and `pause()`. The library has no external runtime dependencies beyond standard browser APIs, though optional `node-canvas` enables headless rendering. Notably, the codebase demonstrates high craftsmanship with a flag-based dirty tracking system for efficient updates, an event system with cross-object observation, and a collection pattern with mutation events. However, it shows maintenance drift through some outdated development dependencies (e.g., `babel-eslint`, `underscore`) and manually maintained TypeScript declarations that may lag behind the source.
EJS (Embedded JavaScript) is a mature, widely-used templating library for Node.js and browsers. It compiles template strings (using `<% %>` tags) into JavaScript functions for server-side or client-side rendering. The core API provides `compile`, `render`, and `renderFile` methods, with support for includes, custom delimiters, caching, async rendering, and Express integration. The library is dual-published as CommonJS and ES Modules, and ships with a CLI tool for rendering templates from the command line. The codebase is well-engineered with a clean separation of concerns: `lib/esm/ejs.js` contains the main template engine, `lib/esm/utils.js` provides helper functions (including prototype-pollution-hardened shallow copy and XML escaping), and `lib/esm/parseargs.js` is a reusable CLI argument parser that was extracted to replace a Jake dependency. The build pipeline uses TypeScript to compile ESM to CJS, browserify for the browser bundle, and uglify-js for minification. Tests are comprehensive (Mocha) and include unit tests for the argument parser, prototype pollution resistance, and ecosystem compatibility with bundlers like Rollup, Webpack, Vite, and Deno. The library demonstrates strong engineering practices: it explicitly avoids prototype pollution by using null-prototype objects, validates option names to prevent code injection, and supports strict mode and destructured locals as alternatives to the deprecated `with` statement. The CLI parser is a pure, well-tested module that handles edge cases like attached short values, grouped booleans, error collection, and prototype-safe option names. While the core engine uses `new Function` (standard for JS template engines) and defaults to `with`, these are documented trade-offs with opt-out flags. Overall, EJS is a solid, professionally maintained project with a clean architecture and high reusability of its utility modules.
actions/github-script is a GitHub Action that allows users to run JavaScript/TypeScript scripts in their workflows with access to a pre-authenticated GitHub API client and other GitHub Action toolkit packages. The action executes user-provided scripts as asynchronous functions within a context that includes github, context, core, glob, io, exec, getOctokit, and require objects. Scripts can make GitHub API calls, perform file operations, and return values that become action outputs. The architecture follows standard GitHub Action patterns with TypeScript source code compiled and bundled via ncc into a single distributable file. Key components include async-function.ts for safely executing user scripts, create-configured-getoctokit.ts for creating secondary authenticated clients with inherited configuration, and wrap-require.ts for handling module resolution. The action integrates with GitHub's retry and request-logging plugins and supports configurable retries, user-agent, base URL, and result encoding.
htmlparser2 is a fast, forgiving HTML/XML parser library for JavaScript. It provides a streaming, callback-based (SAX-like) interface that allows consuming documents with minimal allocations. The library includes a low-level tokenizer, a parser that handles HTML-specific semantics (implicit tag closing, foreign content like SVG/MathML, special tags like script/style), and adapters for Node.js and Web streams. It also offers DOM construction via domhandler and feed parsing (RSS, Atom, RDF). The architecture separates tokenization from parsing, enabling reuse of the tokenizer component. The codebase is well-structured, thoroughly tested, and uses modern TypeScript with strict settings.
ifvisible.js is a modern, dependency-free browser library that provides a clean, event-driven API for detecting page visibility and user activity. It wraps the standard Page Visibility API to surface focus/blur events, and adds an idle-detection system that fires `idle`/`wakeup` events after a configurable period of user inactivity (mouse, keyboard, touch, scroll). Version 3 is a complete rewrite in TypeScript with per-instance event isolation, SSR-safe construction (no DOM access at import time), and support for the Page Lifecycle API (`freeze`/`resume` for bfcache). The library ships as an ESM module, CommonJS, and an IIFE global, with bundled type definitions. It is designed for use in any client-side JavaScript project—SPA frameworks, traditional websites, or even server-side rendering environments (where it becomes a safe no-op). The architecture is simple: a single `IfVisible` class holds an internal `EventEmitter` and a `Timer` class for smart intervals that auto-pause when the user is idle. The codebase is well-structured, thoroughly tested (including an SSR test), and follows modern best practices. It is not a data research project; it is a reusable application library.
diagram-js is a modular, extensible JavaScript library for building interactive web-based diagram editors. It provides the foundational infrastructure—an event-driven architecture via EventBus, a command pattern with full undo/redo support via CommandStack, and a DI container (didi) for composing features as independent modules. The codebase includes core services (Canvas, ElementRegistry, GraphicsFactory) for managing SVG rendering, hit testing, and element lifecycle, along with a rich set of interaction features: drag-and-drop creation/move/resize/connect, snapping, grid snapping, auto-resize, auto-place, bendpoint editing, lasso selection, space tool, popup menus, context pads, palettes, search, overlays, copy/paste, and keyboard bindings. It is designed for downstream domain-specific editors (e.g., bpmn-js, dmn-js) which extend it via provider interfaces and rule systems. The library is well-tested with an extensive suite using Mocha/Chai/Sinon and runs on modern browsers. Its architecture emphasizes decoupling, extensibility, and reusable patterns.
This is a Deno/TypeScript library for extracting structured article data (title, content, author, date, image, etc.) from any URL or HTML string. It uses Mozilla's Readability for the core extraction, supplemented by custom metadata extraction from HTML meta tags, JSON-LD schemas, and link elements. The library provides a transformation system that allows per-site pre/post processing of HTML to improve extraction quality, and a flexible HTML sanitizer to control output tags and attributes. The architecture is modular, with clear separation of concerns: retrieval, metadata extraction, URL normalization, readability extraction, sanitization, and transformation. Entry points are `extract()` and `extractFromHtml()`, with optional custom fetch functions and parser options. The codebase is well-tested, actively maintained, and demonstrates solid engineering practices with minimal dependencies.
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.