Skip to main content
100%

Mimmicking Deps.autorun from Meteor in pure Node

✓ Published0🌍 Public
Aalessioalex
Last edited Jun 20, 2014
Created on Jun 20, 2014

This example demonstrates a pure Node.js implementation of Meteor’s reactive `Deps.autorun` pattern, showing how dependent computations automatically re-run when their data sources change. The code uses Node’s `EventEmitter` to simulate a reactive `Session` object, whose `get` and `set` methods trigger change events. Two `Deps.autorun` callbacks log session values, and a `stop()` method halts one computation after a condition is met. The example runs asynchronous timers to illustrate re-execution and manual invalidation.

AI-generated description

Similar vizzes

Loading thumbnail…

requirebin sketch

This example demonstrates two MobX patterns for managing derived state in a React application. It shows how `mobx.observable` creates reactive state objects, while `mobx.autorun` automatically tracks dependencies and re-runs a "someReallyExpensiveTest" function whenever the input changes. The visualization contrasts an imperative approach using `autorun` with a declarative approach using computed getters that chain `isBoolean` and `isString` properties. Console output logs state transitions as inputs toggle between booleans and strings, highlighting MobX's reactivity model.

HHypercubed
56% match
Loading thumbnail…

Gist 7ef5a071200fae517638

This example demonstrates the execution order of Node.js timer and scheduling APIs by logging messages from `setTimeout`, `setImmediate`, and `process.nextTick`. The code creates an `EventEmitter` and schedules callbacks with zero-millisecond delays, including a nested `setTimeout` and `setImmediate` inside a 10-millisecond timeout. It shows how `process.nextTick` runs before `setImmediate`, while `setTimeout` and `setImmediate` ordering varies by context. The output is printed directly to the console using `console.log`.

Aackuser
53% match
Loading thumbnail…

Effect Functor / Reader Monad

This example demonstrates functional programming patterns—an Effect functor and Reader monad—as JavaScript objects with methods like `map`, `chain`, `join`, and `ap`. The Effect wraps an impure function like `fZero`, while `Effect.of` creates a pure initial value. The Reader monad, using `Reader.ask`, threads a shared environment (a database and logger) through a composed `updateTask` pipeline. The code simulates a database update and logging by explicitly invoking `run` with those dependencies, showing how side effects are deferred and composed without direct state mutation.

RRestuta
50% match
Loading thumbnail…

Hello Reactor

This example demonstrates a minimal event-driven communication system built with JavaScript. It shows how two listeners attached to the same `'big bang'` event respond to a dispatched payload, with one listener logging a fixed message and the other printing the passed arguments. The code defines a custom `Reactor` class and an `Event` class, showcasing manual event registration, callback storage, and dispatch logic. The implementation relies on JavaScript's array `forEach` method to invoke all registered callbacks with the spread `...eventArgs` syntax. The data originates from a hardcoded dispatch call passing the values `135`, `'test'`, and `[1, 2, 3]`.

MMAKIO135
50% match
Loading thumbnail…

Memcached in JavaScript based on Node.JS

This example visualizes the behavior of a Memcached server implemented in Node.js, showing how it manages key-value storage with an LRU (Least Recently Used) eviction strategy under memory pressure. The animation displays the element count in the cache, updating every two seconds via a `setInterval` callback. The code uses Node.js `net` module for TCP networking, a custom LRU class based on chriso/lru, and leverages `process.memoryUsage()` to monitor RSS memory. It also exposes a custom `gc` command to trigger garbage collection via `gc()`.

Aalessioalex
50% match
Loading thumbnail…

auto starting dev server & babel parsing #dev #package #workflow

This example shows a development workflow where a React app automatically starts a live server and watches for JavaScript changes. The code runs the `dev` script, which uses `concurrently` to launch two processes side-by-side: `live-server` serves the `public` folder, while Babel watches `src/app.js` and compiles it with the `env` and `react` presets to `public/scripts/app.js`. The `package.json` defines the project as `indecision-app`, listing dependencies like `babel-preset-env`, `babel-preset-react`, and `save-dev` to enable ES2015+ and JSX transformation during development.

TTimeBandit
49% match
Loading thumbnail…

Gist d51a566a307b428d98eaf3aa8d2a59a3

This example benchmarks JavaScript event emitter libraries across multiple test scenarios, including initialization, emitting with context, and emitting single or multiple values to one or more listeners. The code runs benchmark suites using `benchmark.js`, comparing libraries such as `EventEmitter3`, `MiniSignals`, `push-stream`, and `signal-lite`, and reports throughput in operations per second. It highlights the fastest performers per scenario, such as `push-stream` leading in the "emit with context" test. The visualization shows raw performance data from Node.js 6.2.1, rendered as plain-text tables with pass/fail assertions and timing summaries.

HHypercubed
49% match
Loading thumbnail…

Hook that debounces useState() changes.

This React hook demonstrates how to debounce state updates from `useState` by wrapping the setter in a custom `useStateDebounce` function. It uses `useCallback`, `useRef`, and `useEffect` to manage a `window.setTimeout` and `window.clearTimeout` pair, delaying the `setState` call by a specified `ms` interval. The hook accepts an initial state value and returns the debounced state and setter, preventing rapid re-renders from frequent input changes. The example is implemented as a TypeScript `.tsx` file, showing the logic in isolation without external data sources or visualization libraries.

Aabonello
49% match