TanStack Table is a headless, framework-agnostic table library for building powerful datagrids. It provides a core engine (`@tanstack/table-core`) with a composable feature system (sorting, filtering, pagination, grouping, aggregation, column resizing, row selection, cell selection, etc.) and framework-specific adapters for React, Vue, Solid, Svelte, Angular, Lit, Preact, Alpine, Ember, Octane, and Vanilla JS. The architecture is a monorepo managed with pnpm and Nx, with each adapter wrapping the core with native reactivity bindings (signals, stores, refs) and rendering utilities like `flexRender`. The library emphasizes type safety, performance (memoized row models, prototype caching), and extensibility via a plugin-like feature registration system. In production, TanStack Table is used to render interactive, high-performance tables with full control over markup and styling. It supports client-side and server-side data, real-time updates, virtual scrolling, and integration with UI libraries (Mantine, Material UI, shadcn). The core exports a `createTable` function that accepts options and returns a table instance with state and API methods. Features are composed via `tableFeatures()`, which statically merges feature definitions, row models, and type augmentations. Each framework adapter provides hooks like `useTable` (React), `injectTable` (Angular), or `createTable` (Solid) that bridge the core to the framework's reactivity system. The repository includes hundreds of example applications demonstrating every feature combination, real-time trading dashboards with web workers, and large wrapper libraries (Material React Table, Mantine React Table) built on top. Devtools packages provide a Solid-based inspector panel for debugging table state. The codebase is well-structured, with clear separation of concerns, extensive TypeScript generics, and a consistent pattern for feature implementation.
This is a PHP library for Laravel that provides a fluent API to build Eloquent queries from HTTP request query parameters, enabling filtering, sorting, including relationships, and selecting fields. It is implemented as a wrapper around Laravel's Eloquent Builder, parsing query string parameters like 'filter', 'sort', 'include', and 'fields' to dynamically modify the underlying query. The architecture consists of a central QueryBuilder class that delegates to specialized concerns (FiltersQuery, SortsQuery, AddsIncludesToQuery, AddsFieldsToQuery) and uses a set of pluggable filter, sort, and include implementations that implement defined interfaces. External dependencies are limited to Laravel's illuminate packages and spatie/laravel-package-tools. The library is widely used and well-tested, with extensive documentation.
This repository is a comprehensive, educational library of data structures and algorithms implemented in Python 3. It is organized into subpackages by algorithmic category (sorting, searching, graph, dynamic programming, backtracking, bit manipulation, string, tree, math, matrix, compression, streaming, etc.), each containing self-contained modules with clear function signatures, docstrings, complexity analysis, and often multiple implementation variants. The library is installable via pip and intended for learning, reference, and reuse in competitive programming or software development. It is not an application or data pipeline; it has no web server, CLI entry point, or external runtime dependencies beyond the Python standard library. The architecture is a flat library with a shared `algorithms/common` module providing reusable data types (`TreeNode`, `ListNode`, `Graph`) and each subpackage re-exporting its public API through `__init__.py` files. The codebase demonstrates a mix of modern and legacy Python styles, with newer modules using type hints, dataclasses, and doctests, while older modules rely on bare comments and local node definitions. Despite some inconsistencies and minor bugs, the repository is a well-structured, actively maintained collection that serves as a valuable reference for algorithm implementations.
TheAlgorithms/Java is a comprehensive, community-maintained collection of over 600 algorithm and data structure implementations in Java, organized into topic-specific packages (e.g., maths, sorts, searches, dynamic programming, graph, ciphers, compression, machine learning, streaming). It is designed as an educational reference library, not a production application. The architecture follows a modular utility-class pattern: most algorithms are implemented as final classes with private constructors and static methods, and many implement shared interfaces such as SortAlgorithm and SearchAlgorithm for polymorphic usage. The codebase includes extensive JUnit 5 test coverage with parameterized tests, and many classes reference Wikipedia or academic sources. While the overall quality is high with many reusable components, there are some inconsistencies such as duplicate implementations, leftover main methods, and occasional use of raw types or legacy APIs. The repository is actively maintained with CI workflows, dependabot, and a structured contribution process.
SortableJS is a mature, standalone JavaScript library for creating reorderable drag-and-drop lists and grids. It supports mouse, touch, and pointer events across modern browsers and legacy browsers like IE11 and Edge. The library is designed as a modular system with a core (Sortable class) and optional plugins (AutoScroll, Swap, MultiDrag, OnSpill) that can be mounted selectively. It exports UMD and ESM builds, integrates with major frameworks (React, Vue, Angular) via separate adapter packages, and provides a rich API with options for grouping, animation, handles, filtering, and custom events. The codebase demonstrates a well-thought-out plugin architecture, event dispatching, and animation state management, though some build tooling and browser workarounds show its age.
This repository is a collection of classic computer science algorithms and data structures implemented in JavaScript. Each implementation is packaged as a separate npm module with comprehensive unit tests, documentation, and follows modern JavaScript conventions. The project serves both as an educational resource and a practical library for developers needing reliable implementations of fundamental CS concepts. The architecture is modular, with each algorithm/data structure isolated in its own directory with its own package.json, allowing for independent use and versioning.
This repository is a massive, community-driven collection of algorithm and data structure implementations in Python, explicitly designed for education and reference. It contains over 1,700 files organized into topical directories such as maths, sorts, graphs, strings, ciphers, dynamic programming, machine learning, and Project Euler solutions. Each module is self-contained, typically with extensive docstrings, type hints, and doctests, making it easy to study or extract individual algorithms. The code is written for clarity and learning, not production performance, and many implementations include references to Wikipedia or academic sources. Despite its educational focus, the repository exhibits some technical drift. A handful of files still use Python 2 syntax (e.g., `except ValueError, EOFError:`), which will cause SyntaxError in modern Python. Several web-scraping scripts depend on the non-standard `httpx2` library and external APIs that may break. The project targets Python 3.15 (including free-threading), which is bleeding-edge and may cause compatibility issues with some tools. However, the majority of the codebase uses modern Python features (type hints, dataclasses, PEP 695 generics) and is actively maintained with CI workflows, pre-commit hooks, and regular contributions. This is not a production application or a data research pipeline; it is a reference library for learning and teaching algorithms. The sheer breadth and consistency of the implementations make it a valuable resource for students, educators, and developers looking for clear examples of classic algorithms. The most reusable components are the standalone data structures (e.g., kd-tree, suffix tree, Fenwick tree) and algorithm implementations (e.g., Dinic max flow, Huffman coding, federated averaging) that can be extracted with minimal modification.
This repository is a comprehensive educational resource that implements a wide range of data structures and algorithms in both JavaScript and TypeScript. It is organized by chapter, mirroring the book 'Learning JavaScript Data Structures and Algorithms' by Loiane Groner. The codebase covers fundamental data structures (arrays, stacks, queues, linked lists, sets, dictionaries, hash tables), trees (binary search trees, AVL trees, red-black trees, Fenwick trees, segment trees), heaps, tries, graphs, and classic algorithms (BFS, DFS, Dijkstra, Floyd-Warshall, Prim, Kruskal, heap sort, etc.). Each implementation is accompanied by Jest tests and many files include both .js and .ts versions. The code is well-structured, uses modern JavaScript/TypeScript features (private fields, generics, arrow functions), and includes JSDoc comments. While primarily educational, the implementations are clean and could serve as reference or be extracted for reuse in other projects. Known minor bugs exist in some hash table collision resolution implementations (e.g., get() always returns undefined in separate chaining, hash function returns NaN in linear probing).
AutoFilterer is a .NET library that automatically generates LINQ expressions from Data Transfer Objects (DTOs) for filtering, sorting, and pagination on IQueryable collections. It is designed to be compatible with OpenAPI 3.0 specifications, unlike oData or GraphQL. The core architecture revolves around filter DTOs that inherit from FilterBase or its derivatives (PaginationFilterBase, OrderableFilterBase). Properties in these DTOs are decorated with attributes (e.g., StringFilterOptions, OperatorComparison, CompareTo) or use special types (StringFilter, OperatorFilter<T>, Range<T>) to define filtering rules. The library builds expression trees at runtime and applies them via the ApplyFilter extension method. It also provides a Swagger integration package (AutoFilterer.Swagger) to expose filter parameters in Swagger UI, and a source generator (AutoFilterer.Generators) to automatically create filter DTOs from entity classes. The codebase is well-structured with clear separation of concerns: abstractions (IFilter, IFilterableType), attributes, types, extensions, and a dynamic filter variant. It includes comprehensive unit tests, benchmark tests, and a sandbox application demonstrating usage with a Northwind database. The library targets netstandard2.0, netstandard2.1, and net9.0, making it broadly compatible. While the core library is mature and actively maintained, some ancillary packages (e.g., Swagger integration) use slightly outdated dependencies (Swashbuckle 5.x), and the documentation has some TODO sections. Overall, it is a solid, reusable filtering framework with high craftsmanship in expression tree manipulation.
This is the source code for `@swimlane/ngx-datatable`, an Angular component library for building high-performance, feature-rich data tables. It provides virtual scrolling, client- and server-side sorting/paging, column reordering/resizing, row selection (single, multi, checkbox), tree view, row grouping, summary rows, and extensive custom template support. The library is built with Angular's signals-based reactivity and OnPush change detection, offering a modern reactive API. The repository also includes a comprehensive demo application and a test suite using Vitest, Angular CDK ComponentHarness, and Playwright for E2E. While the codebase demonstrates strong architectural patterns and reusable utilities, it suffers from a high number of open issues (917), some deprecated API surfaces, and a test stack in migration flux, indicating a mature but somewhat stale maintenance state.