How to use kefir - 10 common examples

To help you get started, we’ve selected a few kefir examples, based on popular ways it is used in public projects.

Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.

github DefinitelyTyped / DefinitelyTyped / types / kefir / kefir-tests.ts View on Github external
// Subscribe / add side effects
{
	Kefir.sequentially(1000, [1, 2]).onValue(x => console.log('value:', x));
	Kefir.sequentially(1000, [1, 2]).offValue(x => console.log('value:', x));
	Kefir.sequentially(1000, [1, 2]).valuesToErrors().onValue(x => console.log('error:', x));
	Kefir.sequentially(1000, [1, 2]).valuesToErrors().offValue(x => console.log('error:', x));
	Kefir.sequentially(1000, [1, 2]).onEnd(() => console.log('stream ended'));
	Kefir.sequentially(1000, [1, 2]).offEnd(() => console.log('stream ended'));
	Kefir.sequentially(1000, [1, 2]).onAny(event => console.log('event:', event));
	Kefir.sequentially(1000, [1, 2]).offAny(event => console.log('event:', event));
	Kefir.sequentially(1000, [1, 2]).log('my stream');
	Kefir.sequentially(1000, [1, 2]).offLog('my stream');
	Kefir.sequentially(1000, [1, 2]).toPromise().then((x: number) => console.log('fulfilled with:', x));
	Kefir.sequentially(1000, [1, 2]).observe({});
	Kefir.sequentially(1000, [1, 2]).observe({
		value: _ => {},
		error: _ => {},
		end: () => {},
	});
	Kefir.sequentially(1000, [1, 2]).observe();
	const subscription = Kefir.sequentially(1000, [1, 2]).observe(
		_ => {},
		_ => {},
		() => {}
	);
	if (!subscription.closed) subscription.unsubscribe();
}

// Modify an observable
{
	let observable01: Stream = Kefir.sequentially(100, [1, 2, 3]).map(x => x + 1);
github DefinitelyTyped / DefinitelyTyped / types / kefir / kefir-tests.ts View on Github external
let observable06: Stream = Kefir.sequentially(100, [1, 2, 3]).flatMapLatest(x => Kefir.interval(40, x).take(4));
	let observable07: Stream = Kefir.sequentially(100, [1, 2, 3]).flatMapFirst(x => Kefir.interval(40, x).take(4));
	let observable08: Stream = Kefir.sequentially(100, [1, 2, 3]).flatMapConcat(x => Kefir.interval(40, x).take(4));
	let observable09: Stream = Kefir.sequentially(100, [1, 2, 3]).flatMapConcurLimit(x => Kefir.interval(40, x).take(6), 2);
	let observable10: Stream = Kefir.sequentially(100, [1, 2]).valuesToErrors().flatMapErrors(x => Kefir.interval(40, x).take(2));
}

