Edan Schwartz eschwartz

Instructor of Full Stack Engineering at Prime Digital Academy

eschwartz / filter-async.js

Last active November 17, 2016 22:30

Filter array, using asyncronous logic

	/**
	* @param {Array<T>} list
	* @param {(T):Promise<Boolean>} filter
	* @returns {Promise<T[]>}
	*/
	function filterAsync(list, filter) {
	return Promise
	.all(
	list.map(item => filter(item)
	.then(filterRes => ({ filterRes, item }))

eschwartz / pipe.ts

Created January 20, 2017 21:35

Pipe a read-stream to a write-stream (promisifed)

	import * as stream from 'stream';

	function pipe(readStream:stream.Readable, writeStream: NodeJS.WritableStream):Promise<void> {
	return new Promise<void>((onRes, onErr) => {
	readStream
	.on('error', onErr)
	.pipe(writeStream)
	.on('error', onErr)
	.on('finish', () => onRes())
	});

eschwartz / assertMatch.ts

Last active March 7, 2017 16:44

	function assertMatch(actual:string, regex: string \| RegExp, msg?:string):void {
	const regexNorml:RegExp = _.isString(regex) ? new RegExp(regex as string) : regex;

	const isMatch = regexNorml.test(actual);

	if (!isMatch) {
	assert.fail(actual, regexNorml.toString(), msg, 'matches');
	}
	}

eschwartz / flattenObject.js

Last active March 23, 2017 15:57

Flatten an object

	const _ = require('lodash');

	function flattenObj(obj, prefix) {
	prefix \|\| (prefix = '');

	return Object.keys(obj)
	.reduce((flat, key) => (
	_.isObject(obj[key]) ?
	// Recursively flatten objects
	Object.assign(flat, flattenObj(obj[key], `${prefix}${key}.`)) :

eschwartz / mapAsync.ts

Created July 10, 2017 20:17

Async map

	import * as _ from 'lodash';
	async function mapAsync<TVal, TRes>(items:TVal[], iter:(val:TVal, i:(number \| string)) => Promise<TRes>):Promise<TRes[]> {
	return Promise.all(_.map(items, iter));
	}
	export default mapAsync;

eschwartz / mapValuesAsync.ts

Created July 10, 2017 20:17

Like _.mapValues, but asynchronous

	// https://gist.github.com/eschwartz/70a15f12e6ef90f377d5d51fba9c86d8
	import mapAsync from './mapAsync';

	interface Dict<TVal> {
	[key: string]: TVal
	}

	async function mapValuesAsync<TVal, TRes>(obj:Dict<TVal>, iter:(val:TVal, key:string) => Promise<TRes>):Promise<Dict<TRes>> {
	const keyResPairs:[string, TRes][] = await mapAsync<string, [string, TRes]>(Object.keys(obj),
	async (key:string) => {

eschwartz / assert-matches.ts

Created December 20, 2017 21:54

Assert that a string matches a regular expression

	import * as assert from 'assert';

	function assertMatches(actual:string, regex:RegExp, msg?:string) {
	if (regex.test(actual)) {
	assert(false, `${msg}: expected "${actual}" to match regex "${regex.toString()}"`)
	}
	}
	export default assertMatches;

eschwartz / server-side-calculator-regex.js

Created December 22, 2021 21:42

Regex Solution to Server Side Calculator

	// Track the equation as a string
	let equation = '';

	// 🤯 🤯 🤯 🤯 🤯 🤯 🤯
	// This regular expression defines a set of "rules" for
	// how our equation string should look
	// It also tells us how to break apart the different sections of the
	// string into "groups"
	// These are super powerful, though not always so easy to use 😉
	let equationRegEx = /^([0-9]+(\.[0-9]+)?)?([\+\-\/\*])?([0-9]+(\.[0-9]+)?)?$/