.flatMapFirst(state => {
const argv = ['project', 'new'];
for (const [key, value] of Object.entries(
selectNewProjectContext(state)
)) {
argv.push(`--${key}`);
argv.push(value);
}
// @TODO(mAAdhaTTah) check if dir exists and confirm overwrite
// hygen expects to handle interactivity
return Kefir.stream(emitter => {
runner(argv, {
// NOTE: This is relative to dist, where the build result is.
templates: path.join(__dirname, '..', 'templates'),
cwd: state.cwd,
logger: new Logger(emitter),
createPrompter: () => inquirer,
exec: (action, body) => {
const opts = body && body.length > 0 ? { input: body } : {};
return execa.shell(action, opts);
},
debug: false
})
.then(result => {
emitter.value({ type: 'CREATED', payload: { result } });
})
.catch(error => {
emitter.value({ type: 'FAILED', error: true, payload: { error } });
});
});
});
return this.compiler().flatMap(compiler =>
Kefir.stream(emitter => {
compiler.watch(WebpackService.watch, (err, stats) => {
if (err) {
emitter.error(err);
} else {
emitter.value(stats);
}
});
})
.flatMap(state =>
Kefir.stream(emitter => {
const command = getMochaCommand(state);
emitter.value(shellCommand.request(command));
shelljs.exec(command, { silent: true }, (code, stdout, stderr) => {
if (code !== 0) {
emitter.value(shellCommand.failure({ code, stdout, stderr }));
} else {
emitter.value(shellCommand.success({ stdout }));
}
emitter.end();
});
})
} else {
emitter.end();
}
});
}
let stream07: Stream<number, void> = Kefir.fromCallback<number>(callback => setTimeout(() => callback(1), 1000));
let stream08: Stream<number, void> = Kefir.fromNodeCallback<number, void>(callback => setTimeout(() => callback(null, 1), 1000));
let stream09: Stream<MouseEvent, void> = Kefir.fromEvents<MouseEvent, void>(document.body, 'click');
let stream10: Stream<number, void> = Kefir.stream<number, void>(emitter => {
let count = 0;
emitter.emit(count);
let intervalId = setInterval(() => {
count++;
if (count < 4) {
emitter.emit(count);
} else {
emitter.end();
}
}, 1000);
return () => clearInterval(intervalId);
});
}
// Create a property
{
let property01: Property<number, void> = Kefir.constant(1);
let property02: Property<void, number> = Kefir.constantError(1);
let property03: Property<number, void> = Kefir.fromPromise<number, void>(new Promise<number>(fulfill => fulfill(1)));
}
}
);
/**
* The type emitted by the raf$ stream.
*/
export type RAFAction = ReturnType<typeof rafAction>;
/**
* Stream of requestAnimationFrame events.
*/
export const raf$: Stream<RAFAction, void> = Kefir.stream(emitter => {
let loop: number;
let enabled = true;
(function schedule() {
loop = requestAnimationFrame(time => {
(emitter as any).value(rafAction(time));
if (enabled) {
schedule();
}
});
})();
return () => {
cancelAnimationFrame(loop);
enabled = false;
};
});