// Combine two observables
{
	{
		let foo: Stream  = Kefir.sequentially(100, [1, 2, 3, 4, 5, 6, 7, 8]);
		let bar: Property  = Kefir.sequentially(200, [false, true, false]).delay(40).toProperty(() => true);
		let observable01: Stream = foo.filterBy(bar);
	}
	{
		let a: Property  = Kefir.sequentially(200, [2, 3]).toProperty(() => 1);
		let b: Stream  = Kefir.interval(100, 0).delay(40).take(5);
		let observable02: Property = a.sampledBy(b)
	}
	{
		let foo: Stream  = Kefir.sequentially(100, [1, 2, 3, 4]);
		let bar: Stream  = Kefir.later(250, 0);
		let observable03: Stream = foo.skipUntilBy(bar);
	}
	{
		let foo: Stream  = Kefir.sequentially(100, [1, 2, 3, 4]);
		let bar: Stream  = Kefir.later(250, 'hello');
		let observable04: Stream = foo.takeUntilBy(bar);
	}
	{
		let foo: Stream  = Kefir.sequentially(100, [1, 2, 3, 4, 5, 6, 7, 8]).delay(40);
		let bar: Stream  = Kefir.sequentially(300, [1, 2])
github DefinitelyTyped / DefinitelyTyped / types / kefir / kefir-tests.ts View on Github external
// Convert observables
{
	let property: Property = Kefir.sequentially(100, [1, 2, 3]).toProperty(() => 0);
	let stream: Stream = Kefir.sequentially(100, [1, 2, 3]).toProperty(() => 0).changes();
}

// Subscribe / add side effects
{
	Kefir.sequentially(1000, [1, 2]).onValue(x => console.log('value:', x));
	Kefir.sequentially(1000, [1, 2]).offValue(x => console.log('value:', x));
	Kefir.sequentially(1000, [1, 2]).valuesToErrors().onValue(x => console.log('error:', x));
	Kefir.sequentially(1000, [1, 2]).valuesToErrors().offValue(x => console.log('error:', x));
	Kefir.sequentially(1000, [1, 2]).onEnd(() => console.log('stream ended'));
	Kefir.sequentially(1000, [1, 2]).offEnd(() => console.log('stream ended'));
	Kefir.sequentially(1000, [1, 2]).onAny(event => console.log('event:', event));
	Kefir.sequentially(1000, [1, 2]).offAny(event => console.log('event:', event));
	Kefir.sequentially(1000, [1, 2]).log('my stream');
	Kefir.sequentially(1000, [1, 2]).offLog('my stream');
	Kefir.sequentially(1000, [1, 2]).toPromise().then((x: number) => console.log('fulfilled with:', x));
	Kefir.sequentially(1000, [1, 2]).observe({});
	Kefir.sequentially(1000, [1, 2]).observe({
		value: _ => {},
		error: _ => {},
		end: () => {},
	});
	Kefir.sequentially(1000, [1, 2]).observe();
	const subscription = Kefir.sequentially(1000, [1, 2]).observe(
		_ => {},
		_ => {},
		() => {}
	);
github ivan-kleshnin / unredux / tutorials / 1.state / test0.js View on Github external
import * as R from "ramda"
import K from "kefir"

let action$ = K.sequentially(200, [R.inc, R.inc, R.inc, R.inc, R.dec, R.dec, R.dec, R.dec])

let a = 0
action$.observe(fn => {
  a = fn(a)
  console.log(a)
})

// Next: kinda works but global variables aren't what we want to end with...
github DefinitelyTyped / DefinitelyTyped / types / kefir / kefir-tests.ts View on Github external
}, 1000);

		return () => clearInterval(intervalId);
	});
}

// Create a property
{
	let property01: Property = Kefir.constant(1);
	let property02: Property = Kefir.constantError(1);
	//let property03: Property = Kefir.fromPromise(new Promise(fulfill => fulfill(1)));
}

// Convert observables
{
	let property: Property = Kefir.sequentially(100, [1, 2, 3]).toProperty(() => 0);
	let stream: Stream = Kefir.sequentially(100, [1, 2, 3]).toProperty(() => 0).changes();
}

// Subscribe / add side effects
{
	Kefir.sequentially(1000, [1, 2]).onValue(x => console.log('value:', x));
	Kefir.sequentially(1000, [1, 2]).offValue(x => console.log('value:', x));
	Kefir.sequentially(1000, [1, 2]).valuesToErrors().onValue(x => console.log('error:', x));
	Kefir.sequentially(1000, [1, 2]).valuesToErrors().offValue(x => console.log('error:', x));
	Kefir.sequentially(1000, [1, 2]).onEnd(() => console.log('stream ended'));
	Kefir.sequentially(1000, [1, 2]).offEnd(() => console.log('stream ended'));
	Kefir.sequentially(1000, [1, 2]).onAny(event => console.log('event:', event));
	Kefir.sequentially(1000, [1, 2]).offAny(event => console.log('event:', event));
	Kefir.sequentially(1000, [1, 2]).log('my stream');
	Kefir.sequentially(1000, [1, 2]).offLog('my stream');
	Kefir.sequentially(1000, [1, 2]).toPromise().then((x: number) => console.log('fulfilled with:', x));
github ivan-kleshnin / unredux / tutorials / 2.store / test1.js View on Github external
return function Store(seed, action$) {
    options = R.merge(makeStore.options, options)

    let self = {options} // no OOP

    self.$ = action$
      .merge(K.constant(seed))
      .scan((state, fn) => fn(state))
      .skipDuplicates()

    return self
  }
}
github DefinitelyTyped / DefinitelyTyped / types / kefir / kefir-tests.ts View on Github external
Kefir.sequentially(1000, [1, 2]).observe();
	const subscription = Kefir.sequentially(1000, [1, 2]).observe(
		_ => {},
		_ => {},
		() => {}
	);
	if (!subscription.closed) subscription.unsubscribe();
}

