This repository provides a toolkit for developing JavaScript for Automation (JXA) scripts on macOS using TypeScript. It includes packages for running JXA code from Node.js (@jxa/run), an interactive REPL (@jxa/repl), type definitions for macOS applications (@jxa/types and @jxa/global-type), and a tool to generate TypeScript definitions from Apple's SDEF files (@jxa/sdef-to-dts). The monorepo structure (managed by Lerna) separates concerns into focused packages, enabling type-safe and efficient automation of macOS applications.
e18e/cli is a command-line tool that analyzes JavaScript and TypeScript projects for packaging issues, dependency health, and opportunities to replace dependencies with lighter or native alternatives. It runs multiple checks: publint for publishing best practices, dependency replacement suggestions from curated manifests (native, preferred, micro-utilities), core-js polyfill analysis against declared engine ranges, duplicate dependency detection, and web feature codemod suggestions. The CLI also includes a `migrate` subcommand that can automatically apply codemods to rewrite imports for selected replacements. The architecture is plugin-based: each analysis is a self-contained `ReportPlugin` that receives an `AnalysisContext` and returns messages and stats, aggregated by a `runPlugins` orchestrator. The tool uses an abstract `FileSystem` interface with a `LocalFileSystem` implementation, making it extensible for custom environments. Output is either an interactive TUI via @clack/prompts or JSON. This is a pre-1.0 project, actively developed with good code quality and comprehensive tests.
Yarn v1 (Classic) is a Node.js package manager CLI tool that handles dependency resolution, installation, and locking for JavaScript projects. The codebase implements a monolithic architecture with modular components for package resolution, fetching, linking, and reporting. Entry points include bin/yarn.js which routes through src/cli/index.js to command implementations in src/cli/commands/. Primary data flows involve parsing package.json, resolving dependencies through the resolver hierarchy, generating yarn.lock files, and installing packages into node_modules with hoisting logic. External dependencies include npm/yarn registries, git repositories, and offline mirrors for caching. This repository is in maintenance mode per the README - new features are developed in yarnpkg/berry (Yarn 2.x/3.x). The codebase demonstrates solid engineering with extensive test coverage (Jest/Jasmine), Flow type annotations, and well-defined patterns (Resolver, Fetcher, Reporter). However, it uses legacy tooling (Webpack 2, Babel 6, Flow 0.66) and supports EOL Node versions. The dependency management logic is complex and production-tested across millions of projects, making it genuinely reusable despite its age.
Redash is a full-stack business intelligence platform that enables users to connect to multiple data sources, write and schedule queries, build interactive visualizations, and create dashboards with alerting and sharing capabilities. The backend is a Python Flask application with SQLAlchemy for database access, Redis for caching and task queuing, and RQ for background job execution. The frontend is a React single-page application using Ant Design, Plotly, D3, and Leaflet, organized into pages for queries, dashboards, alerts, data sources, and administration. The system exposes a RESTful API for all operations and supports authentication via password, Google OAuth, SAML, LDAP, JWT, and API keys. The architecture follows a modular plugin pattern for query runners and visualizations. Over 35 query runners (e.g., PostgreSQL, BigQuery, Snowflake, MongoDB, Prometheus) are registered via a common base class, each implementing run_query, get_schema, and configuration_schema. The visualization library (viz-lib) is a separate package that registers chart types (line, bar, pie, map, table, cohort, sankey, etc.) with editors and renderers. Dashboards use a grid layout with widgets that can display visualizations, text, or embedded content. Alerts evaluate query results against conditions and send notifications to destinations like Slack, email, PagerDuty, and webhooks. Key data flows: users write SQL or use query runners to fetch data from connected sources; results are cached and can be visualized; dashboards aggregate multiple visualizations with parameter bindings; scheduled queries refresh results and trigger alerts. The system also supports embedding visualizations in external sites and public sharing of dashboards. While primarily an application, the extensive query runner and visualization plugin systems make it a flexible platform for data exploration and operational reporting.
Invoice Ninja is a full-featured open-source invoicing and billing platform designed for small to medium businesses. It handles the complete lifecycle of invoices, quotes, credits, purchase orders, payments, and expenses. The system supports multi-tenant SaaS and self-hosted deployments with per-company database isolation, and integrates with over 20 payment gateways (Stripe, PayPal, Mollie, GoCardless, etc.). It provides client and vendor portals for self-service, along with extensive reporting, CSV export, and e-invoicing capabilities (Peppol, Verifactu, France e-reporting). The application follows a monolithic MVC architecture built on a custom PHP framework (Illuminate) similar to Laravel. It uses an event-driven architecture with domain events and listeners for side effects (email, webhooks, activity logging). Background jobs are queued for async processing. The frontend uses Blade templates, Livewire components, and a separate React app for some admin panels. The API is RESTful with OpenAPI documentation. Key entry points are HTTP controllers under app/Http/Controllers, with request validation classes. Core data flows involve creating entities through factories, persisting via repositories, and triggering events that listeners handle. Payment flows go through abstract payment drivers that encapsulate gateway-specific logic. The system also includes extensive reporting, CSV export, and e-invoicing (Peppol, Verifactu, France e-reporting). External dependencies include a relational database (MySQL/PostgreSQL), Redis for caching and queues, Elasticsearch for search, and various third-party APIs for payment processing, tax calculation (ZipTax), bank integration (Nordigen, Yodlee), email delivery (Mailgun, Postmark, Brevo), and e-invoicing gateways (Storecove, Qvalia).
NSFWJS is a client-side JavaScript library for detecting NSFW (Not Safe For Work) content in images using TensorFlow.js. It provides a simple API to load pre-trained models (MobileNetV2, MobileNetV2Mid, InceptionV3) and classify images into five categories: Drawing, Hentai, Neutral, Porn, and Sexy. The library is designed for both browser and Node.js environments, with backend selection guidance for optimal performance (WebGL, WebGPU, WASM, CPU). The core architecture consists of a lightweight `NSFWJS` class that handles model loading, inference, classification, and disposal, with support for tree-shaking via separate model imports. The repository also includes several demo applications: a full-featured React + Vite demo with Web Worker offloading, camera support, and file drop; a Node.js Express server example; and a minimal HTML/script tag demo. While primarily an application library, it is hybrid in nature as it bundles pre-trained model weights (quantized and base64-encoded) and includes model conversion scripts, making it both a software tool and a model distribution package. The library relies on TensorFlow.js as a peer dependency and uses IndexedDB for model caching in the browser.
This is the Locomotive Scroll library (v5), a lightweight JavaScript library for smooth scrolling, parallax effects, viewport detection, and progress tracking on the web. It is built on top of Lenis and uses dual Intersection Observers for performance. The repository is a monorepo containing the core library package (`packages/lib`), a demo site (Astro), a documentation site (Docusaurus), and a landing page (Eleventy/GSAP). The library exposes a data-attribute-driven API (`data-scroll`, `data-scroll-speed`, etc.) and a `LocomotiveScroll` class with lifecycle methods. The architecture is well-structured with clean separation of concerns: Core orchestration, IO wrapper, per-element scroll tracking, and utility math functions. The library is TypeScript-first and outputs multiple module formats (ESM, CJS, UMD). While the core is solid, there are signs of technical drift (older TypeScript version, some duplicated utilities across packages, and a bundle including full Lenis source). The demo and landing page sites are more complex and tightly coupled to GSAP, but the core library is reusable as an npm package.
Kaitai Struct is an umbrella project that provides a declarative language for describing binary data structures and a compiler to generate parser code in multiple target languages. The repository coordinates submodules for the compiler, runtimes for various languages (Java, Python, Ruby, etc.), format definitions, visualizer, tests, benchmarks, and documentation. Users describe a format in a .ksy file, compile it with the kaitai-struct-compiler to generate language-specific parser code, and use the corresponding runtime to parse binary data. The project includes CI workflows for building the compiler and publishing artifacts, and maintains a collection of ready-to-use format descriptions.
Photonix is a self-hosted, full-stack photo management application with AI-powered classification and search. The backend is a Django monolith exposing a GraphQL API, with background workers for importing, thumbnail generation, raw processing, and ML classification (color, objects, faces, location, style, events). The frontend is a React 19 single-page app built with TanStack Router, Apollo Client, Zustand state management, and a dark-themed shadcn/ui component library. The system supports multi-user libraries, invitations, map view, albums, and fine-grained search with facets. The architecture relies on a PostgreSQL database, Redis for task coordination and locks, and supervisor to manage numerous background processes. While the project shows solid engineering and a modern tech stack, it carries some technical debt from vendored ML models, TensorFlow 1.x compatibility, and hardcoded download URLs, and is explicitly not yet feature-complete.
Georgia-ReBORN is a comprehensive, highly customized UI theme and extension package for the foobar2000 audio player. Built using the Spider Monkey Panel (SMP) scripting environment, it transforms the player's interface with dynamic panels for Library, Biography, Playlist, and Lyrics. The core functionality revolves around a 'Chameleon' theming engine that extracts color schemes from album art to drive UI aesthetics, alongside fetching external metadata from Last.fm, Wikipedia, and AllMusic to enrich the user experience. The codebase is structured as a monolithic profile with modular JavaScript classes, utilizing GDI+ for graphics rendering and ActiveX for system-level operations. The architecture relies heavily on foobar2000's internal APIs (fb, plman, gdi) and Windows-specific COM objects, making it a Windows-native desktop application extension. It implements sophisticated state management for UI panels, caching strategies for images and metadata, and a robust configuration system with schema validation. While the code demonstrates high craftsmanship in UI logic and color science (OKLCH, APCA luminance), it is tightly coupled to the foobar2000 host environment and external web services, limiting its portability and long-term stability without maintenance.
Fireproof is a local-first, real-time document database with CRDT-based conflict resolution, end-to-end encryption, and multi-platform support (browser, Node.js, Deno, Cloudflare Workers). The monorepo contains the core database engine (`@fireproof/core`), a cloud sync backend (Hono + Durable Objects), a dashboard web application for tenant/ledger management, a CLI tool for build and DevOps tasks, and a React hooks library (`use-fireproof`). The architecture is modular with clear separation between storage gateways (IndexedDB, filesystem, memory, cloud), key management (KeyBag with fingerprinting), device identity (X.509-like PKI), and protocol layers (WebSocket/HTTP message dispatch). The codebase exhibits strong engineering practices including extensive TypeScript usage, comprehensive testing (though some tests are skipped or known to fail), and reusable patterns like the Gateway interceptor, Result type, and Evento command pipeline. However, complexity is high due to multiple runtime targets and active refactoring between versions, and there are known critical bugs (e.g., remote sync not triggering subscriptions in React hooks).
Animatelo is a JavaScript library that provides a collection of pre-built animations using the Web Animations API. It ports the popular animate.css library to the JavaScript-based animation model, allowing developers to apply animations like bounce, fade, slide, and more to DOM elements via a simple API (e.g., animatelo.bounce('#element')). The library consists of a core animation engine (src/animatelo.js) that handles element selection, option validation, and animation creation, with individual animation files defining keyframe sequences for specific effects. The architecture is modular, with each animation encapsulated in its own file that extends the main animatelo object, and a build process (via Gulp) concatenates and minifies the source for distribution. The library relies on the Web Animations API (with polyfill support for older browsers) and has no runtime dependencies, making it lightweight and easy to integrate into web projects.
This is a small, focused React component library that wraps the native ResizeObserver API. It provides a declarative component (`<ResizeObserver>`) that can observe a single child element for size changes, supporting both direct children and render-prop patterns for cases where the observed element is not the immediate child. A `Collection` component uses React context and microtask batching to aggregate multiple resize events from child observers into a single callback, improving performance when many elements are observed. The library also exports a `useResizeObserver` hook for imperative use. Internally, it manages a single shared `ResizeObserver` instance with a map of element-to-callback sets, ensuring efficient resource usage. The code is clean, well-typed, and properly tested, making it a reliable building block for responsive UIs. As part of the Ant Design ecosystem, it follows established patterns and integrates smoothly with other @rc-component packages.
This repository is the Notes app for ownCloud Server, a distraction-free note-taking plugin that stores notes as plain text files in the user's cloud storage. It provides a web-based editor with markdown support (via mdEdit) and syntax highlighting (via Prism), along with a RESTful API (v0.2) for third-party integration. The backend is PHP 8.3 following ownCloud's app framework: controllers handle HTTP requests, services contain business logic, and a simple entity layer maps files to Note objects. The frontend is an AngularJS 1.8 single-page application using Restangular for API communication, with custom directives for autofocus, debounced saving, and editor integration. Notes are persisted as .txt, .md, .org, or .note files in a per-user 'Notes' folder, with filename collision resolution and directory traversal prevention. The app supports favoriting via ownCloud's tag system and remembers the last viewed note across sessions. The codebase is well-structured with unit tests for both PHP and JavaScript, acceptance tests, and CI/CD pipelines. It has been actively maintained with recent security updates (patched AngularJS, underscore, Prism) and a move to in-repo translations. While the architecture is standard for ownCloud plugins and the frontend uses an older AngularJS version, the implementation is clean, the business logic is robust, and there are a few reusable patterns like the async save queue and a Python duplicate-key checker for translation files.
HydroShare is a Django-based web application for sharing, managing, and publishing hydrologic data and models. It provides a rich resource management system with support for various file types (NetCDF, GeoTIFF, timeseries, etc.), fine-grained access control (groups, communities, privileges), metadata extraction, and discovery via a Vue.js frontend. The system uses PostgreSQL, Redis, Celery, MinIO (S3-compatible storage), and MongoDB for indexing. It exposes REST APIs for programmatic access and includes background tasks for bag creation, metadata extraction, and DOI registration. While primarily an application, it incorporates data engineering patterns for scientific metadata handling and file type aggregation.
Layui is a classic web UI component library written in pure HTML, CSS, and JavaScript. It provides a comprehensive set of 20+ interactive components including tables, forms, modals, date pickers, menus, trees, and more. The library follows a modular architecture with ES modules, a core component base class, and a consistent lifecycle (render/reload/destroy). It includes built-in internationalization, a resource loader, a simple front-end router, and a template engine (laytpl, though deprecated). The codebase is actively developed (v3.0.0-alpha.3) with modern build tooling (Rollup, PostCSS, ESLint) but retains some legacy patterns and a dependency on jQuery. The component base class and popup system are well-architected and reusable, while some modules (table, treeTable) are large and monolithic. Testing is incomplete, with unit tests marked as placeholder and visual tests requiring manual execution.
ytDownloader is a cross-platform desktop application built with Electron that provides a graphical interface for downloading videos and audio from YouTube and hundreds of other sites using yt-dlp as the backend download engine. It features a comprehensive download manager supporting single downloads, playlists, and YouTube search, with options for format selection, quality, subtitles, compression, and output templates. The application manages its own yt-dlp and ffmpeg binaries, supports auto-updates, and includes a download history with JSON/CSV export, theming, internationalization (23+ languages), system tray integration, and a global hotkey for quick URL pasting. Architecture: The application follows a standard Electron architecture with a main process (main.js) handling window management, IPC handlers, auto-updater, system tray, and global hotkey. A preload script (preload.js) sets up a context bridge (electronAPI) that exposes filesystem operations, process spawning, clipboard access, and other OS services to the renderer. The renderer process consists of several JavaScript modules (src/index.js, src/playlist.js, src/compressor.js, src/preferences.js, src/history_ui.js, src/common.js) that handle specific views. Communication between renderer and main process occurs via Electron's IPC mechanism (ipcRenderer/ipcMain). User preferences are stored in localStorage and a JSON config file, while download history is persisted as JSON. Key entry points: main.js (Electron main process), preload.js (context bridge), html/index.html (single-page UI shell), src/renderer.js (main renderer logic with YtDownloaderApp class), src/index.js (homepage downloader), src/playlist.js (playlist downloader), src/compressor.js (video compressor), src/preferences.js (settings), src/history_ui.js (history view). External dependencies include yt-dlp (download engine), ffmpeg/ffprobe (media processing), Electron (framework), electron-builder (packaging), electron-updater (auto-updates), systeminformation (GPU detection), and SlimSelect (custom dropdowns). The application bundles these binaries or uses system-installed versions, with fallback mechanisms.
C3.js is a D3-based charting library that provides a high-level, configurable API for generating interactive SVG charts directly in the browser. The library supports a wide range of chart types including line, bar, area, pie, donut, gauge, scatter, spline, step, and the specialized Stanford diagram. It handles data ingestion from multiple formats (JSON, CSV, TSV, rows, columns) and offers features such as zooming, subcharts (brush), legends, tooltips, grid lines, regions, and animated transitions. The core is driven by a single configuration object passed to c3.generate(), which controls all visual and behavioral aspects. Architecturally, C3.js follows a classic prototype-extension pattern: the ChartInternal class holds the rendering logic, and each chart type and API method is added via prototype extensions. The public API is exposed through a Chart instance returned by the factory function. The library is self-contained, depending only on D3.js (v5) and runs entirely client-side. It includes polyfills for older browsers (SVGPathSeg, String.padEnd, Object.assign) and has been tested with Jasmine/Karma in a headless browser environment. The codebase exhibits good modularity within a single-bundle approach: internal modules (e.g., data conversion, color scales, axis rendering, tooltip) are logically separated in the source directory. However, the bundled output is monolithic, making tree-shaking difficult. The project is well-documented with sample pages and a documentation site built with Middleman (Ruby). Maintenance has been stable but slow; the latest version is 0.7.20 with no major releases in recent years. The dependency on D3 v5 (instead of v7) and the presence of IE-specific polyfills indicate some technical drift. Despite this, the code is functional, well-tested, and still widely used. It demonstrates a strong real-world application of D3 for reusable chart components.
TiddlyWiki5 is a mature, extensible personal wiki application that runs entirely as a single HTML file in the browser or as a Node.js server. It manages content as individual 'tiddlers' — small, addressable pieces of text with metadata — and provides a powerful custom filter language for querying, transforming, and aggregating them. The application features a widget-based UI rendering engine, a pluggable wiki-text parser with dozens of rules, a built-in HTTP server with REST-like endpoints, encryption, and extensive integration plugins (geospatial maps via Leaflet/Turf, math typesetting via KaTeX, Markdown parsing, CodeMirror editing, QR codes, etc.). The architecture is highly modular: core functionality is implemented via module types (widgets, filter operators, parser rules, startup hooks, saver backends) that can be extended or overridden by plugins. The codebase has been continuously developed since 2011 and supports both client-side single-page application mode and server-side wiki mode. Despite its impressive extensibility and long history, the codebase shows signs of technical drift. The boot kernel (boot/boot.js) is a large monolithic file that mixes utility functions, the wiki store, module loading, and platform-specific startup logic. Many third-party libraries (e.g., JSZip v2.6.1, Leaflet.markercluster 1.5.3, minified CodeMirror modes) are vendored and outdated, requiring manual patching. The code style is inconsistent, with some modules using modern ES6+ features while others remain in ES5. The filter language and widget infrastructure are well-architected and reusable, but the tight coupling between core modules makes extraction for external use non-trivial. The project remains actively maintained with frequent commits, a large community, and an extensive test suite, making it a solid foundation for knowledge management applications, though significant refactoring would be needed to bring it to contemporary best practices.
AutoRest is a production-grade code generation tool that transforms OpenAPI (Swagger) specifications into client SDKs for multiple programming languages, including C#, Java, Python, Ruby, Go, and Node.js. It is the primary tool used by Azure to generate SDKs for Azure services, but it can be used for any REST API. The system ingests OpenAPI 2.0/3.0 documents, validates them, and processes them through a plugin-based pipeline to produce language-specific client libraries. The architecture is built around a directed acyclic graph of pipeline plugins, each responsible for a specific transformation stage (modeling, flattening, naming, emitting). The core engine orchestrates the pipeline, manages configuration loading and merging, and handles extension lifecycle. A virtual file system with source mapping tracks the provenance of generated code back to original spec positions, enabling accurate error reporting and blame tracking. Key entry points include the CLI application at packages/apps/autorest/src/app.ts, the core processing engine at packages/extensions/core/src/lib/autorest-core.ts, and the modelerfour extension that converts OpenAPI to an intermediate code model. The system also includes an experimental path to convert OpenAPI to TypeSpec via the openapi-to-typespec extension. External dependencies include npm for extension management and runtime environments (Java, Python, .NET) for generated code validation. The data flow begins with loading and parsing OpenAPI specs, followed by validation, conversion to a language-agnostic code model, and finally emission of language-specific SDK code. The pipeline supports caching, configuration merging with interpolation, and directive-based customization (e.g., removing operations, renaming components). The codebase is a large monorepo with many interdependent packages, showing signs of long-term evolution and some technical debt.