mascot-vis 3.0.0 → 3.0.1

package/src-new-ts/data/Table.js

@@ -1,263 +0,0 @@
-import * as d3 from "d3";
-import { generateUniqueID } from "../util.js";
-import { ElementType } from "../action/createElement.js";
-import { FieldType } from "./field.ts";
-import { getFileName } from "./import.js";
-import { inferType } from "./field.ts";
-import { summarize } from "./field.ts";
-
-export default class DataTable {
-
-    constructor(data, url, fTypes) {
-        this.url = url;
-        //this.name = _getFileName(url);
-        this._id = ElementType.DataTable + generateUniqueID();
-        this._data = data;
-        this._rawData = JSON.parse(JSON.stringify(data));
-        //remember the original date values after parsing them
-        this._dateMap = new Map();
-        this._fields = Object.keys(this.data[0]);
-        this._newField = 0;
-        if (fTypes) {
-            this._fieldTypes = fTypes;
-        } else {
-            this._fieldTypes = {};
-            for (let f of this._fields) {
-                this._fieldTypes[f] = inferType(this.data.map(d => d[f]));
-                if (f.toLowerCase() == "year" && this._fieldTypes[f] == FieldType.Integer)
-                    this._fieldTypes[f] = FieldType.Date;
-            }
-        }
-        //fix null values, cast type and summarize
-        this._validate(this.data, this._fieldTypes);
-
-        this._fieldSummaries = {};
-        for (let f of this._fields) {
-            this._fieldSummaries[f] = summarize(this.data.map(d => d[f]), this._fieldTypes[f]);
-        }
-
-        //add row id
-        if (this._fields.indexOf(MSCRowID) < 0) {
-            this._addField(MSCRowID, FieldType.String, this.data.map((d, i) => "r" + i));
-        }
-    }
-
-    get id() {
-        return this._id;
-    }
-
-    get name() {
-        if (this.url)
-            return getFileName(this.url);
-        else
-            return this.id;
-    }
-
-    get data() {
-        return this._data;
-    }
-
-    //only tracking one transform away
-    // set sourceDataTable(dt) {
-    //     this._sourceDataTable = dt;
-    // }
-
-    // get sourceDataTable() {
-    //     return this._sourceDataTable;
-    // }
-
-    getEncodableFields(channel) {
-        switch (channel) {
-            case "x":
-            case "y":
-            case "width":
-            case "height":
-            case "radius":
-            case "fillColor":
-            case "strokeColor":
-            case "text":
-                return this.numericFields.concat(this.nonNumericFields);
-            case "area":
-            case "strokeWidth":
-            default:
-                return this.numericFields;
-        }
-    }
-
-    toJSON() {
-        let json = {};
-        json.data = this.rawData;
-        json.fieldTypes = this._fieldTypes;
-        json.url = this.url;
-        json.id = this.id;
-        json.sourceDataTable = this._sourceDataTable;
-        json.transform = this._transform;
-        json.dateMap = {};
-        return json;
-    }
-
-    setValueOrder(field, values) {
-        this._fieldSummaries[field].unique = values;
-    }
-
-    _addField(name, type, values) {
-        this.data.forEach((d, i) => d[name] = values[i]);
-        this._fieldTypes[name] = type;
-        this._fields.push(name);
-        this._fieldSummaries[name] = summarize(values, type);
-    }
-
-    getFieldType(f) {
-        return this._fieldTypes[f];
-    }
-
-    get fields() {
-        return this._fields;
-    }
-
-    getFieldSummary(f) {
-        return this._fieldSummaries[f];
-    }
-
-    getFieldValues(f) {
-        return this.data.map(d => d[f]);
-    }
-
-    getUniqueFieldValues(f) {
-        return this._fieldSummaries[f].unique;
-    }
-
-    getRowCount() {
-        return this.data.length;
-    }
-
-    hasField(f) {
-        return this._fields.indexOf(f) >= 0;
-    }
-
-    //date values are parsed and stored as number of milliseconds
-    parseFieldAsDate(field, format) {
-        //TODO: validate field and format
-        let parse = d3.timeParse(format);
-        for (let row of this.data) {
-            let v = row[field];
-            if (v == null || v == undefined) {
-                v = "";
-                row[field] = (new Date(1899, 11, 31)).getTime();
-            } else {
-                row[field] = parse(v).getTime();
-            }
-            this._dateMap.set(row[field], v);
-        }
-        this._fieldTypes[field] = FieldType.Date;
-        this._fieldSummaries[field] = summarize(this.data.map(d => d[field]), FieldType.Date);
-    }
-
-    //TODO: need to return the true raw value from the input file
-    getRawValue(col, v) {
-        if (this.getFieldType(col) === FieldType.Date)
-            return this._dateMap.get(v).toString();
-        else
-            return v;
-    }
-
-    get nonNumericFields() {
-        let r = [];
-        for (let f in this._fieldTypes) {
-            if (this._fieldTypes[f] != FieldType.Number && this._fieldTypes[f] != FieldType.Integer && f != DataTable.RowID) {
-                r.push(f);
-            }
-        }
-        r.sort((a, b) => this.getUniqueFieldValues(a).length - this.getUniqueFieldValues(b).length);
-        return r;
-    }
-
-    get numericFields() {
-        let r = [];
-        for (let f in this._fieldTypes) {
-            if ((this._fieldTypes[f] === FieldType.Number || this._fieldTypes[f] === FieldType.Integer) && f != DataTable.RowID) {
-                r.push(f);
-            }
-        }
-        return r;
-    }
-
-    getFieldsByType(t) {
-        let r = [];
-        for (let f in this._fieldTypes) {
-            if ((this._fieldTypes[f] === t) && f != DataTable.RowID) {
-                r.push(f);
-            }
-        }
-        return r;
-    }
-
-    // transform(type, fields, params) {
-    //     let args = params ? params : {};
-    //     switch (type) {
-    //         case "kde":
-    //             return kde(this, fields, args);
-    //         case "bin":
-    //             return bin(this, fields, args);
-    //         case "sort":
-    //             return sort(this, fields, args);
-    //         case "filter":
-    //             return filter(this, fields);
-    //     }
-    // }
-
-    summarize() {
-        for (let f of this._fields) {
-            this._fieldSummaries[f] = summarize(this.data.map(d => d[f]), this._fieldTypes[f]);
-        }
-    }
-
-    _validate(data, fieldTypes) {
-        //date values are parsed and stored as number of milliseconds
-        for (let row of data) {
-            for (let f in fieldTypes) {
-                let type = fieldTypes[f], v = row[f], realv = undefined;
-                if (row[f] == null || row[f] == undefined) {
-                    switch (type) {
-                        case FieldType.Boolean:
-                            realv = false;
-                            break;
-                        case FieldType.Date:
-                            realv = (new Date(1899, 11, 31)).getTime();
-                            break;
-                        case FieldType.String:
-                            realv = "";
-                            break;
-                        default:
-                            realv = 0;
-                            break;
-                    }
-                } else {
-                    switch (type) {
-                        case FieldType.Boolean:
-                            realv = v;
-                            break;
-                        case FieldType.Date:
-                            if (Number.isInteger(v)) { //year
-                                realv = (new Date(v, 0)).getTime();
-                            } else {
-                                realv = (new Date(v + "")).getTime();
-                            }
-                            this._dateMap.set(realv, v);
-                            break;
-                        case FieldType.String:
-                            realv = v.toString();
-                            break;
-                        default:
-                            realv = v;
-                            break;
-                    }
-                }
-                row[f] = realv;
-            }
-        }
-    }
-}
-
-export const MSCRowID = "mascot_rowId";export const MSCNodeID = "id";
-

