@kanaries/graphic-walker 0.2.15 → 0.2.17

package/src/lib/execExp.ts

@@ -0,0 +1,147 @@
+import { IExpParamter, IExpression, IField, IRow } from "../interfaces";
+
+interface IDataFrame {
+    [key: string]: any[];
+}
+
+export function execExpression (exp: IExpression, dataFrame: IDataFrame, columns: IField[]): IDataFrame {
+    const { op, params } = exp;
+    const subFrame: IDataFrame = { ...dataFrame };
+    const len = dataFrame[Object.keys(dataFrame)[0]].length;
+    for (let param of params) {
+        switch (param.type) {
+            case 'field':
+                subFrame[param.value] = dataFrame[param.value];
+                break;
+            case 'constant':
+                subFrame[param.value] = new Array(len).fill(param.value);
+                break;
+            case 'expression':
+                let f = execExpression(param.value, dataFrame, columns);
+                Object.keys(f).forEach(key => {
+                    subFrame[key] = f[key];
+                })
+                break;
+            case 'value':
+            default:
+                break;
+        }
+    }
+    switch (op) {
+        case 'one':
+            return one(exp.as, params, subFrame);
+        case 'bin':
+            return bin(exp.as, params, subFrame);
+        case 'log2':
+            return log2(exp.as, params, subFrame);
+        case 'log10':
+            return log10(exp.as, params, subFrame);
+        case 'binCount':
+            return binCount(exp.as, params, subFrame);
+        default:
+            return subFrame;
+    }
+}
+
+function bin(resKey: string, params: IExpParamter[], data: IDataFrame, binSize: number | undefined = 10): IDataFrame {
+    const { value: fieldKey } = params[0];
+    const fieldValues = data[fieldKey] as number[];
+    let _min = Infinity;
+    let _max = -Infinity;
+    for (let i = 0; i < fieldValues.length; i++) {
+        let val = fieldValues[i];
+        if (val > _max) _max = val;
+        if (val < _min) _min = val;
+    }
+    const step = (_max - _min) / binSize;
+    const beaStep = Math.max(-Math.round(Math.log10(_max - _min)) + 2, 0)
+    const newValues = fieldValues.map((v: number) => {
+        let bIndex = Math.floor((v - _min) / step);
+        if (bIndex === binSize) bIndex = binSize - 1;
+        return Number(((bIndex * step + _min)).toFixed(beaStep))
+    });
+    return {
+        ...data,
+        [resKey]: newValues,
+    }
+}
+
+function binCount(resKey: string, params: IExpParamter[], data: IDataFrame, binSize: number | undefined = 10): IDataFrame {
+    const { value: fieldKey } = params[0];
+    const fieldValues = data[fieldKey] as number[];
+
+    const valueWithIndices: {val: number; index: number; orderIndex: number }[] = fieldValues.map((v, i) => ({
+        val: v,
+        index: i
+    })).sort((a, b) => a.val - b.val)
+        .map((item, i) => ({
+            val: item.val,
+            index: item.index,
+            orderIndex: i
+        }))
+
+    const groupSize = valueWithIndices.length / binSize;
+
+    const newValues = valueWithIndices.map(item => {
+        let bIndex = Math.floor(item.orderIndex / groupSize);
+        if (bIndex === binSize) bIndex = binSize - 1;
+        return bIndex + 1
+    })
+    return {
+        ...data,
+        [resKey]: newValues,
+    }
+}
+
+function log2(resKey: string, params: IExpParamter[], data: IDataFrame): IDataFrame {
+    const { value } = params[0];
+    const field = data[value];
+    const newField = field.map((v: number) => Math.log2(v));
+    return {
+        ...data,
+        [resKey]: newField,
+    }
+}
+
+function log10(resKey: string, params: IExpParamter[], data: IDataFrame): IDataFrame {
+    const { value: fieldKey } = params[0];
+    const fieldValues = data[fieldKey];
+    const newField = fieldValues.map((v: number) => Math.log10(v));
+    return {
+        ...data,
+        [resKey]: newField,
+    }
+}
+
+function one(resKey: string, params: IExpParamter[], data: IDataFrame): IDataFrame {
+    // const { value: fieldKey } = params[0];
+    if (Object.keys(data).length === 0) return data;
+    const len = data[Object.keys(data)[0]].length;
+    const newField = new Array(len).fill(1);
+    return {
+        ...data,
+        [resKey]: newField,
+    }
+}
+
+export function dataset2DataFrame(dataset: IRow[], columns: IField[]): IDataFrame {
+    const dataFrame: IDataFrame = {};
+    columns.forEach((col) => {
+        dataFrame[col.fid] = dataset.map((row) => row[col.fid]);
+    });
+    return dataFrame;
+}
+
+export function dataframe2Dataset(dataFrame: IDataFrame, columns: IField[]): IRow[] {
+    if (columns.length === 0) return [];
+    const dataset: IRow[] = [];
+    const len = dataFrame[Object.keys(dataFrame)[0]].length;
+    for (let i = 0; i < len; i++) {
+        const row: IRow = {};
+        columns.forEach((col) => {
+            row[col.fid] = dataFrame[col.fid][i];
+        });
+        dataset.push(row);
+    }
+    return dataset;
+}

