Add lens composition helper

Author: jvanbruegge

.nojekyll

@@ -7,8 +7,9 @@
   "typings": "lib/es6/index.d.ts",
   "scripts": {
     "build": "tsc -d && tsc -d --module ES6 --outDir lib/es6",
-    "documentation": "typedoc --out docs src && cp-cli .nojekyll docs/.nojekyll",
-    "prepublishOnly": "npm run build && npm run documentation"
+    "format": "prettier --tab-width 4 --single-quote --write './src/**/*.{js,ts,tsx}'",
+    "documentation": "typedoc --out docs src && touch docs/.nojekyll",
+    "prepublishOnly": "npm run format && npm run build && npm run documentation"
   },
   "keywords": [
     "cyclejs",
@@ -18,6 +19,7 @@
   "license": "MIT",
   "devDependencies": {
     "cp-cli": "^1.0.2",
+    "prettier": "^1.8.2",
     "release-it": "^3.1.2",
     "typedoc": "^0.9.0",
     "typescript": "^2.5.3",

package-lock.json

@@ -1,5 +1,5 @@
 import xs, { Stream } from 'xstream';
-import { Instances } from 'cycle-onionify';
+import { Instances, Lens } from 'cycle-onionify';
 
 export type Sinks = any;
 export type Sources = any;
@@ -15,29 +15,35 @@ export interface MergeExceptions {
  * @param  {MergeExceptions}  exceptions a dictionary of special channels, e.g. DOM
  * @return {Sinks}            the new unified sink
  */
-export function mergeSinks(sinks: Sinks[], exceptions: MergeExceptions = {}): Sinks
-{
-    const drivers : string[] = sinks
+export function mergeSinks(
+    sinks: Sinks[],
+    exceptions: MergeExceptions = {}
+): Sinks {
+    const drivers: string[] = sinks
         .map(Object.keys)
         .reduce((acc, curr) => acc.concat(curr), [])
-        .reduce((acc, curr) => acc.indexOf(curr) === -1 ? [...acc, curr] : acc, []);
-
-    const emptySinks : any = drivers
-        .map(s => ({ [s]: [] }) as any)
-        .reduce((acc, curr) => Object.assign(acc, curr ), {});
-
-    const combinedSinks = sinks
-        .reduce((acc, curr) => {
-            return Object.keys(acc)
-                .map(s => ({ [s]: acc[s]}))
-                .map(o => {
-                    const name : string = Object.keys(o)[0];
-                    return !curr[name] ? o : {
-                        [name]: [...o[name], curr[name]]
-                    };
-                })
-                .reduce((a, c) => Object.assign(a, c), {});
-        }, emptySinks);
+        .reduce(
+            (acc, curr) => (acc.indexOf(curr) === -1 ? [...acc, curr] : acc),
+            []
+        );
+
+    const emptySinks: any = drivers
+        .map(s => ({ [s]: [] } as any))
+        .reduce((acc, curr) => Object.assign(acc, curr), {});
+
+    const combinedSinks = sinks.reduce((acc, curr) => {
+        return Object.keys(acc)
+            .map(s => ({ [s]: acc[s] }))
+            .map(o => {
+                const name: string = Object.keys(o)[0];
+                return !curr[name]
+                    ? o
+                    : {
+                          [name]: [...o[name], curr[name]]
+                      };
+            })
+            .reduce((a, c) => Object.assign(a, c), {});
+    }, emptySinks);
 
     const merged = Object.keys(combinedSinks)
         .filter(name => Object.keys(exceptions).indexOf(name) === -1)
@@ -49,7 +55,8 @@ export function mergeSinks(sinks: Sinks[], exceptions: MergeExceptions = {}): Si
         .filter(([_, arr]) => arr !== undefined)
         .map(([key, arr]) => ({ [key]: exceptions[key](arr) }));
 
-    return merged.concat(special)
+    return merged
+        .concat(special)
         .reduce((acc, curr) => Object.assign(acc, curr), {});
 }
 
@@ -61,18 +68,23 @@ export interface PickMergeExceptions {
  * Just like mergeSinks, but for onionify collections
  * @see mergeSinks
  */
-export function pickMergeSinks(driverNames: string[], exceptions: PickMergeExceptions = {}): (ins: Instances<any>) => Sinks {
+export function pickMergeSinks(
+    driverNames: string[],
+    exceptions: PickMergeExceptions = {}
+): (ins: Instances<any>) => Sinks {
     return instances => {
         const merged: Sinks = driverNames
             .filter(name => Object.keys(exceptions).indexOf(name) === -1)
             .map(name => ({ [name]: instances.pickMerge(name) }));
 
-        const special = Object.keys(exceptions)
-            .map(key => ({ [key]: exceptions[key](instances) }));
+        const special = Object.keys(exceptions).map(key => ({
+            [key]: exceptions[key](instances)
+        }));
 
-        return merged.concat(special)
-            .reduce((acc, curr) => Object.assign(acc, curr ), {});
-    }
+        return merged
+            .concat(special)
+            .reduce((acc, curr) => Object.assign(acc, curr), {});
+    };
 }
 
 /**
@@ -81,14 +93,16 @@ export function pickMergeSinks(driverNames: string[], exceptions: PickMergeExcep
  * @param  {string[]}      driverNames the names of all drivers that are possibly in the stream, it's best to use Object.keys() on your driver object
  * @return {Sinks}                     A sinks containing the streams of the last emission in the sinks$
  */
-export function extractSinks(sinks$ : Stream<Sinks>, driverNames : string[]) : Sinks
-{
+export function extractSinks(
+    sinks$: Stream<Sinks>,
+    driverNames: string[]
+): Sinks {
     return driverNames
         .map(d => ({
-        [d]: sinks$
-            .map<Stream<any> | undefined>(s => s[d])
-            .filter(b => !!b)
-            .flatten()
+            [d]: sinks$
+                .map<Stream<any> | undefined>(s => s[d])
+                .filter(b => !!b)
+                .flatten()
         }))
         .reduce((acc, curr) => Object.assign(acc, curr), {});
 }
@@ -100,12 +114,34 @@ export function extractSinks(sinks$ : Stream<Sinks>, driverNames : string[]) : S
  * @param  {string} name The name of the export. For loading a default export simply ignore
  * @return {Component} A dummy that loads the actual component
  */
-export function loadAsync(moduleLoader: () => any, driverNames: string[], name: string = 'default'): Component {
+export function loadAsync(
+    moduleLoader: () => any,
+    driverNames: string[],
+    name: string = 'default'
+): Component {
     return sources => {
-        const lazyComponent$: Stream<Sinks> = xs.fromPromise(moduleLoader())
+        const lazyComponent$: Stream<Sinks> = xs
+            .fromPromise(moduleLoader())
             .map(m => m[name])
             .map(m => m(sources));
 
         return extractSinks(lazyComponent$, driverNames);
     };
 }
+
+/**
+ * Composes two lenses to one
+ * @param {Lens<A, B>} outer
+ * @param {Lens<B, C>} inner
+ * @return {Lens<A, C>} composed lens
+ */
+export function composeLenses<A, B, C>(
+    outer: Lens<A, B>,
+    inner: Lens<B, C>
+): Lens<A, C> {
+    return {
+        get: parent => inner.get(outer.get(parent)),
+        set: (parent, child) =>
+            outer.set(parent, inner.set(outer.get(parent), child))
+    };
+}