package/src-new-ts/data/Tree.js

@@ -1,3 +0,0 @@
-export default class Tree {
-    
-}

package/src-new-ts/data/field.ts

@@ -1,115 +0,0 @@
-import * as d3 from "d3";
-
-interface NodeTable {
-    hasField(field: string): boolean;
-}
-
-interface Tree {
-    nodeTable: NodeTable;
-}
-
-interface DataStructure {
-    name: string;
-    hasField(field: string): boolean;
-    tree?: Tree;
-}
-
-export function validateField(field: string, dt: DataStructure): boolean {
-    if (dt.hasField(field))
-        return true;
-    else if (dt.tree && dt.tree.nodeTable.hasField(field.split(".")[1]))
-        return true;
-    else
-        throw new Error(`Field ${field} does not exist in the table ${dt.name}`);
-}
-
-
-
-export enum FieldType {
-    Boolean = 'Boolean',
-    Date = 'Date',
-    String = 'String',
-    Number = 'Number', // Assuming there's a case for Number based on the default case in summarize function
-    Integer= 'integer'
-}
-
-interface Summary {
-    trueCount?: number;
-    falseCount?: number;
-    min?: number | Date;
-    max?: number | Date;
-    extent?: [number | Date, number | Date];
-    mean?: number;
-    median?: number;
-    unique: Array<any>;
-}
-
-export function inferType(values: any[]): FieldType {
-    let types = Object.values(FieldType) as string[];
-    for (let i = 0; i < values.length; i++) {
-        let v = values[i];
-        if (v == null) continue;
-        for (let j = 0; j < types.length; j++) {
-            // Casting the type to keyof typeof isValidType ensures that the string is considered a valid key of isValidType
-            const typeCheckKey = types[j] as keyof typeof isValidType;
-            if (!isValidType[typeCheckKey](v)) {
-                types.splice(j, 1);
-                j -= 1;
-            }
-        }
-        if (types.length === 1) {
-            // Assuming the types array initially contains strings that are keys of the FieldType enum,
-            // we need to cast the return value back to FieldType for proper typing.
-            return FieldType[types[0] as keyof typeof FieldType];
-        }
-    }
-    // Returning the first element as FieldType after ensuring it's a valid key of the FieldType enum.
-    return FieldType[types[0] as keyof typeof FieldType];
-}
-
-
-export const isValidType = {
-    boolean: function (x: any): boolean { 
-        return x === 'true' || x === 'false' || x === true || x === false || Object.prototype.toString.call(x) == '[object Boolean]'; 
-    },
-    integer: function (x: any): boolean { 
-        return isValidType.number(x) && (x = +x) === ~~x; 
-    },
-    number: function (x: any): boolean { 
-        return !isNaN(+x) && Object.prototype.toString.call(x) != '[object Date]'; 
-    },
-    date: function (x: any): boolean { 
-        let d = new Date(x); 
-        return d !== undefined && !isNaN(d.getTime()); 
-    },
-}
-
-export function summarize(values: Array<any>, type: FieldType): Summary {
-    let s: Summary = { unique: [] };
-    switch (type) {
-        case FieldType.Boolean:
-            s.trueCount = values.filter(d => d).length;
-            s.falseCount = values.filter(d => !d).length;
-            break;
-        case FieldType.Date:
-            // Assuming d3 methods are strongly typed elsewhere or using any as a fallback
-            s.min = d3.min(values) as Date;
-            s.max = d3.max(values) as Date;
-            s.extent = [s.min, s.max];
-            s.unique = [...new Set(values)];
-            break;
-        case FieldType.String:
-            s.unique = [...new Set(values)];
-            break;
-        default:
-            // Assuming these values are numbers for min, max, mean, and median calculations
-            s.min = d3.min(values) as number;
-            s.max = d3.max(values) as number;
-            s.extent = [s.min, s.max];
-            s.mean = d3.mean(values) as number;
-            s.median = d3.median(values) as number;
-            s.unique = [...new Set(values)];
-            break;
-        }
-        return s;
-}