// Modify an observable
{
	let observable01: Stream = Kefir.sequentially(100, [1, 2, 3]).map(x => x + 1);
	let observable02: Stream = Kefir.sequentially(100, [1, 2, 3]).filter(x => x > 1);
	let observable03: Stream = Kefir.sequentially(100, [1, 2, 3]).take(2);
	let observable29: Stream = Kefir.sequentially(100, [1, 2, 3]).takeErrors(2);
	let observable04: Stream = Kefir.sequentially(100, [1, 2, 3]).takeWhile(x => x < 3);
	let observable05: Stream = Kefir.sequentially(100, [1, 2, 3]).last();
	let observable06: Stream = Kefir.sequentially(100, [1, 2, 3]).skip(2);
	let observable07: Stream = Kefir.sequentially(100, [1, 3, 2]).skipWhile(x => x < 3);
	let observable08: Stream = Kefir.sequentially(100, [1, 2, 2, 3, 1]).skipDuplicates();
	let observable09: Stream = Kefir.sequentially(100, [1, 2, 2.1, 3, 1]).skipDuplicates((a, b) => Math.round(a) === Math.round(b));
	let observable10: Stream = Kefir.sequentially(100, [1, 2, 2, 3]).diff((prev, next) => next - prev, 0);
	let observable11: Stream = Kefir.sequentially(100, [1, 2, 2, 3]).scan((prev, next) => next + prev, 0);
	let observable12: Stream = Kefir.sequentially(100, [[1], [], [2,3]]).flatten();
	let observable13: Stream = Kefir.sequentially(100, [1, 2, 3, 4]).flatten(x => x % 2 === 0 ? [x * 10] : []);
	let observable14: Stream = Kefir.sequentially(200, [1, 2, 3]).delay(100);
	let observable15: Stream = Kefir.sequentially(750, [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]).throttle(2500);
	let observable16: Stream = Kefir.sequentially(100, [1, 2, 3, 0, 0, 0, 4, 5, 6]).filter(x => x > 0).debounce(250);
	let observable17: Stream = Kefir.sequentially(100, [0, -1, 2, -3]).valuesToErrors(x => {
		return {convert: x < 0, error: x * 2};
	});
	let observable18: Stream = Kefir.sequentially(100, [0, -1, 2, -3]).valuesToErrors().errorsToValues((x: number) => {
github DefinitelyTyped / DefinitelyTyped / types / kefir / kefir-tests.ts View on Github external
end: () => {},
	});
	Kefir.sequentially(1000, [1, 2]).observe();
	const subscription = Kefir.sequentially(1000, [1, 2]).observe(
		_ => {},
		_ => {},
		() => {}
	);
	if (!subscription.closed) subscription.unsubscribe();
}