package/src/lib/inferMeta.ts

@@ -1,5 +1,4 @@
-import { IAnalyticType, ISemanticType, UnivariateSummary } from "visual-insights";
-import { IMutField, IRow, IUncertainMutField } from "../interfaces";
+import { IAnalyticType, IMutField, IRow, ISemanticType, IUncertainMutField } from '../interfaces';
 
 const COMMON_TIME_FORMAT: RegExp[] = [
     /^\d{4}-\d{2}-\d{2}$/, // YYYY-MM-DD
@@ -8,13 +7,13 @@ const COMMON_TIME_FORMAT: RegExp[] = [
     /^\d{4}\/\d{2}\/\d{2}$/, // YYYY/MM/DD
     /^\d{4}\.\d{2}\.\d{2}$/, // YYYY.MM.DD
     /^\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}$/, // YYYY-MM-DD HH:MM:SS
-    /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$/ // YYYY-MM-DDTHH:MM:SS (ISO-8601)
+    /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$/, // YYYY-MM-DDTHH:MM:SS (ISO-8601)
 ];
 
 /**
  * check if this array is a date time array based on some common date format
  * @param data string array
- * @returns 
+ * @returns
  */
 export function isDateTimeArray(data: string[]): boolean {
     let isDateTime = true;
@@ -34,6 +33,19 @@ export function isDateTimeArray(data: string[]): boolean {
     return isDateTime;
 }
 
+export function isNumericArray(data: any[]): boolean {
+    return data.every((item) => {
+        // Check if the item is already a number
+        if (typeof item === 'number') {
+            return true;
+        }
+
+        // Check if the item can be converted into a number
+        const number = parseFloat(item);
+        return !isNaN(number) && isFinite(item);
+    });
+}
+
 function inferAnalyticTypeFromSemanticType(semanticType: ISemanticType): IAnalyticType {
     switch (semanticType) {
         case 'quantitative':
@@ -43,37 +55,22 @@ function inferAnalyticTypeFromSemanticType(semanticType: ISemanticType): IAnalyt
     }
 }
 
-/**
- * 这里目前暂时包一层，是为了解耦具体的推断实现。后续这里要调整推断的逻辑。
- * 需要讨论这一层是否和交互层有关，如果没有关系，这一层包裹可以不存在这里，而是在visual-insights中。
- * @param data 原始数据
- * @param fid 字段id
- * @returns semantic type 列表
- */
 export function inferSemanticType(data: IRow[], fid: string): ISemanticType {
-    let st = UnivariateSummary.getFieldType(data, fid);
+    const values = data.map((row) => row[fid]);
+
+    let st: ISemanticType = isNumericArray(values) ? 'quantitative' : 'nominal';
     if (st === 'nominal') {
         if (isDateTimeArray(data.map((row) => `${row[fid]}`))) st = 'temporal';
-    } else if (st === 'ordinal') {
-        const valueSet: Set<number> = new Set();
-        let _max = -Infinity;
-        let _min = Infinity;
-        for (let v of valueSet) {
-            _max = Math.max(_max, v);
-            _min = Math.max(_min, v);
-        }
-        if (_max - _min + 1 !== valueSet.size) {
-            st = 'quantitative';
-        }
     }
     return st;
 }
 
-export function inferMeta (props: { dataSource: IRow[]; fields: IUncertainMutField[] }): IMutField[] {
+export function inferMeta(props: { dataSource: IRow[]; fields: IUncertainMutField[] }): IMutField[] {
     const { dataSource, fields } = props;
-    const finalFieldMetas: IMutField[] = []
+    const finalFieldMetas: IMutField[] = [];
     for (let field of fields) {
-        let semanticType: ISemanticType = field.semanticType === '?' ? inferSemanticType(dataSource, field.fid) : field.semanticType;
+        let semanticType: ISemanticType =
+            field.semanticType === '?' ? inferSemanticType(dataSource, field.fid) : field.semanticType;
         let analyticType: IAnalyticType = inferAnalyticTypeFromSemanticType(semanticType);
 
         finalFieldMetas.push({
@@ -82,7 +79,7 @@ export function inferMeta (props: { dataSource: IRow[]; fields: IUncertainMutFie
             name: field.name ? field.name : field.fid,
             analyticType,
             semanticType,
-        })
+        });
     }
-    return finalFieldMetas
-}
+    return finalFieldMetas;
+}

package/src/lib/insights/explainByChildren.ts

@@ -0,0 +1,50 @@
+import { IMeasure, IRow } from '../../interfaces';
+import { IPredicate, checkChildOutlier, checkMajorFactor, filterByPredicates } from '../../utils';
+import { aggregate } from '../op/aggregate';
+
+export function explainByChildren(
+    dataSource: IRow[],
+    predicates: IPredicate[],
+    dimensions: string[],
+    measures: IMeasure[]
+) {
+    // 1. find most relative dimensions(topK)
+    // 2. for each dimension, we check all the dim member in it. find the member whos distribution is most close to current one.
+    // here we do not nomorlize all the dim member's distribution, we use the relative distribution instead.
+    // 3. the dim member we found can be used to explain current one as major factor.
+    // const predicates: IPredicate[] = selection === 'all' ? [] : getPredicates(selection, dimensions, []);
+    const viewData = aggregate(dataSource, {
+        groupBy: dimensions,
+        op: 'aggregate',
+        agg: Object.fromEntries(measures.map((mea) => [mea.key, mea.op])),
+    });
+    const measureIds = measures.map((m) => m.key);
+    const parentData = filterByPredicates(viewData, predicates);
+
+    const majorList: Array<{ key: string; score: number; dimensions: string[]; measures: IMeasure[] }> = [];
+    const outlierList: Array<{ key: string; score: number; dimensions: string[]; measures: IMeasure[] }> = [];
+    for (let extendDim of dimensions) {
+        const data = aggregate(dataSource, {
+            groupBy: dimensions.concat(extendDim),
+            op: 'aggregate',
+            agg: Object.fromEntries(measures.map((mea) => [mea.key, mea.op])),
+        });
+        let groups: Map<any, IRow[]> = new Map();
+        for (let record of data) {
+            if (!groups.has(record[extendDim])) {
+                groups.set(record[extendDim], []);
+            }
+            groups.get(record[extendDim])?.push(record);
+        }
+        const { majorKey, majorSum } = checkMajorFactor(parentData, groups, dimensions, measureIds);
+        majorList.push({ key: majorKey, score: majorSum, dimensions: [extendDim], measures });
+        const { outlierKey, outlierSum } = checkChildOutlier(parentData, groups, dimensions, measureIds);
+        outlierList.push({ key: outlierKey, score: outlierSum, dimensions: [extendDim], measures });
+    }
+    majorList.sort((a, b) => a.score - b.score);
+    outlierList.sort((a, b) => b.score - a.score);
+    return {
+        majorList,
+        outlierList,
+    };
+}

package/src/lib/insights/explainBySelection.ts

@@ -0,0 +1,47 @@
+import { IExplainProps, IField } from '../../interfaces';
+import { filterByPredicates } from '../../utils';
+import { compareDistribution, normalizeWithParent } from '../../utils/normalization';
+import { aggregate } from '../op/aggregate';
+import { complementaryFields, groupByAnalyticTypes, meaList2AggProps } from './utils';
+
+export function explainBySelection(props: IExplainProps) {
+    const { metas, dataSource, viewFields, predicates } = props;
+    const { dimensions: dimsInView, measures: measInView } = groupByAnalyticTypes(viewFields);
+    const complementaryDimensions = complementaryFields({
+        all: metas.filter((f) => f.analyticType === 'dimension'),
+        selection: dimsInView,
+    });
+    const outlierList: Array<{ score: number; viiewFields: IField[] }> = complementaryDimensions.map(extendDim => {
+        const overallData = aggregate(dataSource, {
+            groupBy: [extendDim.fid],
+            op: 'aggregate',
+            agg: meaList2AggProps(measInView),
+        });
+        const viewData = aggregate(dataSource, {
+            groupBy: dimsInView.map((f) => f.fid),
+            op: 'aggregate',
+            agg: meaList2AggProps(measInView),
+        });
+        const subData = filterByPredicates(viewData, predicates);
+
+        let outlierNormalization = normalizeWithParent(
+            subData,
+            overallData,
+            measInView.map((mea) => mea.fid),
+            false
+        );
+
+        let outlierScore = compareDistribution(
+            outlierNormalization.normalizedData,
+            outlierNormalization.normalizedParentData,
+            [extendDim.fid],
+            measInView.map((mea) => mea.fid)
+        );
+        return {
+            viiewFields: measInView.concat(extendDim),
+            score: outlierScore,
+        }
+    }).sort((a, b) => b.score - a.score)
+ 
+    return outlierList;
+}

package/src/lib/insights/explainValue.ts

@@ -0,0 +1,30 @@
+import { IAggregator, IExplainProps } from '../../interfaces';
+import { filterByPredicates } from '../../utils';
+import { aggregate } from '../op/aggregate';
+import { complementaryFields, groupByAnalyticTypes } from './utils';
+
+export function explainValue(props: IExplainProps): number[] {
+    const { viewFields, dataSource, predicates } = props;
+    const { dimensions: dimsInView, measures: measInView } = groupByAnalyticTypes(viewFields);
+    const viewData = aggregate(dataSource, {
+        groupBy: dimsInView.map((f) => f.fid),
+        op: 'aggregate',
+        agg: Object.fromEntries(measInView.map((mea) => [mea.fid, (mea.aggName ?? 'sum') as IAggregator])),
+    });
+    const selection = filterByPredicates(viewData, predicates);
+    const cmps: number[] = [];
+    for (let mea of measInView) {
+        const values = viewData.map((r) => r[mea.fid]).sort((a, b) => a - b);
+        const selectionValues = selection.map((r) => r[mea.fid]);
+        const lowerBoundary: number = values[Math.floor(values.length * 0.15)];
+        const higherBoundary: number = values[Math.min(Math.ceil(values.length * 0.85), values.length - 1)];
+        if (selectionValues.some((v) => v >= higherBoundary)) {
+            cmps.push(1);
+        } else if (selectionValues.some((v) => v <= lowerBoundary)) {
+            cmps.push(-1);
+        } else {
+            cmps.push(0);
+        }
+    }
+    return cmps;
+}

package/src/lib/insights/utils.ts

@@ -0,0 +1,21 @@
+import { IAggregator, IField } from '../../interfaces';
+import { IAggQuery } from '../interfaces';
+
+export function groupByAnalyticTypes(fields: IField[]) {
+    const dimensions = fields.filter((f) => f.analyticType === 'dimension');
+    const measures = fields.filter((f) => f.analyticType === 'measure');
+    return {
+        dimensions,
+        measures,
+    };
+}
+
+export function meaList2AggProps(measures: IField[]): IAggQuery['agg'] {
+    return Object.fromEntries(measures.map((mea) => [mea.fid, (mea.aggName ?? 'sum') as IAggregator]));
+}
+
+export function complementaryFields(props: { selection: IField[]; all: IField[] }): IField[] {
+    return props.all
+        .filter((f) => f.analyticType === 'dimension')
+        .filter((f) => !props.selection.find((vf) => vf.fid === f.fid));
+}

package/src/lib/interfaces.ts

@@ -0,0 +1,33 @@
+import { IAggregator } from "../interfaces";
+
+export interface IAggQuery {
+    op: 'aggregate';
+    groupBy: string[];
+    agg: {
+        [field: string]: IAggregator;
+    };
+}
+
+// interface IFilterQuery {
+//     op: 'filter';
+//     filter: string;
+// }
+
+export interface IFoldQuery {
+    op: 'fold';
+    foldBy: string[];
+    newFoldKeyCol: string;
+    newFoldValueCol: string;
+}
+
+export interface IBinQuery {
+    op: 'bin';
+    binBy: string;
+    newBinCol: string;
+    binSize: number;
+}
+
+
+export interface IRawQuery {
+    op: 'raw';
+}

package/src/lib/op/aggregate.ts

@@ -0,0 +1,49 @@
+import { IRow } from "../../interfaces";
+import { IAggQuery } from "../interfaces";
+import { sum, mean, median, stdev, variance, max, min, count } from "./stat";
+
+const aggregatorMap = {
+    sum,
+    mean,
+    median,
+    stdev,
+    variance,
+    max,
+    min,
+    count,
+};
+
+const KEY_JOINER = '___';
+
+export function aggregate (data: IRow[], query: IAggQuery): IRow[] {
+    const { groupBy, agg } = query;
+    const ans: Map<string, IRow> = new Map();
+    const groups: Map<string, IRow[]> = new Map();
+    for (let row of data) {
+        const gk = groupBy.map((k) => row[k]).join(KEY_JOINER);
+
+        if (!groups.has(gk)) {
+            groups.set(gk, []);
+        }
+        groups.get(gk)?.push(row);
+    }
+    for (let [gk, subGroup] of groups) {
+        if (subGroup.length === 0) {
+            continue;
+        }
+        let aggRow: IRow = {};
+        for (let k of groupBy) {
+            aggRow[k] = subGroup[0][k];
+        }
+        for (let meaKey in agg) {
+            if (aggRow[meaKey] === undefined) {
+                aggRow[meaKey] = 0;
+            }
+            const values: number[] = subGroup.map((r) => r[meaKey]) ?? [];
+            const aggregator = aggregatorMap[agg[meaKey]] ?? sum;
+            aggRow[meaKey] = aggregator(values);
+        }
+        ans.set(gk, aggRow);
+    }
+    return Array.from(ans.values());
+}

package/src/lib/op/bin.ts

@@ -0,0 +1,25 @@
+import { IRow } from "../../interfaces";
+import { IBinQuery } from "../interfaces";
+
+export function bin (dataSource: IRow[], query: IBinQuery): IRow[] {
+    const { binBy, newBinCol, binSize } = query;
+    let _min = Infinity;
+    let _max = -Infinity;
+    for (let i = 0; i < dataSource.length; i++) {
+        let val = dataSource[i][binBy];
+        if (val > _max) _max = val;
+        if (val < _min) _min = val;
+    }
+    const step = (_max - _min) / binSize;
+    // const beaStep = Math.max(-Math.round(Math.log10(_max - _min)) + 2, 0)
+    return dataSource.map((r) => {
+        let bIndex = Math.floor((r[binBy] - _min) / step);
+        if (bIndex === binSize) bIndex = binSize - 1;
+        return {
+            ...r,
+            [newBinCol]: [bIndex * step + _min, (bIndex + 1) * step + _min],
+            
+            // [binFid]: Number(((bIndex * step + _min)).toFixed(beaStep)),
+        };
+    });
+}

package/src/lib/op/fold.ts

@@ -0,0 +1,17 @@
+import { IRow } from "../../interfaces";
+import { IFoldQuery } from "../interfaces";
+
+export function fold (data: IRow[], query: IFoldQuery): IRow[] {
+    const { foldBy, newFoldKeyCol, newFoldValueCol } = query;
+    const ans: IRow[] = [];
+    for (let row of data) {
+        for (let k of foldBy) {
+            const newRow = { ...row };
+            newRow[newFoldKeyCol] = k;
+            newRow[newFoldValueCol] = row[k];
+            delete newRow[k];
+            ans.push(newRow);
+        }
+    }
+    return ans;
+}

package/src/lib/op/stat.ts

@@ -0,0 +1,46 @@
+export function mean(nums: number[]): number {
+    return nums.reduce((a, b) => a + b, 0) / nums.length;
+}
+
+export function sum(nums: number[]): number {
+    return nums.reduce((a, b) => a + b, 0);
+}
+
+export function median(nums: number[]): number {
+    const sorted = nums.sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted.length % 2 === 0 ? (sorted[mid] + sorted[mid - 1]) / 2 : sorted[mid];
+}
+
+export function variance(nums: number[]): number {
+    const m = mean(nums);
+    return mean(nums.map((x) => (x - m) ** 2));
+}
+
+export function stdev(nums: number[]): number {
+    return Math.sqrt(variance(nums));
+}
+
+export function max(nums: number[]): number {
+    let ans = -Infinity;
+    for (let n of nums) {
+        if (n > ans) {
+            ans = n;
+        }
+    }
+    return ans;
+}
+
+export function min(nums: number[]): number {
+    let ans = Infinity;
+    for (let n of nums) {
+        if (n < ans) {
+            ans = n;
+        }
+    }
+    return ans;
+}
+
+export function count(nums: number[]): number {
+    return nums.length;
+}

package/src/lib/viewQuery.ts

@@ -0,0 +1,22 @@
+import { IMutField, IRow } from "../interfaces";
+import { aggregate } from "./op/aggregate";
+import { fold } from "./op/fold";
+import { IAggQuery, IBinQuery, IFoldQuery, IRawQuery } from "./interfaces";
+import { bin } from "./op/bin";
+
+export type IViewQuery = IAggQuery | IFoldQuery | IBinQuery | IRawQuery;
+
+export function queryView (rawData: IRow[], metas: IMutField[], query: IViewQuery) {
+    switch (query.op) {
+        case 'aggregate':
+            return aggregate(rawData, query);
+        case 'fold':
+            return fold(rawData, query);
+        case 'bin':
+            return bin(rawData, query);
+        case 'raw':
+        default:
+            return rawData;
+    }
+
+}

package/src/locales/en-US.json

@@ -58,7 +58,8 @@
             "shape": "Shape",
             "theta": "Angle",
             "radius": "Radius",
-            "filters": "Filters"
+            "filters": "Filters",
+            "details": "Details"
         },
         "aggregator": {
             "sum": "Sum",
@@ -117,7 +118,8 @@
     "main": {
         "tablist": {
             "new": "+ New",
-            "autoTitle": "Chart {{idx}}"
+            "auto_title": "Chart {{idx}}",
+            "chart_name": "Chart Name"
         },
         "tabpanel": {
             "menubar": {
@@ -190,6 +192,7 @@
         "prev": "Previous",
         "next": "Next",
         "drop_field": "Drop Field Here",
-        "confirm": "Confirm"
+        "confirm": "Confirm",
+        "cancel": "Cancel"
     }
 }

package/src/locales/i18n.ts

@@ -6,7 +6,6 @@ import localeEnUs from './en-US.json';
 import localeJaJp from './ja-JP.json';
 import localeZhCn from './zh-CN.json';
 
-
 const locales: Resource & { 'en-US': any } = {
     'en': {
         translation: localeEnUs,

package/src/locales/ja-JP.json

@@ -117,7 +117,8 @@
     "main": {
       "tablist": {
         "new": "+ 新規作成",
-        "autoTitle": "グラフ {{idx}}"
+        "auto_title": "グラフ {{idx}}",
+        "chart_name": "グラフ名"
       },
       "tabpanel": {
         "menubar": {
@@ -190,6 +191,7 @@
       "prev": "前へ",
       "next": "次へ",
       "drop_field": "ここにフィールドをドロップ",
-      "confirm": "確認"
+      "confirm": "確認",
+      "cancel": "キャンセル"
     }
   }

package/src/locales/zh-CN.json

@@ -58,7 +58,8 @@
             "shape": "形状",
             "theta": "角度",
             "radius": "半径",
-            "filters": "筛选器"
+            "filters": "筛选器",
+            "details": "信息"
         },
         "aggregator": {
             "sum": "求和",
@@ -117,7 +118,8 @@
     "main": {
         "tablist": {
             "new": "+ 新建",
-            "autoTitle": "图表 {{idx}}"
+            "auto_title": "图表 {{idx}}",
+            "chart_name": "图表名称"
         },
         "tabpanel": {
             "menubar": {
@@ -190,6 +192,7 @@
         "prev": "向前",
         "next": "向后",
         "drop_field": "拖拽字段至此",
-        "confirm": "确认"
+        "confirm": "确认",
+        "cencel": "取消"
     }
 }