Abiodun abiodun0

I wanted to figure out the fastest way to load non-critical CSS so that the impact on initial page drawing is minimal.

TL;DR: Here's the solution I ended up with: https://github.com/filamentgroup/loadCSS/

For async JavaScript file requests, we have the async attribute to make this easy, but CSS file requests have no similar standard mechanism (at least, none that will still apply the CSS after loading - here are some async CSS loading conditions that do apply when CSS is inapplicable to media: https://gist.github.com/igrigorik/2935269#file-notes-md ).

Seems there are a couple ways to load and apply a CSS file in a non-blocking manner:

	const EPOCH_START_DATE = new Date(0)
	const debounce = (fn, delay) => {
	let lastCallDate = EPOCH_START_DATE
	return (...args) => {
	let curDate = new Date()
	const shouldSkip = new Date() - lastCallDate < delay
	if (shouldSkip) {
	return
	}
	lastCallDate = curDate

	function fuzzysearch (needle, haystack) {
	var hlen = haystack.length
	var nlen = needle.length
	if (nlen > hlen) {
	return false
	}
	if (nlen === hlen) {
	return needle === haystack
	}
	outer: for (var i = 0, j = 0; i < nlen; i++) {

	import { isObservable } from './utils';

	// Action creator
	const actionCreator = (func) => (...args) => {
	const action = func.call(null, ...args);
	action$.next(action);
	if (isObservable(action.payload))
	action$.next(action.payload);
	return action;
	};

	function upsert(ary, pred, val) {
	if (ary.some(item => pred(val, item))) {
	return ary.map(item => (pred(val, item) ? val : item))
	}
	return ary.concat(val);
	}
	// greedy replace as it replaces all matches of predicate
	const replace = (predicate, value, collection) => {
	return collection.map(item => predicate(item, value) ? value : item)
	}

	console.clear();
	/**
	* A contrived data source to use in our "observable"
	* NOTE: this will clearly never error
	*/

	class DataSource {
	constructor() {
	let i = 0;
	this._id = setInterval(() => this.emit(i++), 200);

	const when = (val, whenTrue) => { if (val) { return whenTrue() } else { return null } }

	{when(thingIsTrue, () => <Component />)}

	exports.myService = {
	f: function (x, y) { someServiceImpl.doThing(x, y); }
	};
	// functional DI

	exports.myservice = function(someServicImpl) {
	return {
	f: function (x, y) { someServiceImpl.doThing(x, y);
	}
	}

	const el = document.createElement.bind(document)
	const text = document.createTextNode.bind(document)
	const append = (parent, ...children) => {
	children.forEach(c => parent.appendChild(c))
	return parent
	}

	// Hide the freaking side effects
	const unsafeTap = f => x => (f(x), x);
	const log = unsafeTap(console.log.bind(console));