package/src-new-ts/data/import.ts

@@ -1,96 +0,0 @@
-import * as d3 from "d3";
-import DataTable from "./Table.js";
-
-
-function makeRequest(method: string, url: string): Promise<string> {
-    return fetch(url, { method: method })
-        .then(response => {
-            if (!response.ok) { // if not (>= 200 and < 300)
-                console.log(response.status)
-                return Promise.reject({
-                    status: response.status,
-                    statusText: response.statusText
-                });
-            }
-            return response.text();
-        })
-        .catch(error => {
-            console.log(error);
-            return Promise.reject({
-                status: error.status || 0,
-                statusText: error.statusText || 'Unknown Error'
-            });
-        });
-}
-
-
-export async function importCSV(url: string): Promise<DataTable> {
-    let data: string = await makeRequest("GET", url);
-    // Assuming d3.csvParse returns an array of objects with unknown shapes,
-    // and DataTable can accept this array directly.
-    let parsed = d3.csvParse(data.trim(), d3.autoType);
-    return new DataTable(parsed, url);
-}
-
-// export async function importTreejson(url) {
-//     let data = await makeRequest("GET", url);
-//     return new Tree(JSON.parse(data), url);
-// }
-
-// export async function importGraphjson(url) {
-//     let data = await makeRequest("GET", url);
-//     return new Network(JSON.parse(data), url);
-// }
-
-function validResponse(request: XMLHttpRequest): string | ArrayBuffer | null {
-    var type = request.responseType;
-    return type && type !== 'text' ?
-        request.response : // possibly ArrayBuffer or null on error
-        request.responseText; // string or '' on error
-}
-
-
-export function csvSync(url: string, callback?: (data: DataTable) => void): DataTable | undefined {
-    let async = Boolean(callback);
-    var request = new XMLHttpRequest();
-    request.open('GET', url, async);
-    request.send();
-    if (!async) {
-        let response = validResponse(request);
-        // Type check to ensure response is a string before calling trim
-        if (typeof response === "string") {
-            let data = d3.csvParse(response.trim(), d3.autoType);
-            const dataTable = new DataTable(data, url);
-            if (callback) {
-                callback(dataTable);
-            }
-            return dataTable;
-        } else {
-            //TODO: throw errors based on response
-            throw new Error('Invalid response');
-        }
-    } else {
-        request.onload = () => {
-            let response = validResponse(request);
-            // Ensure onload, the response is treated as a string
-            if (typeof response === "string") {
-                let data = d3.csvParse(response.trim(), d3.autoType);
-                if (callback) {
-                    callback(new DataTable(data, url));
-                }
-            } else {
-                //TODO: handle asynchronous errors
-            }
-        };
-    }
-}
-
-export function getFileName(url: string): string {
-    var startIndex = (url.indexOf('\\') >= 0 ? url.lastIndexOf('\\') : url.lastIndexOf('/'));
-    var filename = url.substring(startIndex);
-    if (filename.indexOf('\\') === 0 || filename.indexOf('/') === 0) {
-        filename = filename.substring(1);
-    }
-    return filename;
-}
-

