This repository is a production-grade, canvas-based WYSIWYG rich text document editor published as the npm package `@hufe921/canvas-editor`. It is a monolithic library that provides a fully self-contained document editing experience, rendering text, tables, images, LaTeX, and form controls entirely on an HTML `<canvas>` element. The architecture is a well-structured layered design featuring a Command pattern facade (`Command`/`CommandAdapt`), a custom particle-based rendering engine (`Draw`), a pub/sub event system (`EventBus`), and a plugin system. The editor supports a wide array of features including pagination, headers/footers, watermarks, change tracking (trace mode), macros, spell checking, accessibility, multi-column layouts, and a sophisticated cascade expression engine for dynamic form control behavior. It is specifically designed for high-fidelity document editing in domains like Electronic Medical Records (EMR), contracts, and official documents, as evidenced by the mock data and feature set. The codebase demonstrates strong engineering craftsmanship. Several components are genuinely reusable, including a custom Myers O(ND) diff algorithm, a standalone LaTeX-to-SVG renderer using Hershey fonts, a fully featured DSL expression evaluator for control cascading, and a clean event bus implementation. The project is actively maintained with a comprehensive test suite (Cypress E2E, Vitest unit tests), modern tooling (Vite, TypeScript), and a rich plugin ecosystem. While some core files like `Draw.ts` and `CommandAdapt.ts` are large and exhibit tight coupling, the overall architecture, separation of concerns, and quality of the reusable components are well above average.
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.
NeoForge is the official successor to Minecraft Forge, providing a comprehensive modding framework and API for Minecraft. It extends vanilla Minecraft through a patching system (coremods/ASM) and a rich event-driven architecture, allowing mods to hook into gameplay, rendering, networking, registries, capabilities (data attachments), and resource transfer. The repository includes the mod loader itself (client and server), a Gradle-based build system (buildSrc) for producing the framework and installer, and an extensive test framework (testframework/) with both unit and in-game game tests. The codebase is well-structured with clear client/server source splits, extensive use of codecs and data-driven JSON, and a modern transactional resource API for energy, fluids, and items. It is actively maintained with large community adoption.
Safety is a commercial CLI tool for software supply chain security, primarily scanning Python (and limited npm) dependencies for known vulnerabilities. It operates as a multi-command CLI built with Click and Typer, offering commands such as `scan`, `check`, `auth`, `firewall`, `init`, and `codebase`. The architecture is modular: a core scanning engine (`safety/scan/`) discovers dependency files (requirements.txt, pyproject.toml, Pipfile.lock, etc.), resolves packages, and matches them against a proprietary vulnerability database fetched from the Safety platform. Results are formatted via a pluggable formatter system (JSON, HTML, screen, text, SPDX) and can be uploaded to the platform for reporting. The tool also includes a firewall mode that intercepts pip/poetry/uv/npm install commands to block malicious packages in real time, using shell aliases (Unix) or registry/autorun (Windows). Authentication is multi-modal: OAuth2 (browser-based), API keys, and machine tokens, with a complex enrollment flow for enterprise MDM. An internal event bus (`safety/events/event_bus/bus.py`) provides async telemetry and audit trail emission, used throughout auth, init, and scan workflows. The codebase demonstrates strong engineering practices: layered configuration resolution (CLI > env > config file > default), a command wrapper pattern for package managers, and a policy file system (YAML) for ignoring vulnerabilities by severity, CVSS score, or expiration. However, there is notable technical drift: the legacy `check` and `license` commands are deprecated but still present, typing is incomplete in several modules, and the Windows firewall interceptor relies on fragile registry manipulation. The test suite is extensive but heavily mocks external services, making integration tests brittle. External dependencies include `httpx`, `authlib`, `tenacity`, `rich`, `pydantic`, `dparse`, `packaging`, `certifi`, `filelock`, and the proprietary `safety-schemas` package. The tool is distributed as a PyPI package and as a GitHub Action, with CI/CD pipelines building platform-specific binaries via PyInstaller and PyApp. Overall, Safety is a mature, feature-rich security tool with a well-architected core, though some areas show signs of rapid feature growth and legacy debt.
OneConfig is a modular, Compose-based configuration library for Minecraft mods, providing a unified API for config definitions, UI rendering, HUD management, keybind handling, event system, and notifications. It supports multiple Minecraft versions and mod loaders (Fabric, NeoForge) via a stonecutter-based build system and extensive mixin compatibility layers for third-party mod configs (e.g., YACL, ClothConfig, MoulConfig). The library features a custom Compose runtime (poly-compose) for Skia-accelerated UI, a tree-based config model with annotation-driven properties, and a service-loader-based platform abstraction. It is actively maintained with a large test suite covering config persistence, event validation, keybind codecs, and HUD migration.
This repository is a userscript/browser extension that provides real-time Japanese-to-Chinese translation for the Granblue Fantasy game website. It intercepts XHR requests to the game's API and modifies JSON responses to replace Japanese text with translations, while also translating HTML content on the page. The application uses a modular architecture with separate translation modules for different game systems (battle, scenario, skills, etc.) and includes a data processing pipeline that converts CSV translation files into JSON format for efficient lookup. Key features include configurable settings, voice subtitles, translator attribution, and optional AI translation fallback.
OpenMod is a .NET-based plugin framework designed for extensibility across game servers and applications. It provides core services including dependency injection, event handling, command processing, permission systems, user management, and configuration management. The framework features a modular architecture with platform-specific adapters for games like Unturned and Rust, enabling developers to create plugins that extend functionality without modifying the core. The system uses an event-driven approach for loose coupling and supports self-updating via NuGet package management. While primarily focused on game server modding, the core abstractions are general enough to apply to other extensible application scenarios.
This repository is a Chinese futures algorithmic trading system centered on the CTP (Commodity Trading Platform) native protocol. It comprises a C++ pybind11 bridge for low-latency market data and order execution, Python trading strategies (e.g., channel breakout, experimental transformer-based models), and a Django web dashboard for monitoring positions, orders, signals, performance, and correlations. The architecture is hybrid: the native module handles real-time CTP communication, while Python strategies run on an in-process event bus with Redis-like pub/sub. The dashboard visualizes trading metrics with ECharts and provides admin CRUD via Django admin. The system is production-oriented but exhibits several maintenance concerns: hardcoded secrets, outdated frontend libraries (Bootstrap 3, jQuery 3.1), duplicate config loading, and an incomplete ML integration. Despite these, the core CTP bridge and strategy framework are well-constructed and demonstrate solid engineering for the niche domain of Chinese futures trading.