Adds pre and post hook functionality to your JavaScript methods.
A tiny, dynamic list virtualization library for React
Curated collection of data structures for the JavaScript/TypeScript.
ESLint rules for React Hooks
Next-generation take on pre/post function hooks
Event Emitting and Middleware Hooks
Strict borsh compatible de/serializer
A view component for react-native with pinch to zoom, tap to move and double tap to zoom capability.
Backwards compatible shim for React's useSyncExternalStore. Works with any React that supports hooks.
Task and Message Queues with Multiple Providers
List of Git hooks
Core Inquirer prompt API
Simple and complete React hooks testing utilities that encourage good testing practices.
Just a little module for plugins.
A lightweight React utility library by inspectph
A collection of 50+ hooks for state and UI management
A set of utility and general-purpose React hooks.
A React table component designed to allow presenting thousands of rows of data.
Babel plugin for React Compiler.
ESLint React's ESLint plugin for React Hooks related rules.
A superset of the JSDOM environment for Jest that respects Node.js globals.
CJS and ESM hooks for orchestrion
Airbnb's ESLint config, following our styleguide
OCSP Stapling implementation
Tripwire captures validation errors from your Ruby on Rails application to help you identify and fix user experience issues. The TripwireNotifier gem makes it easy to hook up your app to the Tripwire web service.
Guardrail captures validation errors from your Ruby on Rails application to help you identify and fix user experience issues. The GuardrailNotifier gem makes it easy to hook up your app to the Guardrail web service.
Transaction::Simple provides a generic way to add active transaction support to objects. The transaction methods added by this module will work with most objects, excluding those that cannot be Marshal-ed (bindings, procedure objects, IO instances, or singleton objects). The transactions supported by Transaction::Simple are not associated with any sort of data store. They are "live" transactions occurring in memory on the object itself. This is to allow "test" changes to be made to an object before making the changes permanent. Transaction::Simple can handle an "infinite" number of transaction levels (limited only by memory). If I open two transactions, commit the second, but abort the first, the object will revert to the original version. Transaction::Simple supports "named" transactions, so that multiple levels of transactions can be committed, aborted, or rewound by referring to the appropriate name of the transaction. Names may be any object except nil. Transaction groups are also supported. A transaction group is an object wrapper that manages a group of objects as if they were a single object for the purpose of transaction management. All transactions for this group of objects should be performed against the transaction group object, not against individual objects in the group. Version 1.4.0 of Transaction::Simple adds a new post-rewind hook so that complex graph objects of the type in tests/tc_broken_graph.rb can correct themselves. Version 1.4.0.1 just fixes a simple bug with #transaction method handling during the deprecation warning. Version 1.4.0.2 is a small update for people who use Transaction::Simple in bundler (adding lib/transaction-simple.rb) and other scenarios where having Hoe as a runtime dependency (a bug fixed in Hoe several years ago, but not visible in Transaction::Simple because it has not needed a re-release). All of the files internally have also been marked as UTF-8, ensuring full Ruby 1.9 compatibility.
SafeMemoize is a production-ready, zero-dependency memoization library for Ruby. It uses Ruby's prepend mechanism to wrap methods with a thread-safe cache (Mutex + double-check locking) that correctly handles nil and false return values — fixing the silent bug in the common ||= pattern. Results are cached per unique argument combination, so parameterized methods only compute each variant once. Additional features include TTL expiration, LRU cache size limiting, conditional caching via if:/unless: predicates, lifecycle hooks for hit/eviction/expiration events, per-instance metrics (hit rate, miss rate, computation time), targeted cache invalidation, custom cache key generators, and introspection helpers. Method visibility (public, protected, private) is fully preserved.