package/src-new-ts/data/predicate.ts

@@ -1,82 +0,0 @@
-interface Predicate {
-  field?: string;
-  value?: any;
-  interval?: [number, number];
-  values?: any[];
-  channel?: string;
-  type?: string;
-  id?: string | number;
-  classId?: string | number;
-  fields?: string[];
-  operator?: '==' | '>' | '>=' | '<' | '<=';
-}
-
-interface Element {
-  dataScope?: {
-      getFieldValue: (field: string) => any;
-      hasField: (field: string) => boolean;
-  };
-  [key: string]: any; // For properties like 'type', 'id', 'classId', etc.
-}
-export function matchCriteria(cpnt: Element, predicates: Predicate[]): boolean {
-  for (let p of predicates) {
-      if (!evaluatePredicate(cpnt, p))
-          return false;
-  }
-  return true;
-}
-
-export function evaluatePredicate(elem: Element, p: Predicate): boolean {
-  // Example of using optional chaining (?.) and nullish coalescing (??)
-  if ("field" in p && p.field) { // Checking if 'field' is a property in 'p' and it's not null/undefined
-      const dataScope = elem.dataScope;
-      if (!dataScope) return false;
-      
-      let f = p.field;
-      if ("value" in p) {
-          return dataScope.getFieldValue(f) === p.value;
-      } else if ("interval" in p && p.interval) {
-          let v = dataScope.getFieldValue(f);
-          return v >= p.interval[0] && v <= p.interval[1];
-      } else if ("values" in p && p.values) {
-          return p.values.includes(dataScope.getFieldValue(f));
-      } else {
-          return dataScope.hasField(f);
-      }
-  } else if ("channel" in p && p.channel) {
-      let c = p.channel;
-      let elemValue = elem[c]; // Direct access since 'c' is now guaranteed to be a property in 'elem'
-      if ("value" in p) {
-          return elemValue === p.value;
-      } else if ("interval" in p && p.interval) {
-          return elemValue >= p.interval[0] && elemValue <= p.interval[1];
-      } else if ("values" in p && p.values) {
-          return p.values.includes(elemValue);
-      }
-  } else if ("type" in p) {
-      return elem.type === p.type;
-  } else if ("id" in p) {
-      return elem.id === p.id;
-  } else if ("classId" in p) {
-      return elem.classId === p.classId;
-  } else if ("fields" in p && p.fields && p.operator) {
-      if (!elem.dataScope) return false;
-      let [f1, f2] = p.fields;
-      let v1 = elem.dataScope.getFieldValue(f1), v2 = elem.dataScope.getFieldValue(f2);
-      switch (p.operator) {
-          case "==":
-              return v1 == v2;
-          case ">":
-              return v1 > v2;
-          case ">=":
-              return v1 >= v2;
-          case "<":
-              return v1 < v2;
-          case "<=":
-              return v1 <= v2;
-          default:
-              return false; // Handling the default case if the operator doesn't match
-      }
-  }
-  return false;
-}