| 'noop' | replace value with itself, performing no operation. |
| 'cumulate' | replace value with the cumulative sum of values up to the current element. |
| '`ascending`' | sort in ascending order. |
| '`descending`' | sort in decending order. |
1/**
+ 2 */
+ 3
+ 4 /** */
+ 5import { Condition, filter } from './DataFilters';
+ 6
+ 7/** defines a [min-max] range */
+ 8export type NumRange = [number, number];
+ 9
+ 10/** defines a numeric domain that includes all values of a column */
+ 11export type NumDomain = [number, number];
+ 12
+ 13/** defines a Date domain that includes all values of a column */
+ 14export type DateDomain = [Date, Date];
+ 15
+ 16/** defines a categorical domain that includes all values of a column */
+ 17export type NameDomain = string[];
+ 18
+ 19/** defines a generic domain that can be any of the typed domains. */
+ 20export type Domain = NumDomain | DateDomain | NameDomain;
+ 21
+ 22/** defines a Column Reference, either as column name or index in the {@link Data.DataRow `DataRow`} array */
+ 23export type ColumnReference = number|string;
+ 24
+ 25/** a generic data value type, used in the {@link Data.DataRow `DataRow`} array */
+ 26export type DataVal = number|string|Date;
+ 27
+ 28/** a single row of column values */
+ 29export type DataRow = DataVal[];
+ 30
+ 31/** a JSON format data set, using arrays of names and rows */
+ 32export interface DataSet {
+ 33 /** an optional name for the data set */
+ 34 name?: string;
+ 35 /** an array of column names. Each name matches the column with the same index in DataRow */
+ 36 colNames: string[];
+ 37 /** rows of data */
+ 38 rows: DataRow[];
+ 39}
+ 40
+ 41/** a JSON format data set, using an array of {name:value, ...} literals*/
+ 42export type DataLiteralSet = Array;
+ 43
+ 44interface TypeStruct { type: string; count: number;};
+ 45
+ 46interface MetaStruct {
+ 47 name: string; // column name
+ 48 column: number; // column index
+ 49 accessed: boolean; // has column data been accessed?
+ 50 cast: boolean; // has column data been cast
+ 51 types: TypeStruct[]; // data types, sorted by likelihood
+ 52}
+ 53
+ 54export type sortFn = (x:any, y:any) => number;
+ 55export type mapFn = (colVal:any, colIndex?:number, rowIndex?:number, rows?:any[][]) => any;
+ 56
+ 57/**
+ 58 * # Data
+ 59 * A simple in-memory database that holds data in rows of columns.
+ 60 *
+ 61 */
+ 62export class Data {
+ 63 //----------------------------
+ 64 // public part
+ 65 //----------------------------
+ 66 public static type = {
+ 67 /** numeric values */
+ 68 number: 'number',
+ 69 /** nominal values, represented by arbitrary words */
+ 70 name: 'name',
+ 71 /** date values */
+ 72 date: 'date',
+ 73 /** currency values. Currently support6ed are values ofg the format '$dd[,ddd]' */
+ 74 currency: 'currency',
+ 75 /** percent values: 'd%' */
+ 76 percent: 'percent',
+ 77// nominal: 'nominal'
+ 78 };
+ 79
+ 80 public static toDataSet(data:DataLiteralSet, name?:string):DataSet {
+ 81 data = data || [{}];
+ 82 const names = Object.keys(data[0]);
+ 83 const rows = data.map((r:any) =>
+ 84 names.map((n:string) => r[n]));
+ 85 return { rows:rows, colNames:names, name:name||undefined };
+ 86 }
+ 87
+ 88 constructor(data?:DataSet) {
+ 89 this.import(data);
+ 90 }
+ 91
+ 92 /**
+ 93 * @return the `name` field for this data base, if any
+ 94 */
+ 95 public getName():string {
+ 96 return this.name;
+ 97 }
+ 98
+ 99 /**
+ 100 * Imports data from an object literal `data`
+ 101 * @param data the data set to import
+ 102 */
+ 103 public import(data:DataSet) {
+ 104 this.name = data.name;
+ 105 this.setData(data.rows, data.colNames);
+ 106 }
+ 107
+ 108 /**
+ 109 * Exports to an object literal
+ 110 */
+ 111 public export():DataSet {
+ 112 return {
+ 113 rows: this.getData(),
+ 114 colNames:this.colNames()
+ 115 };
+ 116 }
+ 117
+ 118 /**
+ 119 * returns the 2D array underlying the data base.
+ 120 */
+ 121 public getData():DataRow[] {
+ 122 return this.data;
+ 123 }
+ 124
+ 125 /**
+ 126 * Returns the values in the specified column as a new array.
+ 127 * @param col the column to return.
+ 128 */
+ 129 public getColumn(col:ColumnReference): DataVal[] {
+ 130 const cn = this.colNumber(col);
+ 131 return this.data.map((row:DataRow) => row[cn]);
+ 132 }
+ 133
+ 134 /**
+ 135 * adds a new column to the data set. if `newCol` already exists,
+ 136 * the column index is returned withoput change.
+ 137 * @param col the name of the new column
+ 138 * @return the index for the new column
+ 139 */
+ 140 public colAdd(col:string):number {
+ 141 let m = this.getMeta(col);
+ 142 if (m === undefined) {
+ 143 m = this.meta[col] = {};
+ 144 m.name = col;
+ 145 m.column = this.meta.length;
+ 146 this.meta.push(m); // access name by both column name and index
+ 147 m.cast = false; // has not been cast yet
+ 148 m.accessed = false; // has not been accessed yet
+ 149 }
+ 150 return m.column;
+ 151 }
+ 152
+ 153 /**
+ 154 * initializes the specifed column with values, adding a new column if needed.
+ 155 * If `val`is a function, it is called as ```
+ 156 * val(colValue:DataVal, rowIndex:number, row:DataRow)
+ 157 * ```
+ 158 * @param col the column to initialize
+ 159 * @param initializer the value to initialize with, or a function whose return
+ 160 * value is used to initialize the column
+ 161 */
+ 162 public colInitialize(col:ColumnReference, initializer:any) {
+ 163 const cn = this.colNumber(col);
+ 164 if (!cn && typeof col === 'string') { this.colAdd(col); }
+ 165 const fn = typeof initializer === 'function';
+ 166 if (cn!==undefined) {
+ 167 this.data.map((r:DataRow, i:number) =>
+ 168 r[cn] = fn? initializer(r[cn], i, r) : initializer
+ 169 );
+ 170 }
+ 171 }
+ 172
+ 173 /**
+ 174 * returns the column index of the specified column.
+ 175 * `col` can be either an index or a name.
+ 176 * @param column the data column, name or index, for which to return the index.
+ 177 * @return the column number or `undefined`.
+ 178 */
+ 179 public colNumber(col:ColumnReference) {
+ 180 const m = this.getMeta(col);
+ 181 if (!m) { return undefined; }
+ 182 else {
+ 183 m.accessed = true;
+ 184 return m.column;
+ 185 }
+ 186 }
+ 187
+ 188 /**
+ 189 * returns the column name for the specified column.
+ 190 * `col` can be either an index or a name.
+ 191 * @param column the data column, name or index.
+ 192 * @return the column name or `undefined`.
+ 193 */
+ 194 public colName(col:ColumnReference) {
+ 195 var m = this.getMeta(col);
+ 196 if (!m) { return undefined; }
+ 197 m.accessed = true;
+ 198 return m.name;
+ 199 }
+ 200
+ 201 /**
+ 202 * returns the names for all columns.
+ 203 * @return an array of strings with the names.
+ 204 */
+ 205 public colNames():string[] {
+ 206 return this.meta.map((m:MetaStruct) => m.name);
+ 207 }
+ 208
+ 209 /**
+ 210 * returns the column type for the specified column.
+ 211 * `col` can be either an index or a name.
+ 212 * @param column the data column, name or index.
+ 213 * @return the column type.
+ 214 */
+ 215 public colType(col:ColumnReference) {
+ 216 const meta = this.getMeta(col);
+ 217 return meta? meta.types[0].type : Data.type.name;
+ 218 }
+ 219
+ 220 /**
+ 221 * modifies `domain` to include all values in column `col`.
+ 222 * If no `col` is specified, the range of data indexes is returned.
+ 223 * @param col optional; the column name or index
+ 224 * @param domain optional; the Domain range to update
+ 225 * @return the updated domain
+ 226 */
+ 227 public findDomain(col?:ColumnReference, domain?:Domain):Domain {
+ 228 if (domain===undefined) { domain = []; }
+ 229 if (col === undefined) { // use array index as domain
+ 230 domain[0] = 0;
+ 231 domain[1] = this.data.length-1;
+ 232 } else {
+ 233 const c = this.colNumber(col);
+ 234 const type = this.colType(col);
+ 235 if (this.data === undefined) {
+ 236 console.log('no data');
+ 237 }
+ 238 switch(type) {
+ 239 case Data.type.name:
+ 240 this.data.forEach((r:DataRow) => {
+ 241 const nomDom = domain;
+ 242 if (nomDom.indexOf(''+r[c]) < 0) { nomDom.push(''+r[c]); }
+ 243 });
+ 244 break;
+ 245 default:
+ 246 this.data.forEach((r:DataRow) => {
+ 247 let v:number = r[c];
+ 248 if (domain[0]===undefined) { domain[0] = v; }
+ 249 if (domain[1]===undefined) { domain[1] = v; }
+ 250 if (v!==undefined && v!==null) {
+ 251 if (v
+ 252 else if (v>domain[1]) { domain[1] = v; }
+ 253 }
+ 254 });
+ 255 }
+ 256 }
+ 257 return domain;
+ 258 }
+ 259
+ 260 public castData() {
+ 261 this.meta.forEach((c:MetaStruct) => {
+ 262 const col = c.column;
+ 263 if (!c.cast) {
+ 264 this.data.forEach((row:DataRow) => row[col] = this.castVal(c.types[0].type, row[col]));
+ 265 }
+ 266 c.cast = true;
+ 267 });
+ 268 }
+ 269
+ 270 /**
+ 271 * filters this data set and returns a new data set with a
+ 272 * shallow copy of rows that pass the `condition`.
+ 273 * See {@link DataFilters DataFilters} for rules and examples on how to construct conditions.
+ 274 * @param condition filters
+ 275 * @return a new Data object with rows that pass the filter
+ 276 */
+ 277 public filter(condition:Condition):Data {
+ 278 return filter(this, condition);
+ 279 }
+ 280
+ 281 /**
+ 282 * @description Sorts the rows of values based on the result of the `sortFn`,
+ 283 * which behaves similarly to the Array.sort method.
+ 284 * Two modes are supported:
+ 285 * # Array Mode
+ 286 * If `col` is omitted, the column arrays are passed as samples into the `sortFn`.
+ 287 * This allows for complex sorts, combining conditions across multiple columns.
+ 288 * ```
+ 289 * data.sort((row1, row2) => row1[5] - row2[5] );
+ 290 * ```
+ 291 * # Column mode
+ 292 * If `col` is specified, either as index or by column name, the respective column value is passed
+ 293 * into `sortFn`. This allows filtering for simple conditions.
+ 294 * **The specified column will be automatically cast prior to sorting**
+ 295 * `data.sort('Date', function(val1, val2) { return val1 - val2; });`
+ 296 * @param col optional; the data column to use for sorting.
+ 297 * @param sortFn a function to implement the conditions,
+ 298 * follows the same specifications as the function passed to Array.sort().
+ 299 * Some predefined sort function can be invoked by providing a
+ 300 * respective string instead of a function. The following functions are defined:
+ 301
+ 302 '`ascending`' sort in ascending order.
+ 303 '`descending`' sort in decending order.
+ 304
+ 305 * @return the Data object in order to allow for chaining.
+ 306 */
+ 307 public sort(sortFn:string|sortFn, col?:ColumnReference):Data {
+ 308 let fn = sortFn;
+ 309 if (!col) {
+ 310 this.data.sort(fn);
+ 311 } else {
+ 312 col = this.colNumber(col);
+ 313 if (sortFn === 'descending') { fn = (a:any, b:any) => (b>a)?1:((b
+ 314 if (sortFn === 'ascending') { fn = (a:any, b:any) => (ba)?-1:0); }
+ 315 this.data.sort((r1:any[], r2:any[]) => fn(r1[col], r2[col]));
+ 316 }
+ 317 return this;
+ 318 }
+ 319
+ 320 /**
+ 321 * Maps one or more columns in each rows of values based
+ 322 * on the result of the `mapFn`, which behaves similarly to the Array.map() method.
+ 323 * Two modes are supported:
+ 324 * # Array Mode
+ 325 * If `col` is omitted, the `mapFn` is passed the column arrays per row as parameter.
+ 326 * This allows for complex mapping combining conditions across multiple columns.
+ 327 * ```
+ 328 * data.map(function(values){
+ 329 * values[1] = values[3] * values[5];
+ 330 * return values;
+ 331 * });
+ 332 * ```
+ 333 * Be sure to return the `values` array as a result.
+ 334 * # Column mode
+ 335 * If `col` is specified, either as index or by column name, the respective column value is passed
+ 336 * into `mapFn`, along with the row index and the entire row array. This allows for simple mapping.
+ 337 * ```
+ 338 * data.map('Price', function(value, i, values) {
+ 339 * return value * 2;
+ 340 * });
+ 341 * ```
+ 342 * @param col the data column, or columns, to apply the mapping to.
+ 343 * @param mapFn a function to implement the mapping,
+ 344 * called on each row of the data set in turn as `mapFn(val, i, c, rows)`, where
+ 345 * - `val`: the column value in the current row
+ 346 * - `c`: the column index in the current row
+ 347 * - `i`: the row index
+ 348 * - `rows`: the rows being iterated over
+ 349` *
+ 350 * follows the same specifications as the function passed to Array.map().
+ 351 * For column mode, some predefined map functions can be invoked by providing a
+ 352 * respective string instead of a function. The following functions are defined:
+ 353
+ 354 'noop' replace value with itself, performing no operation.
+ 355 'cumulate' replace value with the cumulative sum of values up to the current element.
+ 356
+ 357 * @return a new Data object containing the mapping.
+ 358 */
+ 359 public map(col:ColumnReference|ColumnReference[], mapFn:string|mapFn):Data {
+ 360 const noop = (val:any) => val;
+ 361 const cumulate = () => {
+ 362 let sum=0;
+ 363 return (val:number, i:number) => { sum += +val; return sum; };
+ 364 };
+ 365 function getFn() {
+ 366 let fn; // define fn inside each col loop to ensure initialization
+ 367 switch (mapFn) {
+ 368 case 'cumulate': fn = cumulate(); break;
+ 369 case 'noop': fn = noop; break;
+ 370 default: fn = mapFn;
+ 371 }
+ 372 return fn;
+ 373 }
+ 374
+ 375 let result = new Data({colNames:this.colNames(), rows:this.data.slice(), name:this.getName()});
+ 376
+ 377 const names = col['length']? col : [col];
+ 378 names.map((cn:ColumnReference) => {
+ 379 const c = this.colNumber(cn);
+ 380 let fn = getFn(); // define fn inside each col loop to ensure initialization
+ 381 result.data = result.data.map((row:any[], i:number, rows:any[][]) => {
+ 382 row[c] = fn(row[c], c, i, rows);
+ 383 return row;
+ 384 });
+ 385 });
+ 386 return result;
+ 387 }
+ 388
+ 389 //----------------------------
+ 390 // private part
+ 391 //----------------------------
+ 392 private data: DataRow[] = [];
+ 393 private meta: MetaStruct[] = [];
+ 394 private name: string;
+ 395
+ 396 private getMeta(col:ColumnReference):MetaStruct {
+ 397 if (!this.meta) { this.meta = []; }
+ 398 if (!this.meta[col]) { return undefined; }
+ 399 this.meta[col].accessed = true;
+ 400 return this.meta[col];
+ 401 }
+ 402
+ 403 /**
+ 404 * sets `data` to the existing data set. If data has previously been set,
+ 405 * `data` will be added to the end of the list if all `names` match those of the
+ 406 * existing set.
+ 407 * @param data the data to add
+ 408 * @param names an array of names that match the columns
+ 409 * @param autoType unless set to false, the method will attempt to determine the
+ 410 * type of data and automatically cast data points to their correct value
+ 411 */
+ 412 private setData(data:DataRow[], names:string[], autoType=true):void {
+ 413 this.meta = [];
+ 414 this.data = data;
+ 415 if (!names) {
+ 416 console.log();
+ 417 }
+ 418 names.forEach((col:string) => this.colAdd(col));
+ 419 names.forEach((col:string) => this.findTypes(col));
+ 420 this.castData();
+ 421 }
+ 422
+ 423 /**
+ 424 * Determines the type of data in `col`. An array of counts is created for all
+ 425 * encountered types, sorted by descending frequency. THe most likely type in position 0
+ 426 * of the array is returned.
+ 427 * @param col the index of the column to be typed.
+ 428 * @return the most likely type of data in `col`.
+ 429 */
+ 430 private findTypes(col:ColumnReference):string {
+ 431 const m = this.getMeta(col);
+ 432 const types:TypeStruct[] = [];
+ 433 Object.keys(Data.type).forEach((t:string) => {
+ 434 const ts = { type: Data.type[t], count: 0 };
+ 435 types.push(ts);
+ 436 types[Data.type[t]] = ts;
+ 437 });
+ 438 for (let v of this.allRows(col)) {
+ 439 const t = this.findType(v);
+ 440 if (t !== null) { types[t].count++; }
+ 441 }
+ 442 types.sort(function(a:TypeStruct, b:TypeStruct) {
+ 443 if (a.type==='currency'&&a.count>0) { return -1; }
+ 444 if (b.type==='currency'&&b.count>0) { return 1; }
+ 445 return b.count - a.count;
+ 446 });
+ 447 m.types = types;
+ 448 return types[0].type;
+ 449 }
+ 450
+ 451 /**
+ 452 * @description determines the data type. Supported types are
+ 453 * ```
+ 454 * 'date': sample represents a Date, either as a Date object or a String
+ 455 * 'number': sample represents a number
+ 456 * 'percent': sample represents a percentage (special case of a real number)
+ 457 * 'nominal': sample represents a nominal (ordinal or categorical) value
+ 458 * ```
+ 459 * @param val the value to bve typed.
+ 460 * @returns the type ('number', 'date', 'percent', 'nominal', 'currency') corresponding to the sample
+ 461 */
+ 462 private findType(val:DataVal) {
+ 463 if (val && val!=='') {
+ 464 if (val instanceof Date) { return Data.type.date; } // if val is already a date
+ 465 if (typeof val === 'number') { return Data.type.number; } // if val is already a number
+ 466
+ 467 // else: val is a string:
+ 468 const strVal = ''+val;
+ 469 if (''+parseFloat(strVal) === strVal) { return Data.type.number; }
+ 470 if (strVal.startsWith('$') && !isNaN(parseFloat(strVal.slice(1)))) { return Data.type.currency; }
+ 471 if (strVal.endsWith('%') && !isNaN(parseFloat(strVal))) { return Data.type.percent; }
+ 472 if (!isNaN(this.toDate(strVal).getTime())) { return Data.type.date; }
+ 473
+ 474 // european large number currency representation: '$dd[,ddd]'
+ 475 if ((/^\$\d{0,2}((,\d\d\d)*)/g).test(val)) {
+ 476 if (!isNaN(parseFloat(val.trim().replace(/[^eE\+\-\.\d]/g, '').replace(/,/g, '')))) {
+ 477 return Data.type.currency;
+ 478 }
+ 479 }
+ 480 switch (strVal.toLowerCase()) {
+ 481 case "null": break;
+ 482 case "#ref!": break;
+ 483 default: if (val.length>0) { return Data.type.name; }
+ 484 }
+ 485 }
+ 486 return null;
+ 487 }
+ 488
+ 489 /**
+ 490 * A generator that provides the specified column value for each row in `Data` in sequence.
+ 491 * @param column
+ 492 */
+ 493 private * allRows(column:ColumnReference):Iterable {
+ 494 const c = this.colNumber(column);
+ 495 for (let r=0; r
+ 496 yield this.data[r][c];
+ 497 }
+ 498 }
+ 499
+ 500 /**
+ 501 * @param val the string to convert to a date
+ 502 * @param limitYear the year below which the century is corrected. Defaults to 1970.
+ 503 * @returns a new Date object parsed from `str`.
+ 504 * @description returns a new Date object parsed from `str` and corrects for a difference in
+ 505 * interpreting centuries between webkit and mozilla in converting strings to Dates:
+ 506 * The string "15/7/03" will convert to Jul 15 1903 in Mozilla and July 15 2003 in Webkit.
+ 507 * If `limitYear` is not specified this method uses 1970 as the decision date:
+ 508 * years 00-69 will be interpreted as 2000-2069, years 70-99 as 1970-1999.
+ 509 */
+ 510 private toDate(val:DataVal, limitYear=1970):Date {
+ 511 let d:Date;
+ 512 if (val instanceof Date) { d = val; }
+ 513 else { d = new Date(val); }
+ 514 let yr=d.getFullYear();
+ 515 if (yr < 100) {
+ 516 yr += 1900;
+ 517 d.setFullYear( (yr < limitYear)? yr+100 : yr);
+ 518 }
+ 519 return d;
+ 520 }
+ 521
+ 522 /**
+ 523 * @param type ['date' | 'percent' | 'real' | _any_] The type to cast into. In case of _any_ - i.e. `type`
+ 524 * does not match any of the previous keywords, no casting occurs.
+ 525 * @param sample The value to cast.
+ 526 * @returns The result of the cast.
+ 527 * @description Casts the sample to the specified data type.
+ 528 */
+ 529 private castVal(type:string, val:DataVal):DataVal {
+ 530 switch (type) {
+ 531 case Data.type.date: if (val instanceof Date) { return val; }
+ 532 val = this.toDate(val);
+ 533 if (isNaN(val.getTime())) { val = null; }
+ 534 break;
+ 535 case Data.type.percent: if (typeof val === 'string') {
+ 536 const num = parseFloat(val);
+ 537 val = (val).endsWith('%')? num/100 : num;
+ 538 }
+ 539 if (isNaN(val)) { val = null; }
+ 540 break;
+ 541 case Data.type.currency:// replace all except 'e/E', '.', '+/-' and digits
+ 542 if (typeof val === 'string') { val = val.replace(/[^eE\+\-\.\d]/g, ''); }
+ 543 /* falls through */
+ 544 case Data.type.number: if (typeof val === 'string') { val = parseFloat(val); }
+ 545 if (isNaN(val)) { val = null; }
+ 546 break;
+ 547 default: val = ''+val;
+ 548 }
+ 549 return val;
+ 550 }
+ 551}
1var o = require("mithril/ospec/ospec");
+ 2import * as hsdatab from './';
+ 3
+ 4const colNames = ['Name', 'Value', 'Start', 'End'];
+ 5const rows = [
+ 6 ['Harry', '100', '3/1/14', '11/20/14'],
+ 7 ['Mary', '1500', '7/1/14', '9/30/14'],
+ 8 ['Peter', '400', '5/20/14', '4/30/15'],
+ 9 ['Jane', '700', '11/13/14', '8/15/15']
+ 10];
+ 11
+ 12const data = new hsdatab.Data({colNames:colNames, rows:rows});
+ 13
+ 14const query = {Name:["Peter", "Jane"]};
+ 15const result = data.filter(query);
+ 16
+ 17o.spec("Data", () => {
+ 18 o("is created with 4 rows", () => {
+ 19 o(data.getData().length).equals(4);
+ 20 });
+ 21});
+ 22o.spec('Data Filters', () => {
+ 23 o('Query for {Name:["Peter", "Jane"]}', () => {
+ 24 o(result.getData().length).equals(2)('has two rows');
+ 25 o(result.getColumn('Name')[0]).equals('Peter')('has first row name Peter');
+ 26 });
+ 27});
+ 28
+ 29
+ 30/*
+ 31 var vnode = MyComponent.view()
+ 32
+ 33 o(vnode.tag).equals("div")
+ 34 o(vnode.children.length).equals(1)
+ 35 o(vnode.children[0].tag).equals("p")
+ 36 o(vnode.children[0].children).equals("Hello world")
+ 37*/
| '`ascending`' | sort in ascending order. |
| '`descending`' | sort in decending order. |
| 'noop' | replace value with itself, performing no operation. |
| 'cumulate' | replace value with the cumulative sum of values up to the current element. |
1
+ 2/**
+ 3* Use the {@link filter `filter`} function to executes a queries on a {@link Data `Data`} object.
+ 4* Each row in the data is checked and those for which `conditions` holds true are returned as a new `Data` object.
+ 5*
+ 6* # Condition construction
+ 7*
+ 8* ### General Condition
+ 9* ```
+ 10* Condition =
+ 11* IndexCondition -> conditions on the row index
+ 12* || RecursiveCondition -> (set of) conditions on column values
+ 13* ```
+ 14*
+ 15* ### IndexCondition
+ 16* ```
+ 17* IndexCondition =
+ 18* rowIndex:number -> true if row index matches
+ 19* ```
+ 20*
+ 21* ### RecursiveCondition
+ 22* ```
+ 23* RecursiveCondition =
+ 24* OrCondition -> OR: true if any compound condition is true
+ 25* || AndCondition -> AND: true if all compound conditions are true
+ 26*
+ 27* OrCondition = -> OR: true if
+ 28* AndCondition[] -> any of the AndConditions are true
+ 29* || IndexCondition[] -> any of thr IndexConditions are true
+ 30*
+ 31* AndCondition = -> AND: true if
+ 32* SetAndCondition -> all SetAndConditions are true
+ 33* || TermAndCondition -> or if all TermAndConditions are true
+ 34*
+ 35* SetAndCondition = { -> AND: true if all sub-conditions are true
+ 36* 'or': RecursiveCondition -> true if any RecursiveCondition is true
+ 37* || 'and': RecursiveCondition -> true if all RecursiveCondition are true
+ 38* || 'not': RecursiveCondition -> true if the condition is false
+ 39*
+ 40* TermAndCondition = { -> Terminal AND: true if all terminal sub-conditions are true
+ 41* colDesc:colValue -> true if colValue matches
+ 42* || colDesc:[colValue, ...] -> true if any of the colValues match
+ 43* || colDesc:function(value,row) -> true if function returns true
+ 44* }
+ 45*
+ 46* colDesc = either column name or index
+ 47* ```
+ 48*
+ 49* ### Practical Tips
+ 50* ```
+ 51* {'or': [recurCond, ...]} -> OR, same as [recurCond, ...]
+ 52* || {'or': {SetCond, ...}} -> OR, same as [SetCond, ...]
+ 53* || {'and': [recurCond, ...]} -> AND, true if all recurCond are true
+ 54* || {'and': {SetCond, ...}} -> AND, same as {SetCond, ...}
+ 55* || {'not': {SetCond, ...}} -> NAND: true if the SetCond are true
+ 56* || {'not': [recurCond, ...]} -> NOR: true if any of the recurCond are true
+ 57* ```
+ 58*
+ 59* # Example
+ 60*
+ 61*
+ 62* const colNames = ['Name', 'Value', 'Start', 'End'];
+ 63* const rows = [
+ 64* ['Harry', '100', '3/1/14', '11/20/14'],
+ 65* ['Mary', '1500', '7/1/14', '9/30/14'],
+ 66* ['Peter', '400', '5/20/14', '4/30/15'],
+ 67* ['Jane', '700', '11/13/14', '8/15/15']
+ 68* ]
+ 69* const data = new hsdatab.Data({colNames:colNames, rows:rows});
+ 70*
+ 71* queries = [
+ 72* ['0', undefined, 'undefined query => pass all'],
+ 73* ['1', [], 'empty OR: [] => fail all'],
+ 74* ['2', {}, 'empty AND: {} => pass all'],
+ 75* ['3', 1, '2nd row: pass row 1'],
+ 76* ['4', [1,3], '2nd+4th: pass rows: 1 and 3'],
+ 77* ['5', {Name:"Jane"}, 'Name is Jane'],
+ 78* ['6', {1:1500}, 'Column 2 is 1500'],
+ 79* ['7', {Name:["Peter", "Jane"]}, 'Name is Peter or Jane'],
+ 80* ['8', [{Name:"Peter"}, {Value:1500}], 'Name is Peter or Value is 1500'],
+ 81* ['9', {or:{Name:"Peter", Value:1500}}, 'OR: same as 8:'],
+ 82* ['A', {or:[{Name:"Peter"}, {Value:1500}]}, 'OR: [{Name is Peter}, {Value is 1500}]'],
+ 83* ['B', {Name:"Peter", Value:400}, 'Name is Peter and Value is 400'],
+ 84* ['C', {and:{Name:"Peter", Value:400}}, 'AND: {Name is Peter, Value is 400}'],
+ 85* ['D', {and:{Name:"Peter", Value:1500}}, 'AND: {Name is Peter, Value is 1500}'],
+ 86* ['E', {and:[{Name:"Peter"}, {Value:400}]}, 'AND:[{Name is Peter}, {Value is 400}]'],
+ 87* ['F', {and:[{Name:"Peter"}, {Value:1500}]},'AND:[{Name is Peter}, {Value is 1500}]'],
+ 88* ['G', {not:{Name:"Peter", Value:400}}, 'NAND: not {Name is Peter and Value is 400}'],
+ 89* ['H', {not:{Name:"Peter", Value:1500}}, 'NAND: not {Name is Peter and Value is 1500}'],
+ 90* ['I', {not:[{Name:"Peter"}, {Value:1500}]},'NOR: not [{Name is Peter} or {Value is 1500}]'],
+ 91* ['J', {Name:(v) => v.length===4}, 'Name has 4 letters']
+ 92* ];
+ 93*
+ 94* m.mount(root, {
+ 95* view:() => m('', [
+ 96* m('h3', 'Given the data set:'),
+ 97* m('table#data', [
+ 98* m('tr', colNames.map(n => m('th', n))),
+ 99* ...rows.map(row => m('tr', [m('td', row[0]),m('td', row[1]),m('td', row[2].toDateString()),m('td', row[3].toDateString())]))
+ 100* ]),
+ 101* m('h3', 'The following queries yield:'),
+ 102* m('table', [
+ 103* m('tr', [m('th','#'), m('th','Query'), m('th',"Live Result, by 'Name' field")]),
+ 104* ...queries.map(q => {
+ 105* const result = data.filter(q[1]).getColumn('Name').join(', ');
+ 106* return m('tr', [m('td',`${q[0]}:`), m('td',`${q[2]}`), m('td',`[ ${result} ]`)]);
+ 107* })
+ 108* ])
+ 109* ])
+ 110* });
+ 111*
+ 112*
+ 113* $exampleID { height: 600px; }
+ 114* #data th { width:15%; }
+ 115* table {
+ 116* font-size: 10pt;
+ 117* margin-left: 10px;
+ 118* }
+ 119*
+ 120*
+ 121*/
+ 122
+ 123/** */
+ 124import { Data,
+ 125 DataVal,
+ 126 DataRow
+ 127} from './Data';
+ 128
+ 129export type Condition = IndexCondition | RecursiveCondition;
+ 130
+ 131/** true if row index matches the number(s) */
+ 132export type IndexCondition = number;
+ 133
+ 134export type RecursiveCondition = AndCondition | OrCondition;
+ 135export type OrCondition = AndCondition[] | IndexCondition[];
+ 136export type AndCondition = SetAndCondition | TermAndCondition;
+ 137
+ 138export interface SetAndCondition {
+ 139 or?: RecursiveCondition;
+ 140 and?:RecursiveCondition;
+ 141 not?:RecursiveCondition;
+ 142};
+ 143
+ 144export interface TermAndCondition {
+ 145 [colDesc:string]:
+ 146 DataVal
+ 147 | DataVal[]
+ 148 | TermConditionFunction
+ 149 ;
+ 150};
+ 151
+ 152export type TermConditionFunction = (value:DataVal, row:DataRow) => boolean;
+ 153
+ 154
+ 155function resolveTerminalCondition(name:string, val:any, row:DataRow, colNumber:(name:string)=>number):boolean {
+ 156 const col = colNumber(name);
+ 157 const valIsFunction = (typeof val === 'function');
+ 158 const valIsArray = ((typeof val === 'object') && (val.length!==undefined));
+ 159 if (isNaN(col)) {
+ 160 console.log(`column name '${name}' cannot be resolved in terminal condition ${name}=${val}`);
+ 161 console.log(row);
+ 162 return false; // -> this condition is not met;
+ 163 } else if (valIsFunction) {
+ 164 // query true if function evaluates to true
+ 165 return val(row[col], row);
+ 166 } else if (valIsArray) {
+ 167 // query true if empty array, or at least one c true
+ 168 return (val.length === 0) || val.some((v:any) => row[col] === v);
+ 169 } else { // object: all conditions have to be met, unless specified as or
+ 170 return (row[col] === val);
+ 171 }
+ 172}
+ 173
+ 174/**
+ 175 * applies `condition` to a row of data and returns `true` if the row passes.
+ 176 * @param condition the complex condition to test against
+ 177 * @param r the row index in the data set
+ 178 * @param row the row values
+ 179 * @param and
+ 180 */
+ 181function resolveCondition(condition:Condition, row:DataRow, r:number, colNumber:(name:string)=>number, and=true):boolean {
+ 182 let orResult = false;
+ 183 let andResult= true;
+ 184 // undefined condition is TRUE
+ 185 if (condition===undefined) { return true; }
+ 186
+ 187 // Simple Index Condition on row index:
+ 188 else if (typeof condition === 'number') { return (condition === r); }
+ 189
+ 190 // Recursive Condition - OR: [...], AND {...}:
+ 191 else if (typeof condition === 'object') {
+ 192 // array -> or condition on a list of row indices or compound conditions
+ 193 const mc = condition;
+ 194
+ 195 // OR condition: [...]
+ 196 if (mc.length !== undefined) {
+ 197 return (mc.length === 0)?
+ 198 // empty OR is false:
+ 199 false :
+ 200 // else: OR is true if any sub-condition is met
+ 201 mc.some((cd:AndCondition) => resolveCondition(cd, row, r, colNumber, false));
+ 202 }
+ 203 // AND condition: {...}
+ 204 else {
+ 205 for (const name in condition) {
+ 206 let conditionMet = and; // initialize with false for OR, and true for AND conjunction
+ 207 const setCond = condition;
+ 208
+ 209 // resolve SetConditions:
+ 210 switch (name) {
+ 211 case 'or': conditionMet = resolveCondition(setCond.or, row, r, colNumber, false); break;
+ 212 case 'and': conditionMet = resolveCondition(setCond.and, row, r, colNumber, true); break;
+ 213 case 'not': conditionMet = !resolveCondition(setCond.not, row, r, colNumber, true); break;
+ 214 default: conditionMet = resolveTerminalCondition(name, condition[name], row, colNumber);
+ 215 }
+ 216 if (conditionMet) { orResult = true; if(!and) { break; }} // OR conjunction: exit for name loop if condition met
+ 217 else { andResult = false; if(and) { break; }} // AND conjunction: exit for name loop if condition not met
+ 218 }
+ 219 }
+ 220 } else {
+ 221 console.error(`unrecognized condition: ${JSON.stringify(condition)}`);
+ 222 return false;
+ 223 }
+ 224 return and? andResult : orResult;
+ 225}
+ 226
+ 227/**
+ 228 * filters a `Data` object for the given `Condition`s and returns a new `Data` object with those rows for which
+ 229 * `cond` holds true.
+ 230 * @param data the `Data` object to filter
+ 231 * @param cond the complex condition to test against
+ 232 * @return a new `Data` object with the filtered rows
+ 233 */
+ 234export function filter(data:Data, cond:Condition):Data {
+ 235 const colNumber = (name:string):number => data.colNumber(name);
+ 236 try {
+ 237 return new Data({
+ 238 name: data.getName(),
+ 239 colNames: data.colNames(),
+ 240 rows:data.getData().filter((row:DataRow, i:number) => {
+ 241 const keep = resolveCondition(cond, row, i, colNumber);
+ 242 return keep;
+ 243 })
+ 244 });
+ 245 } catch(err) {
+ 246 console.log(err);
+ 247 console.log(err.stack);
+ 248 }
+ 249}
+ 250
1export { NumRange,
+ 2 NumDomain,
+ 3 DateDomain,
+ 4 NameDomain,
+ 5 Domain,
+ 6 ColumnReference,
+ 7 DataVal,
+ 8 DataRow,
+ 9 DataSet
+ 10 } from './Data';
+ 11
+ 12export { Data } from './Data';
+ 13export { Condition} from './DataFilters';
+ 14
+ 15
1/**
+ 2 * # hsDatab
+ 3 *
+ 4 * Helpful Scripts framework-independent data management functions. [Github page](https://github.com/HelpfulScripts/hsDatab)
+ 5 *
+ 6 * **hsDatab** provides a JavaScript-based data management and query mechanism.
+ 7 * Data is managed in a simple in-memory database that holds data in rows of columns.
+ 8 * It autodetermines the types of data held in each column, along with the
+ 9 * domain range for each column of data.
+ 10 * Complex filters can be applied by defining {@link DataFilters `Condition`}s using a simple query object structure.
+ 11 *
+ 12 * ## Data Types
+ 13 * supported {@link Data.Data.type data types} include
+ 14 * - **number**: numeric values
+ 15 * - **name**: nominal values, represented by arbitrary words
+ 16 * - **date**: date values
+ 17 * - **currency**: Currently supported: '$dd[,ddd]'
+ 18 * - **percent**: 'd%'
+ 19 *
+ 20 * ## Data Class
+ 21 * The fundamental object in this library is {@link Data.Data `Data`},
+ 22 * a simple row-column based database object,
+ 23 * featuring named columns, sorting, mapping and filtering functions.
+ 24 *
+ 25 * ## Example
+ 26 *
+ 27 *
+ 28 * const colNames = ['Name', 'Value', 'Start', 'End'];
+ 29 * const rows = [
+ 30 * ['Harry', '100', '3/1/14', '11/20/14'],
+ 31 * ['Mary', '1500', '7/1/14', '9/30/14'],
+ 32 * ['Peter', '400', '5/20/14', '4/30/15'],
+ 33 * ['Jane', '700', '11/13/14', '8/15/15']
+ 34 * ]
+ 35 * const data = new hsdatab.Data({colNames:colNames, rows:rows});
+ 36 *
+ 37 * query = {Name:["Peter", "Jane"]};
+ 38 * const result = data.filter(query);
+ 39 *
+ 40 * m.mount(root, {
+ 41 * view:() => m('', [
+ 42 * m('h3', 'Given the data set:'),
+ 43 * m('pre',
+ 44 * m('table#data', [
+ 45 * m('tr', colNames.map(n => m('th', n))),
+ 46 * ...rows.map(row => m('tr', [
+ 47 * m('td', row[0]),
+ 48 * m('td', row[1]),
+ 49 * m('td', `${row[2].getMonth()+1}/${row[2].getDate()}/${row[2].getFullYear()}`),
+ 50 * m('td', `${row[3].getMonth()+1}/${row[3].getDate()}/${row[3].getFullYear()}`)
+ 51 * ]))
+ 52 * ])),
+ 53 * m('h3', 'The column types and domains are'),
+ 54 * m('pre', m('table',
+ 55 * m('tr', m('th', 'Column'), m('th', 'Type'), m('th', 'Domain')),
+ 56 * m('tr', m('td', '"Name":'), m('td', data.colType("Name")), m('td', data.findDomain("Name").join(', '))),
+ 57 * m('tr', m('td', '"Value":'), m('td', data.colType("Value")), m('td', data.findDomain("Value").join(' - '))),
+ 58 * m('tr', m('td', '"Start":'), m('td', data.colType("Start")), m('td', data.findDomain("Start").map(d => d.toDateString()).join(' - '))),
+ 59 * m('tr', m('td', '"Stop":'), m('td', data.colType("End")), m('td', data.findDomain("End").map(d => d.toDateString()).join(' - ')))
+ 60 * )),
+ 61 * m('h3', 'The query:'),
+ 62 * m('code', '{Name:["Peter", "Jane"]}'),
+ 63 * m('h3', 'yields results with "Name"'),
+ 64 * m('code', result.getColumn('Name').join(', '))
+ 65 * ])
+ 66 * });
+ 67 *
+ 68 *
+ 69 * $exampleID { height: 600px; }
+ 70 * #data th { width:15%; }
+ 71 * #data { font-size: 11pt; }
+ 72 *
+ 73 *
+ 74 */
+ 75
+ 76 /** */
+ 77
+ 78
+ 79