Simple Event System for custom data types
ECMAScript spec abstract operations.
A collection of implementation for ECMAScript abstract operations
Write Pino transports easily
The next generation of events handling for javascript! New: abstract away the network!
An Abstract Class for describing an Ethereum Provider for ethers.
A Light–weight CSS Preprocessor
An Abstract Class for desribing an Ethereum Signer for ethers.
A library to create a trace of your JS app per Google's Trace Event format.
Abstract class for a lexicographically sorted key-value database
Abstract persistence layer and event sourcing schemas for CascadeFlow workflow orchestrator
A noop logger that conforms to the Log4j interface for modules to stub out internal logging
encode/decode number as bitcoin variable length integer
[](https://npm.im/@dnd-kit/abstract)
Create a manifest describing the abilities of an abstract-level database
BitGo SDK coin library for COSMOS base implementation
Utils for writing Salesforce CLI plugins
An implementation of WHATWG EventTarget interface.
BitGo SDK coin library for ETH base implementation
TypeScript definitions for abstract-leveldown
[](https://github.com/bitcoinjs/bip174/actions/workflows/main_ci.yml) [](https://www.npmjs.org/package/bip174)
Abstract interface definition of Tron Wallet Adapters.
Docusaurus util package to abstract the current bundler.
BitGo SDK coin library for Substrate base implementation
Deferrable Gratification (DG) facilitates asynchronous programming in Ruby, by helping create abstractions around complex operations built up from simpler ones. It helps make asynchronous code less error-prone and easier to compose. It also provides some enhancements to the Deferrable API. Features include: * fluent (aka chainable) syntax for registering multiple callbacks and errbacks to the same Deferrable. * a #bothback method for registering code to run on either success or failure. * a combinator library for building up complex asynchronous operations out of simpler ones.
abstraction layer for publishing analytics events.
NoSQL abstraction layer for Ruby, with 'evented' I/O provided by Celluloid.
Lifecycle is an abstraction for dealing with asynchronously updating related events.
The win32-ipc library provides the Win32::IPC class. This is meant to serve as an abstract base class for other IPC related libraries for MS Windows, such as win32-semaphore, win32-event, and so on.
A WebSockets abstraction for the Padrino Ruby Web Framework to manage channels, users and events regardless of the underlying WebSockets implementation.
Utter provides a standard API to allow any class to emit events. It abstracts away event queueing and propagation so you don't have to worry about it.
This gem scrapes the English Wikipedia Homepage (https://en.wikipedia.org/wiki/Main_Page) and obtains the list of significant historical events (and their abstracts) available there. Optionally, users may select one of the historical events and request the text of the first paragraph of the linked article.
ReactiveFreight extends ReactiveShipping to support LTL carriers. Added features include abstracted accessorials and tracking events as well as downloading scanned documents from carriers.
When we send communications to users it is usually in response to an event. Users often have their own communications preferences (when/how/what). This logic can easily become complicated and so I developed Nofly to abstract it and let the core application only worry about knowing what event happened to which object/record.
RSence is a different and unique development model and software frameworks designed first-hand for real-time web applications. RSence consists of separate, but tigtly integrated data- and user interface frameworks. RSence could be classified as a thin server - thick client system. Applications and submobules are installed as indepenent plugin bundles into the plugins folder of a RSence environment, which in itself is a self-contained bundle. A big part of RSence itself is implemented as shared plugin bundles. The user interface framework of RSence is implemented in high-level user interface widget classes. The widget classes share a common foundation API and access the browser's native API's using an abstracted event- and element layer, which provides exceptional cross-browser compatibility. The data framework of RSence is a event-driven system, which synchronized shared values between the client and server. It's like a realtime bidirectional form-submission engine that handles data changes intelligently. On the client, changed values trigger events on user interface widgets. On the server, changed values trigger events on value responder methods of server plugin modules. It doesn't matter if the change originates on client or server, it's all synchronized and propagated automatically. The server framework is implemented as a high-level, modular data-event-driven system, which handles delegation of tasks impossible to implement using a client-only approach. Client sessions are selectively connected to other client sessions and legacy back-ends via the server by using the data framework. The client is written in Javascript and the server is written in Ruby. The client also supports CoffeeScript for custom logic. In many cases, no custom client logic is needed; the user interfaces can be defined in tree-like data models. By default, the models are parsed from YAML files, and other structured data formats are possible, including XML, JSON, databases or any custom logic capable of producing similar objects. The server can connect to custom environments and legacy backends accessible on the server, including software written in other languages.
RSence is a different and unique development model and software frameworks designed first-hand for real-time web applications. RSence consists of separate, but tigtly integrated data- and user interface frameworks. RSence could be classified as a thin server - thick client system. Applications and submobules are installed as indepenent plugin bundles into the plugins folder of a RSence environment, which in itself is a self-contained bundle. A big part of RSence itself is implemented as shared plugin bundles. The user interface framework of RSence is implemented in high-level user interface widget classes. The widget classes share a common foundation API and access the browser's native API's using an abstracted event- and element layer, which provides exceptional cross-browser compatibility. The data framework of RSence is a event-driven system, which synchronized shared values between the client and server. It's like a realtime bidirectional form-submission engine that handles data changes intelligently. On the client, changed values trigger events on user interface widgets. On the server, changed values trigger events on value responder methods of server plugin modules. It doesn't matter if the change originates on client or server, it's all synchronized and propagated automatically. The server framework is implemented as a high-level, modular data-event-driven system, which handles delegation of tasks impossible to implement using a client-only approach. Client sessions are selectively connected to other client sessions and legacy back-ends via the server by using the data framework. The client is written in Javascript and the server is written in Ruby. The client also supports CoffeeScript for custom logic. In many cases, no custom client logic is needed; the user interfaces can be defined in tree-like data models. By default, the models are parsed from YAML files, and other structured data formats are possible, including XML, JSON, databases or any custom logic capable of producing similar objects. The server can connect to custom environments and legacy backends accessible on the server, including software written in other languages.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.