@kanaries/graphic-walker 0.2.11 → 0.2.12

package/src/utils/autoMark.ts

@@ -1,30 +1,30 @@
 import { ISemanticType } from "visual-insights";
 
 /**
- * 
+ *
  * @param semanticTypeList semanticTypeList.length <= 2，调用时，手动将columns 和 rows的最后一个元素组合传进来
  * @returns geom(mark) type
  */
 export function autoMark(semanticTypeList: ISemanticType[]): string {
     if (semanticTypeList.length < 2) {
-        if (semanticTypeList[0] === 'temporal') return 'tick'
-        return 'bar'
+        if (semanticTypeList[0] === "temporal") return "tick";
+        return "bar";
     }
     const couter: Map<ISemanticType, number> = new Map();
-    (['nominal', 'ordinal', 'quantitative', 'temporal'] as ISemanticType[]).forEach(s => {
-        couter.set(s, 0)
-    })
+    (["nominal", "ordinal", "quantitative", "temporal"] as ISemanticType[]).forEach((s) => {
+        couter.set(s, 0);
+    });
     for (let st of semanticTypeList) {
         couter.set(st, couter.get(st)! + 1);
     }
-    if (couter.get('nominal') === 1 || couter.get('ordinal') === 1) {
-        return 'bar'
+    if (couter.get("nominal") === 1 || couter.get("ordinal") === 1) {
+        return "bar";
     }
-    if (couter.get('temporal') === 1 && couter.get('quantitative') === 1) {
-        return 'line'
+    if (couter.get("temporal") === 1 && couter.get("quantitative") === 1) {
+        return "line";
     }
-    if (couter.get('quantitative') === 2) {
-        return 'point'
+    if (couter.get("quantitative") === 2) {
+        return "point";
     }
-    return 'point'
-}
+    return "point";
+}

package/src/utils/dataPrep.ts

@@ -0,0 +1,44 @@
+import { IRow } from "visual-insights";
+import { IMutField } from "../interfaces";
+
+function updateRowKeys(data: IRow[], keyEncodeList: {from: string; to: string}[]): IRow[] {
+    return data.map((row) => {
+        const newRow: IRow = {};
+        for (let k in keyEncodeList) {
+            const { from, to } = keyEncodeList[k];
+            newRow[to] = row[from];
+        }
+        return newRow;
+    });
+}
+
+/**
+ * parse column id(key) to a safe string
+ * @param metas 
+ */
+function parseColumnMetas (metas: IMutField[]) {
+    return metas.map((meta, i) => {
+        const safeKey = `gwc_${i}`;
+        return {
+            ...meta,
+            key: safeKey,
+            fid: safeKey,
+        };
+    });
+}
+
+export function guardDataKeys (data: IRow[], metas: IMutField[]): {
+    safeData: IRow[];
+    safeMetas: IMutField[];
+} {
+    const safeMetas = parseColumnMetas(metas)
+    const keyEncodeList = safeMetas.map((f, i) => ({
+        from: metas[i].fid,
+        to: f.fid
+    }));
+    const safeData = updateRowKeys(data, keyEncodeList);
+    return {
+        safeData,
+        safeMetas
+    }
+}

package/src/utils/index.ts

@@ -1,106 +1,110 @@
-import i18next from 'i18next';
-import { COUNT_FIELD_ID } from '../constants';
-import { IRow, Filters, IMutField } from '../interfaces';
+import i18next from "i18next";
+import { COUNT_FIELD_ID } from "../constants";
+import { IRow, Filters, IMutField } from "../interfaces";
 interface NRReturns {
     normalizedData: IRow[];
-    maxMeasures:IRow;
-    minMeasures:IRow;
-    totalMeasures:IRow
+    maxMeasures: IRow;
+    minMeasures: IRow;
+    totalMeasures: IRow;
 }
 function normalizeRecords(dataSource: IRow[], measures: string[]): NRReturns {
     const maxMeasures: IRow = {};
     const minMeasures: IRow = {};
     const totalMeasures: IRow = {};
-    measures.forEach(mea => {
+    measures.forEach((mea) => {
         maxMeasures[mea] = -Infinity;
         minMeasures[mea] = Infinity;
         totalMeasures[mea] = 0;
-    })
-    dataSource.forEach(record => {
-        measures.forEach(mea => {
-            maxMeasures[mea] = Math.max(record[mea], maxMeasures[mea])
-            minMeasures[mea] = Math.min(record[mea], minMeasures[mea])
-        })
-    })
+    });
+    dataSource.forEach((record) => {
+        measures.forEach((mea) => {
+            maxMeasures[mea] = Math.max(record[mea], maxMeasures[mea]);
+            minMeasures[mea] = Math.min(record[mea], minMeasures[mea]);
+        });
+    });
     const newData: IRow[] = [];
-    dataSource.forEach(record => {
-        const norRecord: IRow = { ... record };
-        measures.forEach(mea => {
+    dataSource.forEach((record) => {
+        const norRecord: IRow = { ...record };
+        measures.forEach((mea) => {
             totalMeasures[mea] += Math.abs(norRecord[mea]);
-        })
-        newData.push(norRecord)
-    })
-    newData.forEach(record => {
-        measures.forEach(mea => {
+        });
+        newData.push(norRecord);
+    });
+    newData.forEach((record) => {
+        measures.forEach((mea) => {
             record[mea] /= totalMeasures[mea];
-        })
-    })
+        });
+    });
     return {
         normalizedData: newData,
         maxMeasures,
         minMeasures,
-        totalMeasures
-    }
+        totalMeasures,
+    };
 }
 
 function normalize2PositiveRecords(dataSource: IRow[], measures: string[]): NRReturns {
-  const maxMeasures: IRow = {};
-  const minMeasures: IRow = {};
-  const totalMeasures: IRow = {};
-  measures.forEach((mea) => {
-    maxMeasures[mea] = -Infinity;
-    minMeasures[mea] = Infinity;
-    totalMeasures[mea] = 0;
-  });
-  dataSource.forEach((record) => {
+    const maxMeasures: IRow = {};
+    const minMeasures: IRow = {};
+    const totalMeasures: IRow = {};
     measures.forEach((mea) => {
-      maxMeasures[mea] = Math.max(record[mea], maxMeasures[mea]);
-      minMeasures[mea] = Math.min(record[mea], minMeasures[mea]);
+        maxMeasures[mea] = -Infinity;
+        minMeasures[mea] = Infinity;
+        totalMeasures[mea] = 0;
     });
-  });
-  const newData: IRow[] = [];
-  dataSource.forEach((record) => {
-    const norRecord: IRow = { ...record };
-    measures.forEach((mea) => {
-      norRecord[mea] = norRecord[mea] - minMeasures[mea]
-      totalMeasures[mea] += norRecord[mea];
+    dataSource.forEach((record) => {
+        measures.forEach((mea) => {
+            maxMeasures[mea] = Math.max(record[mea], maxMeasures[mea]);
+            minMeasures[mea] = Math.min(record[mea], minMeasures[mea]);
+        });
     });
-    newData.push(norRecord);
-  });
-  newData.forEach((record) => {
-    measures.forEach((mea) => {
-      record[mea] /= totalMeasures[mea];
-
+    const newData: IRow[] = [];
+    dataSource.forEach((record) => {
+        const norRecord: IRow = { ...record };
+        measures.forEach((mea) => {
+            norRecord[mea] = norRecord[mea] - minMeasures[mea];
+            totalMeasures[mea] += norRecord[mea];
+        });
+        newData.push(norRecord);
+    });
+    newData.forEach((record) => {
+        measures.forEach((mea) => {
+            record[mea] /= totalMeasures[mea];
+        });
     });
-  });
-  return {
-    normalizedData: newData,
-    maxMeasures,
-    minMeasures,
-    totalMeasures,
-  };
+    return {
+        normalizedData: newData,
+        maxMeasures,
+        minMeasures,
+        totalMeasures,
+    };
 }
 
-export function checkMajorFactor(data: IRow[], childrenData: Map<any, IRow[]>, dimensions: string[], measures: string[]): { majorKey: string; majorSum: number } {
+export function checkMajorFactor(
+    data: IRow[],
+    childrenData: Map<any, IRow[]>,
+    dimensions: string[],
+    measures: string[]
+): { majorKey: string; majorSum: number } {
     const { normalizedData, maxMeasures, minMeasures, totalMeasures } = normalizeRecords(data, measures);
     let majorSum = Infinity;
-    let majorKey = '';
+    let majorKey = "";
     for (let [key, childData] of childrenData) {
         let sum = 0;
-        for (let record of normalizedData ) {
-            let target = childData.find(childRecord => {
-                return dimensions.every(dim => record[dim] === childRecord[dim])
-            })
+        for (let record of normalizedData) {
+            let target = childData.find((childRecord) => {
+                return dimensions.every((dim) => record[dim] === childRecord[dim]);
+            });
             if (target) {
-                measures.forEach(mea => {
-                    let targetValue = (typeof target![mea] === 'number' && !isNaN(target![mea])) ? target![mea] : 0;
-                    targetValue = (targetValue) / totalMeasures[mea]
-                    sum += Math.abs(record[mea] - targetValue)
-                })
+                measures.forEach((mea) => {
+                    let targetValue = typeof target![mea] === "number" && !isNaN(target![mea]) ? target![mea] : 0;
+                    targetValue = targetValue / totalMeasures[mea];
+                    sum += Math.abs(record[mea] - targetValue);
+                });
             } else {
-                measures.forEach(mea => {
+                measures.forEach((mea) => {
                     sum += Math.abs(record[mea]);
-                })
+                });
             }
         }
         if (sum < majorSum) {
@@ -108,32 +112,37 @@ export function checkMajorFactor(data: IRow[], childrenData: Map<any, IRow[]>, d
             majorKey = key;
         }
     }
-    majorSum /= (measures.length * 2);
+    majorSum /= measures.length * 2;
     return { majorKey, majorSum };
 }
 
-export function checkChildOutlier(data: IRow[], childrenData: Map<any, IRow[]>, dimensions: string[], measures: string[]): { outlierKey: string; outlierSum: number } {
+export function checkChildOutlier(
+    data: IRow[],
+    childrenData: Map<any, IRow[]>,
+    dimensions: string[],
+    measures: string[]
+): { outlierKey: string; outlierSum: number } {
     // const { normalizedData, maxMeasures, minMeasures, totalMeasures } = normalize2PositiveRecords(data, measures);
     const { normalizedData, maxMeasures, minMeasures, totalMeasures } = normalizeRecords(data, measures);
     let outlierSum = -Infinity;
-    let outlierKey = '';
+    let outlierKey = "";
     for (let [key, childData] of childrenData) {
         // const { normalizedData: normalizedChildData } = normalize2PositiveRecords(childData, measures);
         const { normalizedData: normalizedChildData } = normalizeRecords(childData, measures);
         let sum = 0;
-        for (let record of normalizedData ) {
-            let target = normalizedChildData.find(childRecord => {
-                return dimensions.every(dim => record[dim] === childRecord[dim])
-            })
+        for (let record of normalizedData) {
+            let target = normalizedChildData.find((childRecord) => {
+                return dimensions.every((dim) => record[dim] === childRecord[dim]);
+            });
             if (target) {
-                measures.forEach(mea => {
-                    let targetValue = (typeof target![mea] === 'number' && !isNaN(target![mea])) ? target![mea] : 0;
-                    sum += Math.abs(record[mea] - targetValue)
-                })
+                measures.forEach((mea) => {
+                    let targetValue = typeof target![mea] === "number" && !isNaN(target![mea]) ? target![mea] : 0;
+                    sum += Math.abs(record[mea] - targetValue);
+                });
             } else {
-                measures.forEach(mea => {
+                measures.forEach((mea) => {
                     sum += Math.abs(record[mea]);
-                })
+                });
             }
         }
         if (sum > outlierSum) {
@@ -141,55 +150,55 @@ export function checkChildOutlier(data: IRow[], childrenData: Map<any, IRow[]>,
             outlierKey = key;
         }
     }
-    outlierSum /= (measures.length * 2);
+    outlierSum /= measures.length * 2;
     return { outlierKey, outlierSum };
 }
 export interface IPredicate {
     key: string;
-    type: 'discrete' | 'continuous';
+    type: "discrete" | "continuous";
     range: Set<any> | [number, number];
 }
 export function getPredicates(selection: IRow[], dimensions: string[], measures: string[]): IPredicate[] {
     const predicates: IPredicate[] = [];
-    dimensions.forEach(dim => {
+    dimensions.forEach((dim) => {
         predicates.push({
             key: dim,
-            type: 'discrete',
-            range: new Set()
-        })
-    })
-    measures.forEach(mea => {
+            type: "discrete",
+            range: new Set(),
+        });
+    });
+    measures.forEach((mea) => {
         predicates.push({
             key: mea,
-            type: 'continuous',
-            range: [Infinity, -Infinity]
-        })
-    })
-    selection.forEach(record => {
+            type: "continuous",
+            range: [Infinity, -Infinity],
+        });
+    });
+    selection.forEach((record) => {
         dimensions.forEach((dim, index) => {
-            (predicates[index].range as Set<any>).add(record[dim])
-        })
+            (predicates[index].range as Set<any>).add(record[dim]);
+        });
         measures.forEach((mea, index) => {
             (predicates[index].range as [number, number])[0] = Math.min(
-              (predicates[index].range as [number, number])[0],
-              record[mea]
+                (predicates[index].range as [number, number])[0],
+                record[mea]
             );
             (predicates[index].range as [number, number])[1] = Math.max(
-              (predicates[index].range as [number, number])[1],
-              record[mea]
+                (predicates[index].range as [number, number])[1],
+                record[mea]
             );
-        })
-    })
+        });
+    });
     return predicates;
 }
 
 export function getPredicatesFromVegaSignals(signals: Filters, dimensions: string[], measures: string[]): IPredicate[] {
     const predicates: IPredicate[] = [];
-    dimensions.forEach(dim => {
+    dimensions.forEach((dim) => {
         predicates.push({
-            type: 'discrete',
+            type: "discrete",
             range: new Set(signals[dim]),
-            key: dim
+            key: dim,
         });
     });
     return predicates;
@@ -197,16 +206,16 @@ export function getPredicatesFromVegaSignals(signals: Filters, dimensions: strin
 
 export function filterByPredicates(data: IRow[], predicates: IPredicate[]): IRow[] {
     const filterData = data.filter((record) => {
-      return predicates.every((pre) => {
-        if (pre.type === 'continuous') {
-          return (
-            record[pre.key] >= (pre.range as [number, number])[0] &&
-            record[pre.key] <= (pre.range as [number, number])[1]
-          );
-        } else {
-          return (pre.range as Set<any>).has(record[pre.key]);
-        }
-      });
+        return predicates.every((pre) => {
+            if (pre.type === "continuous") {
+                return (
+                    record[pre.key] >= (pre.range as [number, number])[0] &&
+                    record[pre.key] <= (pre.range as [number, number])[1]
+                );
+            } else {
+                return (pre.range as Set<any>).has(record[pre.key]);
+            }
+        });
     });
     return filterData;
 }
@@ -227,22 +236,25 @@ export function applyFilters(dataSource: IRow[], filters: Filters): IRow[] {
     });
 }
 
-export function extendCountField (dataSource: IRow[], fields: IMutField[]): {
+export function extendCountField(
+    dataSource: IRow[],
+    fields: IMutField[]
+): {
     dataSource: IRow[];
     fields: IMutField[];
 } {
-    const nextData = dataSource.map(r => ({
+    const nextData = dataSource.map((r) => ({
         ...r,
-        [COUNT_FIELD_ID]: 1
-    }))
+        [COUNT_FIELD_ID]: 1,
+    }));
     const nextFields = fields.concat({
         fid: COUNT_FIELD_ID,
-        name: i18next.t('constant.row_count'),
-        analyticType: 'measure',
-        semanticType: 'quantitative'
-    })
+        name: i18next.t("constant.row_count"),
+        analyticType: "measure",
+        semanticType: "quantitative",
+    });
     return {
         dataSource: nextData,
-        fields: nextFields
-    }
-}
+        fields: nextFields,
+    };
+}

package/src/utils/normalization.ts

@@ -1,4 +1,4 @@
-import { IRow } from '../interfaces';
+import { IRow } from "../interfaces";
 
 export function normalizeWithParent(
     data: IRow[],
@@ -11,69 +11,72 @@ export function normalizeWithParent(
 } {
     const totalMeasuresOfParent: IRow = {};
     const totalMeasures: IRow = {};
-    measures.forEach(mea => {
+    measures.forEach((mea) => {
         totalMeasuresOfParent[mea] = 0;
         totalMeasures[mea] = 0;
-    })
-    parentData.forEach(record => {
-        measures.forEach(mea => {
-            totalMeasuresOfParent[mea] += Math.abs(record[mea])
-        })
-    })
-    data.forEach(record => {
-        measures.forEach(mea => {
+    });
+    parentData.forEach((record) => {
+        measures.forEach((mea) => {
+            totalMeasuresOfParent[mea] += Math.abs(record[mea]);
+        });
+    });
+    data.forEach((record) => {
+        measures.forEach((mea) => {
             totalMeasures[mea] += Math.abs(record[mea]);
-        })
-    })
+        });
+    });
     const normalizedParentData: IRow[] = [];
-    parentData.forEach(record => {
+    parentData.forEach((record) => {
         const newRecord = { ...record };
-        measures.forEach(mea => {
+        measures.forEach((mea) => {
             newRecord[mea] /= totalMeasuresOfParent[mea];
-        })
+        });
         normalizedParentData.push(newRecord);
-    })
+    });
     const normalizedData: IRow[] = [];
-    data.forEach(record => {
+    data.forEach((record) => {
         const newRecord = { ...record };
-        measures.forEach(mea => {
+        measures.forEach((mea) => {
             if (syncScale) {
                 newRecord[mea] /= totalMeasuresOfParent[mea];
             } else {
-                newRecord[mea] /= totalMeasures[mea]
+                newRecord[mea] /= totalMeasures[mea];
             }
-        })
+        });
         normalizedData.push(newRecord);
-    })
+    });
     return {
         normalizedData,
-        normalizedParentData
+        normalizedParentData,
     };
 }
 
-export function compareDistribution (distribution1: IRow[], distribution2: IRow[], dimensions: string[], measures: string[]): number {
+export function compareDistribution(
+    distribution1: IRow[],
+    distribution2: IRow[],
+    dimensions: string[],
+    measures: string[]
+): number {
     let score = 0;
     let count = 0;
     const tagsForD2: boolean[] = distribution2.map(() => false);
     for (let record of distribution1) {
         let targetRecordIndex = distribution2.findIndex((r, i) => {
-            return !tagsForD2[i] && dimensions.every(dim => r[dim] === record[dim])
-        })
+            return !tagsForD2[i] && dimensions.every((dim) => r[dim] === record[dim]);
+        });
         if (targetRecordIndex > -1) {
             tagsForD2[targetRecordIndex] = true;
             const targetRecord = distribution2[targetRecordIndex];
             for (let mea of measures) {
-                
                 score = Math.max(
                     score,
-                    Math.max(targetRecord[mea], record[mea]) /
-                        Math.min(targetRecord[mea], record[mea])
+                    Math.max(targetRecord[mea], record[mea]) / Math.min(targetRecord[mea], record[mea])
                 );
                 count++;
             }
         } else {
             for (let mea of measures) {
-                score = Math.max(score, record[mea])
+                score = Math.max(score, record[mea]);
                 count++;
             }
         }
@@ -90,31 +93,36 @@ export function compareDistribution (distribution1: IRow[], distribution2: IRow[
     return score;
 }
 
-export function normalizeByMeasures (dataSource: IRow[], measures: string[]) {
+export function normalizeByMeasures(dataSource: IRow[], measures: string[]) {
     let sums: Map<string, number> = new Map();
 
-    measures.forEach(mea => {
+    measures.forEach((mea) => {
         sums.set(mea, 0);
-    })
+    });
 
-    dataSource.forEach(record => {
-        measures.forEach(mea => {
+    dataSource.forEach((record) => {
+        measures.forEach((mea) => {
             sums.set(mea, sums.get(mea)! + Math.abs(record[mea]));
-        })
-    })
+        });
+    });
 
     const ans: IRow[] = [];
-    dataSource.forEach(record => {
+    dataSource.forEach((record) => {
         const norRecord: IRow = { ...record };
-        measures.forEach(mea => {
+        measures.forEach((mea) => {
             norRecord[mea] /= sums.get(mea)!;
-        })
+        });
         ans.push(norRecord);
     });
     return ans;
 }
 
-export function getDistributionDifference(dataSource: IRow[], dimensions: string[], measure1: string, measure2: string): number {
+export function getDistributionDifference(
+    dataSource: IRow[],
+    dimensions: string[],
+    measure1: string,
+    measure2: string
+): number {
     let score = 0;
     for (let record of dataSource) {
         if (record[measure1] === 0 || record[measure2] === 0) continue;
@@ -123,7 +131,7 @@ export function getDistributionDifference(dataSource: IRow[], dimensions: string
     return score;
 }
 
-export function makeBinField (dataSource: IRow[], fid: string, binFid: string, binSize: number | undefined = 10) {
+export function makeBinField(dataSource: IRow[], fid: string, binFid: string, binSize: number | undefined = 10) {
     let _min = Infinity;
     let _max = -Infinity;
     for (let i = 0; i < dataSource.length; i++) {
@@ -132,21 +140,21 @@ export function makeBinField (dataSource: IRow[], fid: string, binFid: string, b
         if (val < _min) _min = val;
     }
     const step = (_max - _min) / binSize;
-    return dataSource.map(r => {
+    return dataSource.map((r) => {
         let bIndex = Math.floor((r[fid] - _min) / step);
         if (bIndex === binSize) bIndex = binSize - 1;
         return {
             ...r,
-            [binFid]: bIndex * step + _min
-        }
-    })
+            [binFid]: bIndex * step + _min,
+        };
+    });
 }
 
-export function makeLogField (dataSource: IRow[], fid: string, logFid: string) {
-    return dataSource.map(r => {
+export function makeLogField(dataSource: IRow[], fid: string, logFid: string) {
+    return dataSource.map((r) => {
         return {
             ...r,
-            [logFid]: (typeof r[fid] === 'number' && r[fid] > 0) ? Math.log10(r[fid]) : null
-        }
-    })
-}
+            [logFid]: typeof r[fid] === "number" && r[fid] > 0 ? Math.log10(r[fid]) : null,
+        };
+    });
+}