@hpcc-js/dgrid 3.5.7 → 3.5.9

package/src/DatasourceStore.ts

@@ -1,126 +1,126 @@
-import type { DDL2 } from "@hpcc-js/ddl-shim";
-import { Deferred, QueryResults } from "./dgrid-shim.ts";
-import { ColumnType, RowFormatter } from "./RowFormatter.ts";
-
-export interface IDatasource {
-    id: () => string;
-    hash: () => string;
-    label: () => string;
-
-    outFields: () => DDL2.IField[];
-    total: () => number;
-    fetch: (from: number, count: number) => Promise<ReadonlyArray<object>>;
-}
-
-export class DatasourceCache implements IDatasource {
-    protected _datasource: IDatasource;
-    _prevHash: string;
-    _fetchCache: { [key: string]: Promise<ReadonlyArray<object>> } = {};
-
-    constructor(datasource: IDatasource) {
-        this._datasource = datasource;
-    }
-
-    validateCache() {
-        const hash = this.hash();
-        if (this._prevHash !== hash) {
-            this._prevHash = hash;
-            this._fetchCache = {};
-        }
-    }
-
-    id() { return this._datasource.id(); }
-    hash() { return this._datasource.hash(); }
-    label() { return this._datasource.label(); }
-
-    outFields() { return this._datasource.outFields(); }
-    total() { return this._datasource.total(); }
-    fetch(from: number, count: number): Promise<ReadonlyArray<object>> {
-        this.validateCache();
-        const cacheID = `${from}->${count}`;
-        let retVal = this._fetchCache[cacheID];
-        if (!retVal) {
-            retVal = this._datasource.fetch(from, count);
-            this._fetchCache[cacheID] = retVal;
-        }
-        return retVal;
-    }
-}
-
-export class DatasourceStore {
-    _datasource: DatasourceCache;
-    _columnsIdx: { [key: string]: number } = {};
-    _columns;
-
-    private rowFormatter: RowFormatter;
-
-    constructor(datasource: IDatasource, renderHtml: boolean) {
-        this._datasource = new DatasourceCache(datasource);
-
-        this._columnsIdx = {};
-        this._columns = this.db2Columns(this._datasource.outFields()).map((column, idx) => {
-            this._columnsIdx[column.field] = idx;
-            return column;
-        });
-        this.rowFormatter = new RowFormatter(this._columns, renderHtml);
-    }
-
-    columns() {
-        return this._columns;
-    }
-
-    db2Columns(fields: DDL2.IField[], prefix = ""): ColumnType[] {
-        if (!fields) return [];
-        return fields.map((field, idx) => {
-            const column: ColumnType = {
-                field: prefix + field.id,
-                leafID: field.id,
-                label: field.id,
-                idx,
-                className: "resultGridCell",
-                sortable: true,
-                isSet: false
-            };
-            if (field.type === "dataset") {
-                column.children = this.db2Columns(field.children, prefix + field.id + "_");
-            } else {
-                column.formatter = (cell, row) => {
-                    switch (typeof cell) {
-                        case "string":
-                            return cell.replace(/\t/g, "&nbsp;&nbsp;&nbsp;&nbsp;");
-                    }
-                    return cell;
-                };
-            }
-            return column;
-        });
-    }
-
-    getIdentity(row) {
-        return row.__hpcc_id;
-    }
-
-    _request(start, end): Promise<{ totalLength: number, data: any[] }> {
-        if (!this._datasource) return Promise.resolve({ totalLength: 0, data: [] });
-        const retVal = this._datasource.fetch(start, end - start).then(response => {
-            return {
-                totalLength: this._datasource.total(),
-                data: response.map((row, idx) => {
-                    const formattedRow: any = this.rowFormatter.format(row);
-                    formattedRow.__hpcc_id = start + idx;
-                    formattedRow.__origRow = row;
-                    return formattedRow;
-                })
-            };
-        });
-        return retVal;
-    }
-
-    fetchRange(options): Promise<any[]> {
-        const retVal = new Deferred();
-        this._request(options.start, options.end).then(response => retVal.resolve(response));
-        return new QueryResults(retVal.then(response => response.data), {
-            totalLength: retVal.then(response => response.totalLength)
-        });
-    }
-}
+import type { DDL2 } from "@hpcc-js/ddl-shim";
+import { Deferred, QueryResults } from "./dgrid-shim.ts";
+import { ColumnType, RowFormatter } from "./RowFormatter.ts";
+
+export interface IDatasource {
+    id: () => string;
+    hash: () => string;
+    label: () => string;
+
+    outFields: () => DDL2.IField[];
+    total: () => number;
+    fetch: (from: number, count: number) => Promise<ReadonlyArray<object>>;
+}
+
+export class DatasourceCache implements IDatasource {
+    protected _datasource: IDatasource;
+    _prevHash: string;
+    _fetchCache: { [key: string]: Promise<ReadonlyArray<object>> } = {};
+
+    constructor(datasource: IDatasource) {
+        this._datasource = datasource;
+    }
+
+    validateCache() {
+        const hash = this.hash();
+        if (this._prevHash !== hash) {
+            this._prevHash = hash;
+            this._fetchCache = {};
+        }
+    }
+
+    id() { return this._datasource.id(); }
+    hash() { return this._datasource.hash(); }
+    label() { return this._datasource.label(); }
+
+    outFields() { return this._datasource.outFields(); }
+    total() { return this._datasource.total(); }
+    fetch(from: number, count: number): Promise<ReadonlyArray<object>> {
+        this.validateCache();
+        const cacheID = `${from}->${count}`;
+        let retVal = this._fetchCache[cacheID];
+        if (!retVal) {
+            retVal = this._datasource.fetch(from, count);
+            this._fetchCache[cacheID] = retVal;
+        }
+        return retVal;
+    }
+}
+
+export class DatasourceStore {
+    _datasource: DatasourceCache;
+    _columnsIdx: { [key: string]: number } = {};
+    _columns;
+
+    private rowFormatter: RowFormatter;
+
+    constructor(datasource: IDatasource, renderHtml: boolean) {
+        this._datasource = new DatasourceCache(datasource);
+
+        this._columnsIdx = {};
+        this._columns = this.db2Columns(this._datasource.outFields()).map((column, idx) => {
+            this._columnsIdx[column.field] = idx;
+            return column;
+        });
+        this.rowFormatter = new RowFormatter(this._columns, renderHtml);
+    }
+
+    columns() {
+        return this._columns;
+    }
+
+    db2Columns(fields: DDL2.IField[], prefix = ""): ColumnType[] {
+        if (!fields) return [];
+        return fields.map((field, idx) => {
+            const column: ColumnType = {
+                field: prefix + field.id,
+                leafID: field.id,
+                label: field.id,
+                idx,
+                className: "resultGridCell",
+                sortable: true,
+                isSet: false
+            };
+            if (field.type === "dataset") {
+                column.children = this.db2Columns(field.children, prefix + field.id + "_");
+            } else {
+                column.formatter = (cell, row) => {
+                    switch (typeof cell) {
+                        case "string":
+                            return cell.replace(/\t/g, "&nbsp;&nbsp;&nbsp;&nbsp;");
+                    }
+                    return cell;
+                };
+            }
+            return column;
+        });
+    }
+
+    getIdentity(row) {
+        return row.__hpcc_id;
+    }
+
+    _request(start, end): Promise<{ totalLength: number, data: any[] }> {
+        if (!this._datasource) return Promise.resolve({ totalLength: 0, data: [] });
+        const retVal = this._datasource.fetch(start, end - start).then(response => {
+            return {
+                totalLength: this._datasource.total(),
+                data: response.map((row, idx) => {
+                    const formattedRow: any = this.rowFormatter.format(row);
+                    formattedRow.__hpcc_id = start + idx;
+                    formattedRow.__origRow = row;
+                    return formattedRow;
+                })
+            };
+        });
+        return retVal;
+    }
+
+    fetchRange(options): Promise<any[]> {
+        const retVal = new Deferred();
+        this._request(options.start, options.end).then(response => retVal.resolve(response));
+        return new QueryResults(retVal.then(response => response.data), {
+            totalLength: retVal.then(response => response.totalLength)
+        });
+    }
+}

