@hpcc-js/common 3.6.5 → 3.7.0

package/src/Database.ts

@@ -1,860 +1,860 @@
-import { deviation as d3Deviation, max as d3Max, mean as d3Mean, median as d3Median, min as d3Min, sum as d3Sum, variance as d3Variance } from "d3-array";
-import { map as d3Map, nest as d3Nest } from "d3-collection";
-import { csvFormatRows as d3CsvFormatRows, csvParse as d3CsvParse, tsvFormatRows as d3TsvFormatRows, tsvParse as d3TsvParse } from "d3-dsv";
-import { format as d3Format } from "d3-format";
-import { timeFormat as d3TimeFormat, timeParse as d3TimeParse } from "d3-time-format";
-import { PropertyExt } from "./PropertyExt.ts";
-import * as Utility from "./Utility.ts";
-
-const d3Aggr = {
-    min: d3Min,
-    max: d3Max,
-    mean: d3Mean,
-    median: d3Median,
-    variance: d3Variance,
-    deviation: d3Deviation,
-    sum: d3Sum
-};
-
-let lastFoundFormat = null;
-
-export interface INestedColumn {
-    label: string;
-    columns: Array<string | INestedColumn>;
-}
-
-//  Field  ---
-export type FieldType = "string" | "number" | "boolean" | "date" | "time" | "hidden" | "nested";
-
-export class Field extends PropertyExt {
-    private _owner: Grid;
-    idx: number;
-    protected _children: Field[] = [];
-
-    constructor(id?) {
-        super();
-
-        this._id = id || this._id;
-    }
-
-    owner(): Grid;
-    owner(_: Grid): this;
-    owner(_?: Grid): Grid | this {
-        if (!arguments.length) return this._owner;
-        this._owner = _;
-        return this;
-    }
-
-    valid(): boolean {
-        return !!this.label();
-    }
-
-    checksum(): string {
-        return Utility.checksum(this.label() + this.type() + this.mask() + this.format());
-    }
-
-    typeTransformer(_: any) {
-        switch (this.type()) {
-            case "number":
-                return Number(_);
-            case "string":
-                return String(_);
-            case "boolean":
-                return typeof (_) === "string" && ["false", "off", "0"].indexOf(_.toLowerCase()) >= 0 ? false : Boolean(_);
-            case "time":
-            case "date":
-                return this.maskTransformer(_);
-        }
-        return _;
-    }
-
-    maskTransformer(_) {
-        return this.formatter(this.mask()).parse(String(_));
-    }
-
-    formatTransformer(_) {
-        return this.formatter(this.format())(_);
-    }
-
-    parse(_) {
-        if (!_) {
-            return _;
-        }
-        try {
-            return this.typeTransformer(_);
-        } catch (e) {
-            console.warn("Unable to parse:  " + _);
-            return null;
-        }
-    }
-
-    transform(_) {
-        if (!_) {
-            return _;
-        }
-        try {
-            return this.formatTransformer(this.typeTransformer(_));
-        } catch (e) {
-            console.warn("Unable to transform:  " + _);
-            return null;
-        }
-    }
-
-    clone() {
-        const context = this;
-        const retVal = new Field(this._id);
-        cloneProp(retVal, "label");
-        cloneProp(retVal, "type");
-        cloneProp(retVal, "mask");
-        cloneProp(retVal, "format");
-
-        function cloneProp(dest, key) {
-            dest[key + "_default"](context[key + "_default"]());
-            if (context[key + "_exists"]()) {
-                dest[key](context[key]());
-            }
-        }
-        return retVal;
-    }
-
-    formatter(format) {
-        let retVal;
-        if (!format) {
-            retVal = function (_) {
-                return _;
-            };
-            retVal.parse = function (_) {
-                return _;
-            };
-            return retVal;
-        }
-        switch (this.type()) {
-            case "time":
-            case "date":
-                return d3TimeFormat(format);
-        }
-        retVal = d3Format(format);
-        retVal.parse = function (_) {
-            return _;
-        };
-        return retVal;
-    }
-
-    children(): Field[];
-    children(_: Array<string | INestedColumn | Field>, asDefault?: boolean): this;
-    children(_?: Array<string | INestedColumn | Field>, asDefault?: boolean): Field[] | this {
-        if (_ === void 0) return this._children;
-        this.type("nested");
-        const fieldsArr = this._children;
-        this._children = _.map((field: string | INestedColumn | Field, idx): Field => {
-            if (field instanceof Field) {
-                fieldsArr[idx] = field;
-                return field;
-            } else if (typeof field === "string") {
-                if (asDefault) {
-                    return (fieldsArr[idx] || new Field()).label_default(field);
-                } else {
-                    return (fieldsArr[idx] || new Field()).label(field);
-                }
-            } else {
-                if (asDefault) {
-                    return (fieldsArr[idx] || new Field())
-                        .label_default(field.label)
-                        .children(field.columns) as Field
-                        ;
-                } else {
-                    return (fieldsArr[idx] || new Field())
-                        .label(field.label)
-                        .children(field.columns) as Field
-                        ;
-                }
-            }
-        }, this);
-        return this;
-    }
-
-}
-Field.prototype._class += " common_Database.Field";
-
-export interface Field {
-    label(): string;
-    label(_: string): this;
-    label_default(): string;
-    label_default(_: string): this;
-    type(): FieldType;
-    type(_: FieldType): this;
-    mask(): string;
-    mask(_: string): this;
-    format(): string;
-    format(_: string): this;
-}
-
-Field.prototype.publish("label", "", "string", "Label", null, { optional: true });
-Field.prototype.publish("type", "", "set", "Type", ["", "string", "number", "boolean", "date", "time", "hidden", "nested"], { optional: true });
-Field.prototype.publish("mask", "", "string", "Time Mask", null, { disable: (w: any) => w.type() !== "time", optional: true });
-Field.prototype.publish("format", "", "string", "Format", null, { optional: true });
-
-//  Grid  ---
-export class Grid extends PropertyExt {
-    _dataChecksum: boolean;
-    _dataVersion: number;
-
-    private _data = [];
-    private _dataChecksums = [];
-
-    constructor(dataChecksum?) {
-        super();
-        dataChecksum = dataChecksum || false;
-        this._dataChecksum = dataChecksum;
-        this._dataVersion = 0;
-        this.clear();
-    }
-
-    clear() {
-        this.fields([]);
-        this._data = [];
-        this._dataChecksums = [];
-        ++this._dataVersion;
-        return this;
-    }
-
-    //  Backward compatability  ---
-    resetColumns() {
-        const fields = this.fields() as Field[];
-        this.legacyColumns([]);
-        this.legacyColumns(fields.map(function (field) {
-            return field.label();
-        }));
-    }
-
-    legacyColumns(_?, asDefault?): any | Grid {
-        if (!arguments.length) return this.row(0);
-        this.row(0, _, asDefault);
-        return this;
-    }
-
-    legacyData(_?, _clone?) {
-        return Grid.prototype.data.apply(this, arguments);
-    }
-
-    //  Meta  ---
-    schema() {
-    }
-
-    field(idx) {
-        return this.fields()[idx];
-    }
-
-    fieldByLabel(_, ignoreCase?) {
-        return this.fields().filter(function (field: Field, idx) {
-            field.idx = idx;
-            return ignoreCase ? field.label().toLowerCase() === _.toLowerCase() : field.label() === _;
-        })[0];
-    }
-
-    data(_?, clone?): any | Grid {
-        if (!arguments.length) return this._data;
-        this._data = clone ? _.map(function (d) { return d.map(function (d2) { return d2; }); }) : _;
-        this._dataCalcChecksum();
-        return this;
-    }
-
-    parsedData() {
-        const context = this;
-        return this._data.map(function (row) {
-            return row.map(function (cell, idx) {
-                return context.fields()[idx].parse(cell);
-            });
-        });
-    }
-
-    formattedData() {
-        return this._data.map(row => {
-            return this.fields().map((field, idx) => {
-                return field.transform(row[idx]);
-            });
-        });
-    }
-
-    fieldsChecksum() {
-        return Utility.checksum(this.fields().map(function (field) { return field.checksum(); }));
-    }
-
-    dataChecksum() {
-        return Utility.checksum(this._dataChecksum ? this._dataChecksums : this._dataVersion);
-    }
-
-    checksum() {
-        return Utility.checksum([this.dataChecksum(), this.fieldsChecksum()]);
-    }
-
-    //  Row Access  ---
-    private _dataCalcChecksum(idx?) {
-        ++this._dataVersion;
-        if (this._dataChecksum) {
-            if (arguments.length) {
-                this._dataChecksums[idx] = Utility.checksum(this._data[idx]);
-            } else {
-                this._dataChecksums = this._data.map(function (row) { return Utility.checksum(row); });
-            }
-        }
-        return this;
-    }
-
-    row(row?, _?, asDefault?): any | Grid {
-        if (arguments.length < 2) return row === 0 ? this.fields().map(function (d) { return d.label(); }) : this._data[row - 1];
-        if (row === 0) {
-            const fieldsArr = this.fields();
-            this.fields(_.map(function (field: string | INestedColumn, idx) {
-                if (typeof field === "string") {
-                    if (asDefault) {
-                        return (fieldsArr[idx] || new Field()).label_default(field);
-                    } else {
-                        return (fieldsArr[idx] || new Field()).label(field);
-                    }
-                } else {
-                    if (asDefault) {
-                        return (fieldsArr[idx] || new Field())
-                            .label_default(field.label)
-                            .children(field.columns)
-                            ;
-                    } else {
-                        return (fieldsArr[idx] || new Field())
-                            .label(field.label)
-                            .children(field.columns)
-                            ;
-                    }
-                }
-            }, this));
-        } else {
-            this._data[row - 1] = _;
-            this._dataCalcChecksum(row - 1);
-        }
-        return this;
-    }
-
-    rows(_?): any | Grid {
-        if (!arguments.length) return [this.row(0)].concat(this._data);
-        this.row(0, _[0]);
-        this._data = _.filter(function (_row, idx) { return idx > 0; });
-        this._dataCalcChecksum();
-        return this;
-    }
-
-    //  Column Access  ---
-    column(col, _?): any | Grid {
-        if (arguments.length < 2) return [this.fields()[col].label()].concat(this._data.map(function (row, _idx) { return row[col]; }));
-        _.forEach(function (d, idx) {
-            if (idx === 0) {
-                this.fields()[col] = new Field().label(_[0]);
-            } else {
-                this._data[idx - 1][col] = d;
-                this._dataCalcChecksum(idx - 1);
-            }
-        }, this);
-        return this;
-    }
-
-    columnData(col, _): any | Grid {
-        if (arguments.length < 2) return this._data.map(function (row, _idx) { return row[col]; });
-        _.forEach(function (d, idx) {
-            this._data[idx][col] = d;
-            this._dataCalcChecksum(idx);
-        }, this);
-        return this;
-    }
-
-    columns(_?): any | Grid {
-        if (!arguments.length) return this.fields().map(function (_col, idx) {
-            return this.column(idx);
-        }, this);
-        _.forEach(function (_col, idx) {
-            this.column(idx, _[idx]);
-        }, this);
-        return this;
-    }
-
-    //  Cell Access  ---
-    cell(row, col, _) {
-        if (arguments.length < 3) return this.row(row)[col];
-        if (row === 0) {
-            this.fields()[col] = new Field().label(_);
-        } else {
-            this._data[row][col] = _;
-            this._dataCalcChecksum(row);
-        }
-        return this;
-    }
-
-    //  Grid Access  ---
-    grid(_?) {
-        return Grid.prototype.rows.apply(this, arguments);
-    }
-
-    //  Hipie Helpers  ---
-
-    hipieMappings(columns, missingDataString) {
-        missingDataString = missingDataString || "";
-        if (!this.fields().length || !this._data.length) {
-            return [];
-        }
-        const mappedColumns = [];
-        let hasRollup = false;
-        columns.forEach(function (mapping, idx) {
-            const mappedColumn = {
-                groupby: false,
-                func: "",
-                params: []
-            };
-            if (mapping.hasFunction()) {
-                mappedColumn.func = mapping.function();
-                if (mappedColumn.func === "SCALE") {
-                    mappedColumn.groupby = true;
-                } else {
-                    hasRollup = true;
-                }
-
-                mapping.params().forEach(function (param) {
-                    const field = this.fieldByLabel(param, true);
-                    mappedColumn.params.push(field ? field.idx : -1);
-                }, this);
-            } else {
-                mappedColumn.groupby = true;
-                const field = this.fieldByLabel(mapping.id(), true);
-                mappedColumn.params.push(field ? field.idx : -1);
-            }
-            mappedColumns.push(mappedColumn);
-        }, this);
-
-        if (hasRollup) {
-            const retVal = [];
-            this.rollup(mappedColumns.filter(function (mappedColumn) {
-                return mappedColumn.groupby === true;
-            }).map(function (d) {
-                return d.params[0];
-            }), function (leaves) {
-                const row = mappedColumns.map(function (mappedColumn) {
-                    const param1 = mappedColumn.params[0];
-                    const param2 = mappedColumn.params[1];
-                    switch (mappedColumn.func) {
-                        case "SUM":
-                            return d3Sum(leaves, function (d) { return d[param1]; });
-                        case "AVE":
-                            return d3Mean(leaves, function (d) { return d[param1] / d[param2]; });
-                        case "MIN":
-                            return d3Min(leaves, function (d) { return d[param1]; });
-                        case "MAX":
-                            return d3Max(leaves, function (d) { return d[param1]; });
-                        case "SCALE":
-                            console.warn("Unexpected function:  " + mappedColumn.func);
-                            //  All leaves should have the same values, use mean just in case they don't?
-                            return d3Mean(leaves, function (d) { return d[param1] / +param2; });
-                    }
-                    //  All leaves should have the same value.
-                    return leaves[0][param1];
-                });
-                retVal.push(row);
-                return row;
-            });
-            return retVal;
-        } else {
-            return this._data.map(function (row) {
-                return mappedColumns.map(function (mappedColumn) {
-                    const param1 = mappedColumn.params[0];
-                    const param2 = mappedColumn.params[1];
-                    switch (mappedColumn.func) {
-                        case "SCALE":
-                            return row[param1] / +param2;
-                        case "SUM":
-                        case "AVE":
-                        case "MIN":
-                        case "MAX":
-                            console.warn("Unexpected function:  " + mappedColumn.func);
-                    }
-                    return row[param1];
-                });
-            });
-        }
-    }
-
-    legacyView() {
-        return new LegacyView(this);
-    }
-
-    nestView(columnIndicies) {
-        return new RollupView(this, columnIndicies);
-    }
-
-    rollupView(columnIndicies, rollupFunc?) {
-        return new RollupView(this, columnIndicies, rollupFunc);
-    }
-
-    aggregateView(columnIndicies, aggrType, aggrColumn, aggrDeltaColumn = "") {
-        const context = this;
-        return new RollupView(this, columnIndicies, function (values) {
-            switch (aggrType) {
-                case null:
-                case undefined:
-                case "":
-                    values.aggregate = values.length;
-                    return values;
-                default:
-                    const columns = context.legacyColumns();
-                    const colIdx = columns.indexOf(aggrColumn);
-                    const deltaIdx = columns.indexOf(aggrDeltaColumn);
-                    values.aggregate = d3Aggr[aggrType](values, function (value) {
-                        return (+value[colIdx] - (deltaIdx >= 0 ? +value[deltaIdx] : 0)) / (deltaIdx >= 0 ? +value[deltaIdx] : 1);
-                    });
-                    return values;
-            }
-        });
-    }
-
-    //  Nesting  ---
-    private _nest(columnIndicies, _rollup?) {
-        if (!(columnIndicies instanceof Array)) {
-            columnIndicies = [columnIndicies];
-        }
-        const nest = d3Nest();
-        columnIndicies.forEach(function (idx) {
-            nest.key(function (d) {
-                return d[idx];
-            });
-        });
-        return nest;
-    }
-
-    nest(columnIndicies) {
-        return this._nest(columnIndicies)
-            .entries(this._data)
-            ;
-    }
-
-    rollup(columnIndicies, rollup) {
-        return this._nest(columnIndicies)
-            .rollup(rollup)
-            .entries(this._data)
-            ;
-    }
-
-    //  Util  ---
-    length() {
-        return this._data.length + 1;
-    }
-
-    width() {
-        return this.fields().length;
-    }
-
-    pivot() {
-        this.resetColumns();
-        this.rows(this.columns());
-        return this;
-    }
-
-    clone(deep) {
-        return new Grid()
-            .fields(this.fields(), deep)
-            .data(this.data(), deep)
-            ;
-    }
-
-    filter(filter) {
-        const filterIdx = {};
-        this.row(0).forEach(function (col, idx) {
-            filterIdx[col] = idx;
-        });
-        return new Grid()
-            .fields(this.fields(), true)
-            .data(this.data().filter(function (row) {
-                for (const key in filter) {
-                    if (filter[key] !== row[filterIdx[key]]) {
-                        return false;
-                    }
-                }
-                return true;
-            }))
-            ;
-    }
-
-    analyse(columns) {
-        if (!(columns instanceof Array)) {
-            columns = [columns];
-        }
-        const retVal = [];
-        columns.forEach(function (col) {
-            const rollup = this.rollup(col, function (leaves) {
-                return leaves.length;
-            });
-            retVal.push(rollup);
-            const keys = rollup.map(function (d) { return d.key; });
-            this.fields()[col].isBoolean = typeTest(keys, isBoolean);
-            this.fields()[col].isNumber = typeTest(keys, isNumber);
-            this.fields()[col].isString = !this.fields()[col].isNumber && typeTest(keys, isString);
-            this.fields()[col].isUSState = this.fields()[col].isString && typeTest(keys, isUSState);
-            this.fields()[col].isDateTime = this.fields()[col].isString && typeTest(keys, isDateTime);
-            this.fields()[col].isDateTimeFormat = lastFoundFormat;
-            this.fields()[col].isDate = !this.fields()[col].isDateTime && typeTest(keys, isDate);
-            this.fields()[col].isDateFormat = lastFoundFormat;
-            this.fields()[col].isTime = this.fields()[col].isString && !this.fields()[col].isDateTime && !this.fields()[col].isDate && typeTest(keys, isTime);
-            this.fields()[col].isTimeFormat = lastFoundFormat;
-        }, this);
-        return retVal;
-    }
-
-    //  Import/Export  ---
-    jsonObj(_?): any | Grid {
-        if (!arguments.length) return this._data.map(function (row) {
-            const retVal = {};
-            this.row(0).forEach(function (col, idx) {
-                retVal[col] = row[idx];
-            });
-            return retVal;
-        }, this);
-        this.clear();
-        this.data(_.map(function (row) {
-            const retVal = [];
-            for (const key in row) {
-                let colIdx = this.row(0).indexOf(key);
-                if (colIdx < 0) {
-                    colIdx = this.fields().length;
-                    this.fields().push(new Field().label(key));
-                }
-                retVal[colIdx] = row[key];
-            }
-            return retVal;
-        }, this));
-        return this;
-    }
-
-    json(_: string | object): this;
-    json(): string;
-    json(_?: string | object): string | this {
-        if (!arguments.length) return JSON.stringify(this.jsonObj(), null, "  ");
-        if (typeof (_) === "string") {
-            _ = JSON.parse(_);
-        }
-        this.jsonObj(_);
-        return this;
-    }
-
-    csv(_: string): this;
-    csv(): string;
-    csv(_?: string): string | this {
-        if (!arguments.length) {
-            const temp = document.createElement("div");
-            return d3CsvFormatRows(this.grid().map(row => {
-                return row.map(cell => {
-                    return Utility.removeHTMLFromString(cell, temp);
-                });
-            }));
-        }
-        this.jsonObj(d3CsvParse(_));
-        return this;
-    }
-
-    tsv(_: string): this;
-    tsv(): string;
-    tsv(_?: string): string | this {
-        if (!arguments.length) return d3TsvFormatRows(this.grid());
-        this.jsonObj(d3TsvParse(_));
-        return this;
-    }
-}
-Grid.prototype._class += " common_Database.Grid";
-export interface Grid {
-    fields(): Field[];
-    fields(_: Field[], clone?: boolean): this;
-}
-
-Grid.prototype.publish("fields", [], "propertyArray", "Fields");
-const fieldsOrig = Grid.prototype.fields;
-Grid.prototype.fields = function (_?, clone?) {
-    if (!arguments.length) return fieldsOrig.apply(this, arguments);
-    return fieldsOrig.call(this, clone ? _.map(function (d) { return d.clone(); }) : _);
-};
-
-//  Views  ---
-export class LegacyView {
-    _grid;
-    _parsedData;
-    _parsedDataChecksum;
-    _formattedData;
-    _formattedDataChecksum;
-
-    constructor(grid) {
-        this._grid = grid;
-    }
-
-    checksum() {
-        const value = this._grid.on.apply(this._grid, arguments);
-        return value === this._grid ? this : value;
-    }
-
-    fields() {
-        const value = this._grid.on.apply(this._grid, arguments);
-        return value === this._grid ? this : value;
-    }
-
-    grid() {
-        return this._grid;
-    }
-    columns(_?) {
-        if (!arguments.length) return this._grid.legacyColumns();
-        this._grid.legacyColumns(_);
-        return this;
-    }
-    rawData(_?) {
-        if (!arguments.length) return this._grid.legacyData();
-        this._grid.legacyData(_);
-        return this;
-    }
-    formattedData() {
-        if (this._formattedDataChecksum !== this._grid.checksum()) {
-            this._formattedDataChecksum = this._grid.checksum();
-            this._formattedData = this._grid.formattedData();
-        }
-        return this._formattedData;
-    }
-    parsedData() {
-        if (this._parsedDataChecksum !== this._grid.checksum()) {
-            this._parsedDataChecksum = this._grid.checksum();
-            this._parsedData = this._grid.parsedData();
-        }
-        return this._parsedData;
-    }
-    protected _whichData(opts?) {
-        if (opts) {
-            if (opts.parsed) {
-                return this.formattedData();
-            } else if (opts.formatted) {
-                return this.formattedData();
-            }
-        }
-        return this.rawData();
-    }
-    data(_) {
-        return LegacyView.prototype.rawData.apply(this, arguments);
-    }
-}
-
-export class RollupView extends LegacyView {
-    _columnIndicies;
-    _rollup;
-    _nestChecksum;
-    _nest;
-
-    constructor(grid, columns, rollup?) {
-        super(grid);
-        if (!(columns instanceof Array)) {
-            columns = [columns];
-        }
-        this._columnIndicies = columns.filter(function (column) { return column; }).map(function (column) {
-            switch (typeof column) {
-                case "string":
-                    return this._grid.fieldByLabel(column).idx;
-            }
-            return column;
-        }, this);
-
-        rollup = rollup || function (d) { return d; };
-        this._rollup = rollup;
-    }
-
-    nest() {
-        if (this._nestChecksum !== this._grid.checksum()) {
-            this._nestChecksum = this._grid.checksum();
-
-            const nest = d3Nest();
-            this._columnIndicies.forEach(function (idx) {
-                nest.key(function (d) {
-                    return d[idx];
-                });
-            });
-            this._nest = nest
-                .rollup(this._rollup)
-                ;
-        }
-        return this._nest;
-    }
-    entries(opts?) {
-        return this.nest().entries(this._whichData(opts));
-    }
-    map(opts) {
-        return this.nest().map(this._whichData(opts));
-    }
-    d3Map(opts) {
-        return this.nest().map(this._whichData(opts), d3Map);
-    }
-    _walkData(entries, prevRow = []) {
-        let retVal = [];
-        entries.forEach(function (entry) {
-            if (entry instanceof Array) {
-                retVal.push(prevRow.concat([entry]));
-            } else if (entry.values instanceof Array) {
-                retVal = retVal.concat(this._walkData(entry.values, prevRow.concat([entry.key])));
-            } else if (entry.value instanceof Array) {
-                retVal = retVal.concat(this._walkData(entry.value, prevRow.concat([entry.key])));
-            }
-        }, this);
-        return retVal;
-    }
-    data(opts) {
-        return this._walkData(this.entries(opts));
-    }
-}
-
-//  --- --- ---
-function typeTest(cells, test) {
-    if (!(cells instanceof Array)) {
-        cells = [cells];
-    }
-    return cells.filter(function (d) { return d !== ""; }).every(test);
-}
-function isBoolean(cell) {
-    return typeof cell === "boolean";
-}
-function isNumber(cell) {
-    return typeof cell === "number" || !isNaN(cell);
-}
-function isString(cell) {
-    return typeof cell === "string";
-}
-const dateTimeFormats = [
-];
-const dateFormats = [
-    "%Y-%m-%d",
-    "%Y%m%d"
-];
-const timeFormats = [
-    "%H:%M:%S.%LZ",
-    "%H:%M:%SZ",
-    "%H:%M:%S"
-];
-dateFormats.forEach(function (d) {
-    timeFormats.forEach(function (t) {
-        dateTimeFormats.push(d + "T" + t);
-    });
-});
-function formatPicker(formats, cell) {
-    for (let i = 0; i < formats.length; ++i) {
-        const date = d3TimeParse(formats[i])(cell);
-        if (date) {
-            lastFoundFormat = formats[i];
-            return formats[i];
-        }
-    }
-    return null;
-}
-function isDateTime(cell) {
-    return formatPicker(dateTimeFormats, cell);
-}
-function isDate(cell) {
-    return formatPicker(dateFormats, cell);
-}
-function isTime(cell) {
-    return formatPicker(timeFormats, cell);
-}
-function isUSState(cell) {
-    return ["AL", "AK", "AZ", "AR", "CA", "CO", "CT", "DE", "FL", "GA", "HI", "ID", "IL", "IN", "IA", "KS", "KY", "LA", "ME", "MD", "MA", "MI", "MN", "MS", "MO", "MT", "NE", "NV", "NH", "NJ", "NM", "NY", "NC", "ND", "OH", "OK", "OR", "PA", "RI", "SC", "SD", "TN", "TX", "UT", "VT", "VA", "WA", "WV", "WI", "WY", "AS", "DC", "FM", "GU", "MH", "MP", "PW", "PR", "VI"].indexOf(String(cell).toUpperCase()) >= 0;
-}
+import { deviation as d3Deviation, max as d3Max, mean as d3Mean, median as d3Median, min as d3Min, sum as d3Sum, variance as d3Variance } from "d3-array";
+import { map as d3Map, nest as d3Nest } from "d3-collection";
+import { csvFormatRows as d3CsvFormatRows, csvParse as d3CsvParse, tsvFormatRows as d3TsvFormatRows, tsvParse as d3TsvParse } from "d3-dsv";
+import { format as d3Format } from "d3-format";
+import { timeFormat as d3TimeFormat, timeParse as d3TimeParse } from "d3-time-format";
+import { PropertyExt } from "./PropertyExt.ts";
+import * as Utility from "./Utility.ts";
+
+const d3Aggr = {
+    min: d3Min,
+    max: d3Max,
+    mean: d3Mean,
+    median: d3Median,
+    variance: d3Variance,
+    deviation: d3Deviation,
+    sum: d3Sum
+};
+
+let lastFoundFormat = null;
+
+export interface INestedColumn {
+    label: string;
+    columns: Array<string | INestedColumn>;
+}
+
+//  Field  ---
+export type FieldType = "string" | "number" | "boolean" | "date" | "time" | "hidden" | "nested";
+
+export class Field extends PropertyExt {
+    private _owner: Grid;
+    idx: number;
+    protected _children: Field[] = [];
+
+    constructor(id?) {
+        super();
+
+        this._id = id || this._id;
+    }
+
+    owner(): Grid;
+    owner(_: Grid): this;
+    owner(_?: Grid): Grid | this {
+        if (!arguments.length) return this._owner;
+        this._owner = _;
+        return this;
+    }
+
+    valid(): boolean {
+        return !!this.label();
+    }
+
+    checksum(): string {
+        return Utility.checksum(this.label() + this.type() + this.mask() + this.format());
+    }
+
+    typeTransformer(_: any) {
+        switch (this.type()) {
+            case "number":
+                return Number(_);
+            case "string":
+                return String(_);
+            case "boolean":
+                return typeof (_) === "string" && ["false", "off", "0"].indexOf(_.toLowerCase()) >= 0 ? false : Boolean(_);
+            case "time":
+            case "date":
+                return this.maskTransformer(_);
+        }
+        return _;
+    }
+
+    maskTransformer(_) {
+        return this.formatter(this.mask()).parse(String(_));
+    }
+
+    formatTransformer(_) {
+        return this.formatter(this.format())(_);
+    }
+
+    parse(_) {
+        if (!_) {
+            return _;
+        }
+        try {
+            return this.typeTransformer(_);
+        } catch (e) {
+            console.warn("Unable to parse:  " + _);
+            return null;
+        }
+    }
+
+    transform(_) {
+        if (!_) {
+            return _;
+        }
+        try {
+            return this.formatTransformer(this.typeTransformer(_));
+        } catch (e) {
+            console.warn("Unable to transform:  " + _);
+            return null;
+        }
+    }
+
+    clone() {
+        const context = this;
+        const retVal = new Field(this._id);
+        cloneProp(retVal, "label");
+        cloneProp(retVal, "type");
+        cloneProp(retVal, "mask");
+        cloneProp(retVal, "format");
+
+        function cloneProp(dest, key) {
+            dest[key + "_default"](context[key + "_default"]());
+            if (context[key + "_exists"]()) {
+                dest[key](context[key]());
+            }
+        }
+        return retVal;
+    }
+
+    formatter(format) {
+        let retVal;
+        if (!format) {
+            retVal = function (_) {
+                return _;
+            };
+            retVal.parse = function (_) {
+                return _;
+            };
+            return retVal;
+        }
+        switch (this.type()) {
+            case "time":
+            case "date":
+                return d3TimeFormat(format);
+        }
+        retVal = d3Format(format);
+        retVal.parse = function (_) {
+            return _;
+        };
+        return retVal;
+    }
+
+    children(): Field[];
+    children(_: Array<string | INestedColumn | Field>, asDefault?: boolean): this;
+    children(_?: Array<string | INestedColumn | Field>, asDefault?: boolean): Field[] | this {
+        if (_ === void 0) return this._children;
+        this.type("nested");
+        const fieldsArr = this._children;
+        this._children = _.map((field: string | INestedColumn | Field, idx): Field => {
+            if (field instanceof Field) {
+                fieldsArr[idx] = field;
+                return field;
+            } else if (typeof field === "string") {
+                if (asDefault) {
+                    return (fieldsArr[idx] || new Field()).label_default(field);
+                } else {
+                    return (fieldsArr[idx] || new Field()).label(field);
+                }
+            } else {
+                if (asDefault) {
+                    return (fieldsArr[idx] || new Field())
+                        .label_default(field.label)
+                        .children(field.columns) as Field
+                        ;
+                } else {
+                    return (fieldsArr[idx] || new Field())
+                        .label(field.label)
+                        .children(field.columns) as Field
+                        ;
+                }
+            }
+        }, this);
+        return this;
+    }
+
+}
+Field.prototype._class += " common_Database.Field";
+
+export interface Field {
+    label(): string;
+    label(_: string): this;
+    label_default(): string;
+    label_default(_: string): this;
+    type(): FieldType;
+    type(_: FieldType): this;
+    mask(): string;
+    mask(_: string): this;
+    format(): string;
+    format(_: string): this;
+}
+
+Field.prototype.publish("label", "", "string", "Label", null, { optional: true });
+Field.prototype.publish("type", "", "set", "Type", ["", "string", "number", "boolean", "date", "time", "hidden", "nested"], { optional: true });
+Field.prototype.publish("mask", "", "string", "Time Mask", null, { disable: (w: any) => w.type() !== "time", optional: true });
+Field.prototype.publish("format", "", "string", "Format", null, { optional: true });
+
+//  Grid  ---
+export class Grid extends PropertyExt {
+    _dataChecksum: boolean;
+    _dataVersion: number;
+
+    private _data = [];
+    private _dataChecksums = [];
+
+    constructor(dataChecksum?) {
+        super();
+        dataChecksum = dataChecksum || false;
+        this._dataChecksum = dataChecksum;
+        this._dataVersion = 0;
+        this.clear();
+    }
+
+    clear() {
+        this.fields([]);
+        this._data = [];
+        this._dataChecksums = [];
+        ++this._dataVersion;
+        return this;
+    }
+
+    //  Backward compatability  ---
+    resetColumns() {
+        const fields = this.fields() as Field[];
+        this.legacyColumns([]);
+        this.legacyColumns(fields.map(function (field) {
+            return field.label();
+        }));
+    }
+
+    legacyColumns(_?, asDefault?): any | Grid {
+        if (!arguments.length) return this.row(0);
+        this.row(0, _, asDefault);
+        return this;
+    }
+
+    legacyData(_?, _clone?) {
+        return Grid.prototype.data.apply(this, arguments);
+    }
+
+    //  Meta  ---
+    schema() {
+    }
+
+    field(idx) {
+        return this.fields()[idx];
+    }
+
+    fieldByLabel(_, ignoreCase?) {
+        return this.fields().filter(function (field: Field, idx) {
+            field.idx = idx;
+            return ignoreCase ? field.label().toLowerCase() === _.toLowerCase() : field.label() === _;
+        })[0];
+    }
+
+    data(_?, clone?): any | Grid {
+        if (!arguments.length) return this._data;
+        this._data = clone ? _.map(function (d) { return d.map(function (d2) { return d2; }); }) : _;
+        this._dataCalcChecksum();
+        return this;
+    }
+
+    parsedData() {
+        const context = this;
+        return this._data.map(function (row) {
+            return row.map(function (cell, idx) {
+                return context.fields()[idx].parse(cell);
+            });
+        });
+    }
+
+    formattedData() {
+        return this._data.map(row => {
+            return this.fields().map((field, idx) => {
+                return field.transform(row[idx]);
+            });
+        });
+    }
+
+    fieldsChecksum() {
+        return Utility.checksum(this.fields().map(function (field) { return field.checksum(); }));
+    }
+
+    dataChecksum() {
+        return Utility.checksum(this._dataChecksum ? this._dataChecksums : this._dataVersion);
+    }
+
+    checksum() {
+        return Utility.checksum([this.dataChecksum(), this.fieldsChecksum()]);
+    }
+
+    //  Row Access  ---
+    private _dataCalcChecksum(idx?) {
+        ++this._dataVersion;
+        if (this._dataChecksum) {
+            if (arguments.length) {
+                this._dataChecksums[idx] = Utility.checksum(this._data[idx]);
+            } else {
+                this._dataChecksums = this._data.map(function (row) { return Utility.checksum(row); });
+            }
+        }
+        return this;
+    }
+
+    row(row?, _?, asDefault?): any | Grid {
+        if (arguments.length < 2) return row === 0 ? this.fields().map(function (d) { return d.label(); }) : this._data[row - 1];
+        if (row === 0) {
+            const fieldsArr = this.fields();
+            this.fields(_.map(function (field: string | INestedColumn, idx) {
+                if (typeof field === "string") {
+                    if (asDefault) {
+                        return (fieldsArr[idx] || new Field()).label_default(field);
+                    } else {
+                        return (fieldsArr[idx] || new Field()).label(field);
+                    }
+                } else {
+                    if (asDefault) {
+                        return (fieldsArr[idx] || new Field())
+                            .label_default(field.label)
+                            .children(field.columns)
+                            ;
+                    } else {
+                        return (fieldsArr[idx] || new Field())
+                            .label(field.label)
+                            .children(field.columns)
+                            ;
+                    }
+                }
+            }, this));
+        } else {
+            this._data[row - 1] = _;
+            this._dataCalcChecksum(row - 1);
+        }
+        return this;
+    }
+
+    rows(_?): any | Grid {
+        if (!arguments.length) return [this.row(0)].concat(this._data);
+        this.row(0, _[0]);
+        this._data = _.filter(function (_row, idx) { return idx > 0; });
+        this._dataCalcChecksum();
+        return this;
+    }
+
+    //  Column Access  ---
+    column(col, _?): any | Grid {
+        if (arguments.length < 2) return [this.fields()[col].label()].concat(this._data.map(function (row, _idx) { return row[col]; }));
+        _.forEach(function (d, idx) {
+            if (idx === 0) {
+                this.fields()[col] = new Field().label(_[0]);
+            } else {
+                this._data[idx - 1][col] = d;
+                this._dataCalcChecksum(idx - 1);
+            }
+        }, this);
+        return this;
+    }
+
+    columnData(col, _): any | Grid {
+        if (arguments.length < 2) return this._data.map(function (row, _idx) { return row[col]; });
+        _.forEach(function (d, idx) {
+            this._data[idx][col] = d;
+            this._dataCalcChecksum(idx);
+        }, this);
+        return this;
+    }
+
+    columns(_?): any | Grid {
+        if (!arguments.length) return this.fields().map(function (_col, idx) {
+            return this.column(idx);
+        }, this);
+        _.forEach(function (_col, idx) {
+            this.column(idx, _[idx]);
+        }, this);
+        return this;
+    }
+
+    //  Cell Access  ---
+    cell(row, col, _) {
+        if (arguments.length < 3) return this.row(row)[col];
+        if (row === 0) {
+            this.fields()[col] = new Field().label(_);
+        } else {
+            this._data[row][col] = _;
+            this._dataCalcChecksum(row);
+        }
+        return this;
+    }
+
+    //  Grid Access  ---
+    grid(_?) {
+        return Grid.prototype.rows.apply(this, arguments);
+    }
+
+    //  Hipie Helpers  ---
+
+    hipieMappings(columns, missingDataString) {
+        missingDataString = missingDataString || "";
+        if (!this.fields().length || !this._data.length) {
+            return [];
+        }
+        const mappedColumns = [];
+        let hasRollup = false;
+        columns.forEach(function (mapping, idx) {
+            const mappedColumn = {
+                groupby: false,
+                func: "",
+                params: []
+            };
+            if (mapping.hasFunction()) {
+                mappedColumn.func = mapping.function();
+                if (mappedColumn.func === "SCALE") {
+                    mappedColumn.groupby = true;
+                } else {
+                    hasRollup = true;
+                }
+
+                mapping.params().forEach(function (param) {
+                    const field = this.fieldByLabel(param, true);
+                    mappedColumn.params.push(field ? field.idx : -1);
+                }, this);
+            } else {
+                mappedColumn.groupby = true;
+                const field = this.fieldByLabel(mapping.id(), true);
+                mappedColumn.params.push(field ? field.idx : -1);
+            }
+            mappedColumns.push(mappedColumn);
+        }, this);
+
+        if (hasRollup) {
+            const retVal = [];
+            this.rollup(mappedColumns.filter(function (mappedColumn) {
+                return mappedColumn.groupby === true;
+            }).map(function (d) {
+                return d.params[0];
+            }), function (leaves) {
+                const row = mappedColumns.map(function (mappedColumn) {
+                    const param1 = mappedColumn.params[0];
+                    const param2 = mappedColumn.params[1];
+                    switch (mappedColumn.func) {
+                        case "SUM":
+                            return d3Sum(leaves, function (d) { return d[param1]; });
+                        case "AVE":
+                            return d3Mean(leaves, function (d) { return d[param1] / d[param2]; });
+                        case "MIN":
+                            return d3Min(leaves, function (d) { return d[param1]; });
+                        case "MAX":
+                            return d3Max(leaves, function (d) { return d[param1]; });
+                        case "SCALE":
+                            console.warn("Unexpected function:  " + mappedColumn.func);
+                            //  All leaves should have the same values, use mean just in case they don't?
+                            return d3Mean(leaves, function (d) { return d[param1] / +param2; });
+                    }
+                    //  All leaves should have the same value.
+                    return leaves[0][param1];
+                });
+                retVal.push(row);
+                return row;
+            });
+            return retVal;
+        } else {
+            return this._data.map(function (row) {
+                return mappedColumns.map(function (mappedColumn) {
+                    const param1 = mappedColumn.params[0];
+                    const param2 = mappedColumn.params[1];
+                    switch (mappedColumn.func) {
+                        case "SCALE":
+                            return row[param1] / +param2;
+                        case "SUM":
+                        case "AVE":
+                        case "MIN":
+                        case "MAX":
+                            console.warn("Unexpected function:  " + mappedColumn.func);
+                    }
+                    return row[param1];
+                });
+            });
+        }
+    }
+
+    legacyView() {
+        return new LegacyView(this);
+    }
+
+    nestView(columnIndicies) {
+        return new RollupView(this, columnIndicies);
+    }
+
+    rollupView(columnIndicies, rollupFunc?) {
+        return new RollupView(this, columnIndicies, rollupFunc);
+    }
+
+    aggregateView(columnIndicies, aggrType, aggrColumn, aggrDeltaColumn = "") {
+        const context = this;
+        return new RollupView(this, columnIndicies, function (values) {
+            switch (aggrType) {
+                case null:
+                case undefined:
+                case "":
+                    values.aggregate = values.length;
+                    return values;
+                default:
+                    const columns = context.legacyColumns();
+                    const colIdx = columns.indexOf(aggrColumn);
+                    const deltaIdx = columns.indexOf(aggrDeltaColumn);
+                    values.aggregate = d3Aggr[aggrType](values, function (value) {
+                        return (+value[colIdx] - (deltaIdx >= 0 ? +value[deltaIdx] : 0)) / (deltaIdx >= 0 ? +value[deltaIdx] : 1);
+                    });
+                    return values;
+            }
+        });
+    }
+
+    //  Nesting  ---
+    private _nest(columnIndicies, _rollup?) {
+        if (!(columnIndicies instanceof Array)) {
+            columnIndicies = [columnIndicies];
+        }
+        const nest = d3Nest();
+        columnIndicies.forEach(function (idx) {
+            nest.key(function (d) {
+                return d[idx];
+            });
+        });
+        return nest;
+    }
+
+    nest(columnIndicies) {
+        return this._nest(columnIndicies)
+            .entries(this._data)
+            ;
+    }
+
+    rollup(columnIndicies, rollup) {
+        return this._nest(columnIndicies)
+            .rollup(rollup)
+            .entries(this._data)
+            ;
+    }
+
+    //  Util  ---
+    length() {
+        return this._data.length + 1;
+    }
+
+    width() {
+        return this.fields().length;
+    }
+
+    pivot() {
+        this.resetColumns();
+        this.rows(this.columns());
+        return this;
+    }
+
+    clone(deep) {
+        return new Grid()
+            .fields(this.fields(), deep)
+            .data(this.data(), deep)
+            ;
+    }
+
+    filter(filter) {
+        const filterIdx = {};
+        this.row(0).forEach(function (col, idx) {
+            filterIdx[col] = idx;
+        });
+        return new Grid()
+            .fields(this.fields(), true)
+            .data(this.data().filter(function (row) {
+                for (const key in filter) {
+                    if (filter[key] !== row[filterIdx[key]]) {
+                        return false;
+                    }
+                }
+                return true;
+            }))
+            ;
+    }
+
+    analyse(columns) {
+        if (!(columns instanceof Array)) {
+            columns = [columns];
+        }
+        const retVal = [];
+        columns.forEach(function (col) {
+            const rollup = this.rollup(col, function (leaves) {
+                return leaves.length;
+            });
+            retVal.push(rollup);
+            const keys = rollup.map(function (d) { return d.key; });
+            this.fields()[col].isBoolean = typeTest(keys, isBoolean);
+            this.fields()[col].isNumber = typeTest(keys, isNumber);
+            this.fields()[col].isString = !this.fields()[col].isNumber && typeTest(keys, isString);
+            this.fields()[col].isUSState = this.fields()[col].isString && typeTest(keys, isUSState);
+            this.fields()[col].isDateTime = this.fields()[col].isString && typeTest(keys, isDateTime);
+            this.fields()[col].isDateTimeFormat = lastFoundFormat;
+            this.fields()[col].isDate = !this.fields()[col].isDateTime && typeTest(keys, isDate);
+            this.fields()[col].isDateFormat = lastFoundFormat;
+            this.fields()[col].isTime = this.fields()[col].isString && !this.fields()[col].isDateTime && !this.fields()[col].isDate && typeTest(keys, isTime);
+            this.fields()[col].isTimeFormat = lastFoundFormat;
+        }, this);
+        return retVal;
+    }
+
+    //  Import/Export  ---
+    jsonObj(_?): any | Grid {
+        if (!arguments.length) return this._data.map(function (row) {
+            const retVal = {};
+            this.row(0).forEach(function (col, idx) {
+                retVal[col] = row[idx];
+            });
+            return retVal;
+        }, this);
+        this.clear();
+        this.data(_.map(function (row) {
+            const retVal = [];
+            for (const key in row) {
+                let colIdx = this.row(0).indexOf(key);
+                if (colIdx < 0) {
+                    colIdx = this.fields().length;
+                    this.fields().push(new Field().label(key));
+                }
+                retVal[colIdx] = row[key];
+            }
+            return retVal;
+        }, this));
+        return this;
+    }
+
+    json(_: string | object): this;
+    json(): string;
+    json(_?: string | object): string | this {
+        if (!arguments.length) return JSON.stringify(this.jsonObj(), null, "  ");
+        if (typeof (_) === "string") {
+            _ = JSON.parse(_);
+        }
+        this.jsonObj(_);
+        return this;
+    }
+
+    csv(_: string): this;
+    csv(): string;
+    csv(_?: string): string | this {
+        if (!arguments.length) {
+            const temp = document.createElement("div");
+            return d3CsvFormatRows(this.grid().map(row => {
+                return row.map(cell => {
+                    return Utility.removeHTMLFromString(cell, temp);
+                });
+            }));
+        }
+        this.jsonObj(d3CsvParse(_));
+        return this;
+    }
+
+    tsv(_: string): this;
+    tsv(): string;
+    tsv(_?: string): string | this {
+        if (!arguments.length) return d3TsvFormatRows(this.grid());
+        this.jsonObj(d3TsvParse(_));
+        return this;
+    }
+}
+Grid.prototype._class += " common_Database.Grid";
+export interface Grid {
+    fields(): Field[];
+    fields(_: Field[], clone?: boolean): this;
+}
+
+Grid.prototype.publish("fields", [], "propertyArray", "Fields");
+const fieldsOrig = Grid.prototype.fields;
+Grid.prototype.fields = function (_?, clone?) {
+    if (!arguments.length) return fieldsOrig.apply(this, arguments);
+    return fieldsOrig.call(this, clone ? _.map(function (d) { return d.clone(); }) : _);
+};
+
+//  Views  ---
+export class LegacyView {
+    _grid;
+    _parsedData;
+    _parsedDataChecksum;
+    _formattedData;
+    _formattedDataChecksum;
+
+    constructor(grid) {
+        this._grid = grid;
+    }
+
+    checksum() {
+        const value = this._grid.on.apply(this._grid, arguments);
+        return value === this._grid ? this : value;
+    }
+
+    fields() {
+        const value = this._grid.on.apply(this._grid, arguments);
+        return value === this._grid ? this : value;
+    }
+
+    grid() {
+        return this._grid;
+    }
+    columns(_?) {
+        if (!arguments.length) return this._grid.legacyColumns();
+        this._grid.legacyColumns(_);
+        return this;
+    }
+    rawData(_?) {
+        if (!arguments.length) return this._grid.legacyData();
+        this._grid.legacyData(_);
+        return this;
+    }
+    formattedData() {
+        if (this._formattedDataChecksum !== this._grid.checksum()) {
+            this._formattedDataChecksum = this._grid.checksum();
+            this._formattedData = this._grid.formattedData();
+        }
+        return this._formattedData;
+    }
+    parsedData() {
+        if (this._parsedDataChecksum !== this._grid.checksum()) {
+            this._parsedDataChecksum = this._grid.checksum();
+            this._parsedData = this._grid.parsedData();
+        }
+        return this._parsedData;
+    }
+    protected _whichData(opts?) {
+        if (opts) {
+            if (opts.parsed) {
+                return this.formattedData();
+            } else if (opts.formatted) {
+                return this.formattedData();
+            }
+        }
+        return this.rawData();
+    }
+    data(_) {
+        return LegacyView.prototype.rawData.apply(this, arguments);
+    }
+}
+
+export class RollupView extends LegacyView {
+    _columnIndicies;
+    _rollup;
+    _nestChecksum;
+    _nest;
+
+    constructor(grid, columns, rollup?) {
+        super(grid);
+        if (!(columns instanceof Array)) {
+            columns = [columns];
+        }
+        this._columnIndicies = columns.filter(function (column) { return column; }).map(function (column) {
+            switch (typeof column) {
+                case "string":
+                    return this._grid.fieldByLabel(column).idx;
+            }
+            return column;
+        }, this);
+
+        rollup = rollup || function (d) { return d; };
+        this._rollup = rollup;
+    }
+
+    nest() {
+        if (this._nestChecksum !== this._grid.checksum()) {
+            this._nestChecksum = this._grid.checksum();
+
+            const nest = d3Nest();
+            this._columnIndicies.forEach(function (idx) {
+                nest.key(function (d) {
+                    return d[idx];
+                });
+            });
+            this._nest = nest
+                .rollup(this._rollup)
+                ;
+        }
+        return this._nest;
+    }
+    entries(opts?) {
+        return this.nest().entries(this._whichData(opts));
+    }
+    map(opts) {
+        return this.nest().map(this._whichData(opts));
+    }
+    d3Map(opts) {
+        return this.nest().map(this._whichData(opts), d3Map);
+    }
+    _walkData(entries, prevRow = []) {
+        let retVal = [];
+        entries.forEach(function (entry) {
+            if (entry instanceof Array) {
+                retVal.push(prevRow.concat([entry]));
+            } else if (entry.values instanceof Array) {
+                retVal = retVal.concat(this._walkData(entry.values, prevRow.concat([entry.key])));
+            } else if (entry.value instanceof Array) {
+                retVal = retVal.concat(this._walkData(entry.value, prevRow.concat([entry.key])));
+            }
+        }, this);
+        return retVal;
+    }
+    data(opts) {
+        return this._walkData(this.entries(opts));
+    }
+}
+
+//  --- --- ---
+function typeTest(cells, test) {
+    if (!(cells instanceof Array)) {
+        cells = [cells];
+    }
+    return cells.filter(function (d) { return d !== ""; }).every(test);
+}
+function isBoolean(cell) {
+    return typeof cell === "boolean";
+}
+function isNumber(cell) {
+    return typeof cell === "number" || !isNaN(cell);
+}
+function isString(cell) {
+    return typeof cell === "string";
+}
+const dateTimeFormats = [
+];
+const dateFormats = [
+    "%Y-%m-%d",
+    "%Y%m%d"
+];
+const timeFormats = [
+    "%H:%M:%S.%LZ",
+    "%H:%M:%SZ",
+    "%H:%M:%S"
+];
+dateFormats.forEach(function (d) {
+    timeFormats.forEach(function (t) {
+        dateTimeFormats.push(d + "T" + t);
+    });
+});
+function formatPicker(formats, cell) {
+    for (let i = 0; i < formats.length; ++i) {
+        const date = d3TimeParse(formats[i])(cell);
+        if (date) {
+            lastFoundFormat = formats[i];
+            return formats[i];
+        }
+    }
+    return null;
+}
+function isDateTime(cell) {
+    return formatPicker(dateTimeFormats, cell);
+}
+function isDate(cell) {
+    return formatPicker(dateFormats, cell);
+}
+function isTime(cell) {
+    return formatPicker(timeFormats, cell);
+}
+function isUSState(cell) {
+    return ["AL", "AK", "AZ", "AR", "CA", "CO", "CT", "DE", "FL", "GA", "HI", "ID", "IL", "IN", "IA", "KS", "KY", "LA", "ME", "MD", "MA", "MI", "MN", "MS", "MO", "MT", "NE", "NV", "NH", "NJ", "NM", "NY", "NC", "ND", "OH", "OK", "OR", "PA", "RI", "SC", "SD", "TN", "TX", "UT", "VT", "VA", "WA", "WV", "WI", "WY", "AS", "DC", "FM", "GU", "MH", "MP", "PW", "PR", "VI"].indexOf(String(cell).toUpperCase()) >= 0;
+}