3.1 refactor cells rendering

demo/App.js

@@ -5,6 +5,7 @@ import PropTypes from 'prop-types';
 import { Table } from 'dash-table';
 import {mockData} from './data';
 import { memoizeOne } from 'core/memoizer';
+import Logger from 'core/Logger';
 
 const clone = o => JSON.parse(JSON.stringify(o));
 
@@ -49,7 +50,7 @@ class App extends Component {
 
         const setProps = memoizeOne(() => {
             return newProps => {
-                console.info('--->', newProps);
+                Logger.debug('--->', newProps);
                 this.setState(prevState => ({
                     tableProps: R.merge(prevState.tableProps, newProps)
                 }));

demo/index.js

@@ -5,6 +5,6 @@ import App from './App';
 import Logger, { DebugLevel, LogLevel } from 'core/Logger';
 
 Logger.setDebugLevel(DebugLevel.DEBUG);
-Logger.setLogLevel(LogLevel.WARNING);
+Logger.setLogLevel(LogLevel.NONE);
 
 ReactDOM.render(<App />, document.getElementById('root'));

src/core/math/arrayZipMap.ts

@@ -0,0 +1,37 @@
+import * as R from 'ramda';
+
+type Array<T> = T[];
+
+export function arrayMap<T1, T2, TR>(
+    a1: Array<T1>,
+    a2: Array<T2>,
+    cb: (d1: T1, d2: T2, i: number) => TR
+) {
+    const mapArray = R.addIndex<T1, TR>(R.map);
+
+    return mapArray((iValue, i) => cb(iValue, a2[i], i), a1);
+}
+
+export function arrayMap3<T1, T2, T3, TR>(
+    a1: Array<T1>,
+    a2: Array<T2>,
+    a3: Array<T3>,
+    cb: (d1: T1, d2: T2, d3: T3, i: number) => TR
+) {
+    const mapArray = R.addIndex<T1, TR>(R.map);
+
+    return mapArray((iValue, i) => cb(iValue, a2[i], a3[i], i), a1);
+
+}
+
+export function arrayMapN<TR>(
+    cb: (i: number, ...args: any[]) => TR,
+    ...arrays: (any[])[]
+) {
+    const a1 = arrays.slice(0, 1);
+    const as = arrays.slice(1);
+
+    const mapArray = R.addIndex<any, TR>(R.map);
+
+    return mapArray((iValue, i) => cb(i, [iValue, ...as.map(a => a[i])]), a1);
+}

src/core/math/matrixZipMap.ts

@@ -0,0 +1,72 @@
+import * as R from 'ramda';
+
+type Matrix<T> = T[][];
+
+export function matrixMap<T1, T2, TR>(
+    m1: Matrix<T1>,
+    m2: Matrix<T2>,
+    cb: (d1: T1, d2: T2, i: number, j: number) => TR
+) {
+    const mapMatrix = R.addIndex<T1[], TR[]>(R.map);
+    const mapRow = R.addIndex<T1, TR>(R.map);
+
+    return mapMatrix((iRow, i) =>
+        mapRow(
+            (ijValue, j) => cb(ijValue, m2[i][j], i, j),
+            iRow
+        ), m1
+    );
+}
+
+export function matrixMap3<T1, T2, T3, TR>(
+    m1: Matrix<T1>,
+    m2: Matrix<T2>,
+    m3: Matrix<T3>,
+    cb: (d1: T1, d2: T2, d3: T3, i: number, j: number) => TR
+) {
+    const mapMatrix = R.addIndex<T1[], TR[]>(R.map);
+    const mapRow = R.addIndex<T1, TR>(R.map);
+
+    return mapMatrix((iRow, i) =>
+        mapRow(
+            (ijValue, j) => cb(ijValue, m2[i][j], m3[i][j], i, j),
+            iRow
+        ), m1
+    );
+}
+
+export function matrixMap4<T1, T2, T3, T4, TR>(
+    m1: Matrix<T1>,
+    m2: Matrix<T2>,
+    m3: Matrix<T3>,
+    m4: Matrix<T4>,
+    cb: (d1: T1, d2: T2, d3: T3, d4: T4, i: number, j: number) => TR
+) {
+    const mapMatrix = R.addIndex<T1[], TR[]>(R.map);
+    const mapRow = R.addIndex<T1, TR>(R.map);
+
+    return mapMatrix((iRow, i) =>
+        mapRow(
+            (ijValue, j) => cb(ijValue, m2[i][j], m3[i][j], m4[i][j], i, j),
+            iRow
+        ), m1
+    );
+}
+
+export function matrixMapN<TR>(
+    cb: (i: number, j: number, ...args: any[]) => TR,
+    ...matrices: (any[][])[]
+) {
+    const m1 = matrices.slice(0, 1);
+    const ms = matrices.slice(1);
+
+    const mapMatrix = R.addIndex<any[], TR[]>(R.map);
+    const mapRow = R.addIndex<any, TR>(R.map);
+
+    return mapMatrix((iRow, i) =>
+        mapRow(
+            (ijValue, j) => cb(i, j, [ijValue, ...ms.map(m => m[i][j])]),
+            iRow
+        ), m1
+    );
+}

src/core/memoizer.ts

@@ -14,11 +14,10 @@ export function memoizeOne<
     let lastArgs: any[] | null = null;
     let lastResult: any;
 
-    return (...args: TArgs): TEntry => {
-        return isEqualArgs(lastArgs, args) ?
+    return (...args: TArgs): TEntry =>
+        isEqualArgs(lastArgs, args) ?
             lastResult :
             (lastArgs = args) && (lastResult = fn(...args));
-    };
 }
 
 export function memoizeOneFactory<

src/core/memoizerCache.ts

@@ -15,7 +15,7 @@ export default function memoizerCache<
 {
     const cache = new Map<CacheKeyFragment, any>();
 
-    return (key: TKey, args: TArgs): TEntry => {
+    return (key: TKey, ...args: TArgs): TEntry => {
         const lastKey = key.slice(-1)[0];
         const cacheKeys = key.slice(0, -1);