package/src/DatasourceTable.ts

@@ -1,62 +1,62 @@
-import { Widget } from "@hpcc-js/common";
-import { Memory } from "./dgrid-shim.ts";
-import { Common } from "./Common.ts";
-import { DatasourceStore, IDatasource } from "./DatasourceStore.ts";
-
-export class DatasourceTable extends Common {
-    _prevDatasource?: IDatasource;
-
-    constructor() {
-        super();
-    }
-
-    invalidate(): this {
-        delete this._prevDatasource;
-        return this;
-    }
-
-    enter(domNode, element) {
-        super.enter(domNode, element);
-    }
-
-    update(domNode, element) {
-        super.update(domNode, element);
-    }
-    render(callback?: (w: Widget) => void): this {
-        return super.render(w => {
-            if (this._prevDatasource !== this.datasource()) {
-                this._dgrid.set("collection", new Memory());
-                this._dgrid.set("columns", []);
-                this._prevDatasource = this.datasource();
-                if (this._prevDatasource) {
-                    const store = new DatasourceStore(this._prevDatasource, this.renderHtml());
-                    this._dgrid.set("columns", store.columns());
-                    this._dgrid.set("collection", store);
-                    if (callback) {
-                        callback(w);
-                    }
-                } else {
-                    if (callback) {
-                        callback(w);
-                    }
-                }
-            } else {
-                if (callback) {
-                    callback(w);
-                }
-            }
-        });
-    }
-
-    click(row, col, sel) {
-    }
-}
-DatasourceTable.prototype._class += " dgrid_DatasourceTable";
-
-export interface DatasourceTable {
-    datasource(): IDatasource;
-    datasource(_: IDatasource): this;
-}
-
-DatasourceTable.prototype.publish("datasource", null, "object", "Datasource");
-
+import { Widget } from "@hpcc-js/common";
+import { Memory } from "./dgrid-shim.ts";
+import { Common } from "./Common.ts";
+import { DatasourceStore, IDatasource } from "./DatasourceStore.ts";
+
+export class DatasourceTable extends Common {
+    _prevDatasource?: IDatasource;
+
+    constructor() {
+        super();
+    }
+
+    invalidate(): this {
+        delete this._prevDatasource;
+        return this;
+    }
+
+    enter(domNode, element) {
+        super.enter(domNode, element);
+    }
+
+    update(domNode, element) {
+        super.update(domNode, element);
+    }
+    render(callback?: (w: Widget) => void): this {
+        return super.render(w => {
+            if (this._prevDatasource !== this.datasource()) {
+                this._dgrid.set("collection", new Memory());
+                this._dgrid.set("columns", []);
+                this._prevDatasource = this.datasource();
+                if (this._prevDatasource) {
+                    const store = new DatasourceStore(this._prevDatasource, this.renderHtml());
+                    this._dgrid.set("columns", store.columns());
+                    this._dgrid.set("collection", store);
+                    if (callback) {
+                        callback(w);
+                    }
+                } else {
+                    if (callback) {
+                        callback(w);
+                    }
+                }
+            } else {
+                if (callback) {
+                    callback(w);
+                }
+            }
+        });
+    }
+
+    click(row, col, sel) {
+    }
+}
+DatasourceTable.prototype._class += " dgrid_DatasourceTable";
+
+export interface DatasourceTable {
+    datasource(): IDatasource;
+    datasource(_: IDatasource): this;
+}
+
+DatasourceTable.prototype.publish("datasource", null, "object", "Datasource");
+

