jlong

var parser = document.createElement('a');
parser.href = "http://example.com:3000/pathname/?search=test#hash";

parser.protocol; // => "http:"
parser.hostname; // => "example.com"
parser.port;     // => "3000"
parser.pathname; // => "/pathname/"
parser.search;   // => "?search=test"
parser.hash;     // => "#hash"
parser.host;     // => "example.com:3000"

mikaelbr

// === Arrays

var [a, b] = [1, 2];
console.log(a, b);
//=> 1 2


// Use from functions, only select from pattern
var foo = () => [1, 2, 3];

domenic

pr () {
  git fetch origin refs/pull/$1/head:refs/remotes/origin/pr/$1 --force
  git checkout -b pr/$1 origin/pr/$1
  git rebase master
  git checkout master
  git merge pr/$1 --ff-only
}

gaearon

/**
 * Stores are just seed + reduce function.
 * Notice they are plain objects and don't own the state.
 */
const countUpStore = {
  seed: {
    counter: 0
  },

  reduce(state, action) {

goatslacker

import { Dispatcher } from 'flux'

function isPromise(obj) {
  return obj && (typeof obj === 'object' || typeof obj === 'function') &&
    typeof obj.then === 'function'
}

const inject = Math.random().toString(16).substr(2, 7)

class Alt {

vslinko

Experimental Relay Implementation

Features:

• Relay.fetch(graphqlQuery) returns subscribtion that could change over time by mutation queries.
• Relay.update(m: UpdateMutation) optimistically updates resource in all previous queries that contains updated resource.
• Relay.update(m: DeleteMutation) optimistically deletes resource from all previous queries that contains deleted resource.
• Relay.update(m: CreateMutation) pessimistically creates resource and executes again all previous queries.
• All objects with id key in graphql response explained as resources. Arrays, objects without id and scalars explained as static properties.

yelouafi

// Observable is an Union Type, with the following variants
const Empty   = () => ['EMPTY']
const Cons    = (head, tail) => ['CONS', head, tail]
const Future  = promise => ['FUTURE', promise]

// race between 2 promises; each promise will resolve to a lazy value
const lazyRace = (p1, p2) => Promise.race([p1,p2]).then(lazy => lazy())

// function composition
const compose = (...fns) => (arg) => fns.reduceRight((res, f) => f(res), arg)

rgrove

Can't share the complete code because the app's closed source and still in stealth mode, but here's how I'm using React Router and Redux in a large app with server rendering and code splitting on routes.

Server

1. Wildcard Express route configures a Redux store for each request and makes an addReducers() callback available to the getComponents() method of each React Router route. Each route is responsible for adding any Redux reducers it needs when it's loaded. (This isn't really necessary on the

edwork

CEC-Detection

Want to control a TV over HDMI-CEC via a remote RasPi? Include the following as a switch:

platform: command_line
switches:
    tv_power:
      command_on: "ssh pi@<ip_address> -i /home/homeassistant/.homeassistant/id_homeassistant 'echo on 0 | cec-client -s -d 1'"
 command_off: "ssh pi@ -i /home/homeassistant/.homeassistant/id_homeassistant 'echo standby 0 | cec-client -s -d 1'"

Spirotot

#!/bin/bash
# Sway WM screen + audio recorder
# Usage: ./record -d [display] -a [audio_device] -o [project_output_name]
#
# Displays can be listed with `swaymsg -t get_outputs`.
# Audio devices can be listed with `arecord -l`.
# Probably best not to put spaces in the "-o" argument, sorry...
# 
# Dependencies: ffmpeg, alsamixer
#