// Modify an observable
{
	let observable01: Stream = Kefir.sequentially(100, [1, 2, 3]).map(x => x + 1);
	let observable02: Stream = Kefir.sequentially(100, [1, 2, 3]).filter(x => x > 1);
	let observable03: Stream = Kefir.sequentially(100, [1, 2, 3]).take(2);
	let observable29: Stream = Kefir.sequentially(100, [1, 2, 3]).takeErrors(2);
	let observable04: Stream = Kefir.sequentially(100, [1, 2, 3]).takeWhile(x => x < 3);
	let observable05: Stream = Kefir.sequentially(100, [1, 2, 3]).last();
	let observable06: Stream = Kefir.sequentially(100, [1, 2, 3]).skip(2);
	let observable07: Stream = Kefir.sequentially(100, [1, 3, 2]).skipWhile(x => x < 3);
	let observable08: Stream = Kefir.sequentially(100, [1, 2, 2, 3, 1]).skipDuplicates();
	let observable09: Stream = Kefir.sequentially(100, [1, 2, 2.1, 3, 1]).skipDuplicates((a, b) => Math.round(a) === Math.round(b));
	let observable10: Stream = Kefir.sequentially(100, [1, 2, 2, 3]).diff((prev, next) => next - prev, 0);
	let observable11: Stream = Kefir.sequentially(100, [1, 2, 2, 3]).scan((prev, next) => next + prev, 0);
	let observable12: Stream = Kefir.sequentially(100, [[1], [], [2,3]]).flatten();
	let observable13: Stream = Kefir.sequentially(100, [1, 2, 3, 4]).flatten(x => x % 2 === 0 ? [x * 10] : []);
	let observable14: Stream = Kefir.sequentially(200, [1, 2, 3]).delay(100);
	let observable15: Stream = Kefir.sequentially(750, [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]).throttle(2500);
	let observable16: Stream = Kefir.sequentially(100, [1, 2, 3, 0, 0, 0, 4, 5, 6]).filter(x => x > 0).debounce(250);
	let observable17: Stream = Kefir.sequentially(100, [0, -1, 2, -3]).valuesToErrors(x => {
		return {convert: x < 0, error: x * 2};
github DefinitelyTyped / DefinitelyTyped / types / kefir / kefir-tests.ts View on Github external
type Second = 'second';
	let observable32: Stream = Kefir.sequentially(100, ['first', 'second']).filter((value): value is First => value === 'first');
}

// Combine observables
{
	{
		let a: Stream = Kefir.sequentially(100, [1, 3]);
		let b: Stream = Kefir.sequentially(100, [2, 4]).delay(40);
		let observable01: Observable = Kefir.combine([a, b], (a, b) => a + b);
	}
	{
		let a: Stream = Kefir.sequentially(100, [1, 3]);
		let b: Stream = Kefir.sequentially(100, [2, 4]).delay(40);
		let c: Stream = Kefir.sequentially(60, [5, 6, 7]);
		let observable02: Observable = Kefir.combine([a, b], [c], (a, b, c) => a + b + c);
	}
	{
		let a: Stream = Kefir.sequentially(100, [0, 1, 2, 3]);
		let b: Stream = Kefir.sequentially(160, [4, 5, 6]);
		let c: Property = Kefir.sequentially(100, [8, 9]).delay(260).toProperty(() => 7);
		let observable03: Observable = Kefir.zip([a, b, c]);
	}
	{
		let a: Stream = Kefir.sequentially(100, [0, 1, 2]);
		let b: Stream = Kefir.sequentially(100, [0, 1, 2]).delay(30);
		let c: Stream = Kefir.sequentially(100, [0, 1, 2]).delay(60);
		let abc: Observable = Kefir.merge([a, b, c]);
	}
	{
		let a: Stream = Kefir.sequentially(100, [0, 1, 2]);
		let b: Stream = Kefir.sequentially(100, [3, 4, 5]);
github ivan-kleshnin / unredux / tutorials / 10.log / test1.rx.js View on Github external
counterSub(v, s) {
    return R.over("counter", R.flip(R.subtract)(v), s)
  },
})

// Comparison of approaches:
let action$ = O.of(
  mods.init,
  mods.counterInc,
  mods.counterAdd(2),
  mods.counterSub(2),
).concatMap(x => O.of(x).delay(200))

let state = D.run(
  () => D.makeStore({}),
  D.withLog({key: "db"}),
  D.withControl({}),
)(action$)

state.$.subscribe()

// Next: ???

kefir

Reactive Programming library for JavaScript inspired by Bacon.js and RxJS with focus on high performance and low memory usage

MIT
Latest version published 4 years ago

Package Health Score

57 / 100
Full package analysis