package/src/RowFormatter.ts

@@ -1,146 +1,146 @@
-function entitiesEncode(str) {
-    return String(str).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-}
-
-function safeEncode(item) {
-    switch (Object.prototype.toString.call(item)) {
-        case "[object Undefined]":
-        case "[object Boolean]":
-        case "[object Number]":
-            return item;
-        case "[object String]":
-            return entitiesEncode(item);
-        default:
-            console.warn("Unknown cell type:  " + Object.prototype.toString.call(item));
-    }
-    return item;
-}
-
-function isArray(obj: any): obj is any[] {
-    return obj instanceof Array;
-}
-
-const LINE_SPLITTER = "<br><hr class='dgrid-fakeline'>";
-const LINE_SPLITTER2 = "<br><hr class='dgrid-fakeline' style='visibility: hidden'>";
-
-export interface ColumnType {
-    field: string;
-    leafID: string;
-    label: string;
-    idx: number;
-    className: string;
-    sortable: boolean;
-    isSet: boolean;
-    width?: number;
-    formatter?: CellFormatter;
-    renderCell?: CellRenderer;
-    children?: ColumnType[];
-}
-export interface RowType {
-    __hpcc_id: number;
-    __origRow: any[];
-    [colIdx: number]: any;
-}
-export type CellFormatter = (this: ColumnType, cell: any, row: RowType) => string;
-export type CellRenderer = (this: ColumnType, row: RowType, cell: any, cellElement: HTMLElement) => HTMLElement | void;
-
-export class RowFormatter {
-    private _columns: ColumnType[];
-    private _flattenedColumns = [];
-    private _columnIdx = {};
-    private _formattedRow = {};
-
-    constructor(columns: ColumnType[], protected _renderHtml) {
-        this._columns = columns;
-        this.flattenColumns(columns);
-    }
-
-    flattenColumns(columns: ColumnType[]) {
-        for (const column of columns) {
-            this.flattenColumn(column);
-        }
-    }
-
-    flattenColumn(column: ColumnType) {
-        if (column.children) {
-            for (const childColumn of column.children) this.flattenColumn(childColumn);
-        } else {
-            this._columnIdx[column.field] = this._flattenedColumns.length;
-            this._flattenedColumns.push(column.field);
-        }
-    }
-
-    format(row) {
-        this._formattedRow = {};
-        this.formatRow(this._columns, row);
-        return this.row();
-    }
-
-    calcDepth(columns: ColumnType[], row) {
-        let maxChildDepth = 1;
-        for (const column of columns) {
-            if (column.children && row[column.leafID]) {
-                let childDepth = 0;
-                let childRows = [];
-                if (isArray(row[column.leafID])) {
-                    childRows = row[column.leafID];
-                } else if (isArray(row[column.leafID].Row)) {
-                    childRows = row[column.leafID].Row;
-                }
-                for (const childRow of childRows) {
-                    childDepth += this.calcDepth(column.children, childRow);
-                }
-                maxChildDepth = Math.max(maxChildDepth, childDepth);
-            }
-        }
-        return maxChildDepth;
-    }
-
-    formatCell(column: ColumnType, cell, maxChildDepth) {
-        if (column.children) {
-            let childDepth = 0;
-            if (!isArray(cell)) {
-                if (isArray(cell.Row)) {
-                    cell = cell.Row;
-                } else {
-                    cell = [cell];
-                }
-            }
-            for (const row of cell) {
-                childDepth = Math.max(childDepth, this.formatRow(column.children, row));
-            }
-        } else {
-            if (column.isSet) {
-                cell = JSON.stringify(cell.Item);
-            }
-            if (this._formattedRow[column.field] === undefined) {
-                this._formattedRow[column.field] = "" + (cell === undefined ? "" : (this._renderHtml ? cell : safeEncode(cell)));
-            } else {
-                this._formattedRow[column.field] += LINE_SPLITTER;
-                this._formattedRow[column.field] += "" + (cell === undefined ? "" : (this._renderHtml ? cell : safeEncode(cell)));
-            }
-            if (maxChildDepth > 1) {
-                const paddingArr = [];
-                paddingArr.length = maxChildDepth;
-                const padding = paddingArr.join(LINE_SPLITTER2);
-                this._formattedRow[column.field] += padding;
-            }
-        }
-    }
-
-    formatRow(columns: ColumnType[], row: { [key: string]: any } = [], rowIdx: number = 0) {
-        const maxChildDepth = this.calcDepth(columns, row);
-        for (const column of columns) {
-            this.formatCell(column, row[column.leafID], maxChildDepth);
-        }
-        return maxChildDepth;
-    }
-
-    row() {
-        const retVal = {};
-        for (const column of this._flattenedColumns) {
-            retVal[column] = this._formattedRow[column];
-        }
-        return retVal;
-    }
-}
+function entitiesEncode(str) {
+    return String(str).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+function safeEncode(item) {
+    switch (Object.prototype.toString.call(item)) {
+        case "[object Undefined]":
+        case "[object Boolean]":
+        case "[object Number]":
+            return item;
+        case "[object String]":
+            return entitiesEncode(item);
+        default:
+            console.warn("Unknown cell type:  " + Object.prototype.toString.call(item));
+    }
+    return item;
+}
+
+function isArray(obj: any): obj is any[] {
+    return obj instanceof Array;
+}
+
+const LINE_SPLITTER = "<br><hr class='dgrid-fakeline'>";
+const LINE_SPLITTER2 = "<br><hr class='dgrid-fakeline' style='visibility: hidden'>";
+
+export interface ColumnType {
+    field: string;
+    leafID: string;
+    label: string;
+    idx: number;
+    className: string;
+    sortable: boolean;
+    isSet: boolean;
+    width?: number;
+    formatter?: CellFormatter;
+    renderCell?: CellRenderer;
+    children?: ColumnType[];
+}
+export interface RowType {
+    __hpcc_id: number;
+    __origRow: any[];
+    [colIdx: number]: any;
+}
+export type CellFormatter = (this: ColumnType, cell: any, row: RowType) => string;
+export type CellRenderer = (this: ColumnType, row: RowType, cell: any, cellElement: HTMLElement) => HTMLElement | void;
+
+export class RowFormatter {
+    private _columns: ColumnType[];
+    private _flattenedColumns = [];
+    private _columnIdx = {};
+    private _formattedRow = {};
+
+    constructor(columns: ColumnType[], protected _renderHtml) {
+        this._columns = columns;
+        this.flattenColumns(columns);
+    }
+
+    flattenColumns(columns: ColumnType[]) {
+        for (const column of columns) {
+            this.flattenColumn(column);
+        }
+    }
+
+    flattenColumn(column: ColumnType) {
+        if (column.children) {
+            for (const childColumn of column.children) this.flattenColumn(childColumn);
+        } else {
+            this._columnIdx[column.field] = this._flattenedColumns.length;
+            this._flattenedColumns.push(column.field);
+        }
+    }
+
+    format(row) {
+        this._formattedRow = {};
+        this.formatRow(this._columns, row);
+        return this.row();
+    }
+
+    calcDepth(columns: ColumnType[], row) {
+        let maxChildDepth = 1;
+        for (const column of columns) {
+            if (column.children && row[column.leafID]) {
+                let childDepth = 0;
+                let childRows = [];
+                if (isArray(row[column.leafID])) {
+                    childRows = row[column.leafID];
+                } else if (isArray(row[column.leafID].Row)) {
+                    childRows = row[column.leafID].Row;
+                }
+                for (const childRow of childRows) {
+                    childDepth += this.calcDepth(column.children, childRow);
+                }
+                maxChildDepth = Math.max(maxChildDepth, childDepth);
+            }
+        }
+        return maxChildDepth;
+    }
+
+    formatCell(column: ColumnType, cell, maxChildDepth) {
+        if (column.children) {
+            let childDepth = 0;
+            if (!isArray(cell)) {
+                if (isArray(cell.Row)) {
+                    cell = cell.Row;
+                } else {
+                    cell = [cell];
+                }
+            }
+            for (const row of cell) {
+                childDepth = Math.max(childDepth, this.formatRow(column.children, row));
+            }
+        } else {
+            if (column.isSet) {
+                cell = JSON.stringify(cell.Item);
+            }
+            if (this._formattedRow[column.field] === undefined) {
+                this._formattedRow[column.field] = "" + (cell === undefined ? "" : (this._renderHtml ? cell : safeEncode(cell)));
+            } else {
+                this._formattedRow[column.field] += LINE_SPLITTER;
+                this._formattedRow[column.field] += "" + (cell === undefined ? "" : (this._renderHtml ? cell : safeEncode(cell)));
+            }
+            if (maxChildDepth > 1) {
+                const paddingArr = [];
+                paddingArr.length = maxChildDepth;
+                const padding = paddingArr.join(LINE_SPLITTER2);
+                this._formattedRow[column.field] += padding;
+            }
+        }
+    }
+
+    formatRow(columns: ColumnType[], row: { [key: string]: any } = [], rowIdx: number = 0) {
+        const maxChildDepth = this.calcDepth(columns, row);
+        for (const column of columns) {
+            this.formatCell(column, row[column.leafID], maxChildDepth);
+        }
+        return maxChildDepth;
+    }
+
+    row() {
+        const retVal = {};
+        for (const column of this._flattenedColumns) {
+            retVal[column] = this._formattedRow[column];
+        }
+        return retVal;
+    }
+}