@visactor/vtable 1.26.6 → 1.26.8

package/es/data/DataSource.js

@@ -6,9 +6,9 @@ import { applyChainSafe, getOrApply, obj, isPromise, emptyFn } from "../tools/he
 
 import { EventTarget } from "../event/EventTarget";
 
-import { computeChildrenNodeLength, getValueByPath, isAllDigits } from "../tools/util";
+import { computeChildrenNodeLength, isAllDigits } from "../tools/util";
 
-import { arrayEqual, cloneDeep, isNumber, isObject, isValid } from "@visactor/vutils";
+import { arrayEqual, cloneDeep, isNumber, isValid } from "@visactor/vutils";
 
 import { RecordAggregator, SumAggregator, CountAggregator, MaxAggregator, MinAggregator, AvgAggregator, NoneAggregator, CustomAggregator } from "../ts-types/dataset/aggregation";
 
@@ -41,15 +41,15 @@ export function getField(record, field, col, row, table, promiseCallBack) {
     if ((void 0 === fieldGet || "" === fieldGet) && Array.isArray(record)) {
         return record[col - table.leftRowSeriesNumberCount];
     }
-    if (isObject(record) && fieldGet in record) {
+    if (Array.isArray(fieldGet)) {
+        return getValue(getRecordFieldValue(record, fieldGet), promiseCallBack);
+    }
+    if (isRecordContainer(record) && fieldGet in record) {
         return getValue(record[fieldGet], promiseCallBack);
     }
     if ("function" == typeof fieldGet) {
         return getValue(fieldGet(record, col, row, table), promiseCallBack);
     }
-    if (Array.isArray(fieldGet)) {
-        return getValue(getValueByPath(record, [ ...fieldGet ]), promiseCallBack);
-    }
     const fieldArray = `${fieldGet}`.split(".");
     if (fieldArray.length <= 1) {
         return getValue(record[fieldGet], promiseCallBack);
@@ -57,6 +57,56 @@ export function getField(record, field, col, row, table, promiseCallBack) {
     return getValue(applyChainSafe(record, ((val, name) => getField(val, name, col, row, table, emptyFn)), ...fieldArray), promiseCallBack);
 }
 
+function isRecordContainer(value) {
+    return null !== value && "object" == typeof value;
+}
+
+function getRecordFieldPath(field) {
+    return Array.isArray(field) ? field : "string" == typeof field && field.includes(".") ? field.split(".") : void 0;
+}
+
+function hasRecordField(record, field) {
+    if (!isRecordContainer(record)) return !1;
+    const path = getRecordFieldPath(field);
+    if (!Array.isArray(field) && field in record) return !0;
+    if (!path) return !1;
+    let target = record;
+    for (const key of path) {
+        if (!isRecordContainer(target) || !(key in target)) return !1;
+        target = target[key];
+    }
+    return !0;
+}
+
+export function getRecordFieldValue(record, field) {
+    if (null == record) return;
+    const path = getRecordFieldPath(field);
+    return !Array.isArray(field) && isRecordContainer(record) && field in record ? record[field] : path ? path.reduce(((current, key) => null == current ? void 0 : current[key]), record) : record[field];
+}
+
+function setRecordProperty(record, key, value) {
+    "__proto__" !== key && "constructor" !== key && "prototype" !== key ? record[key] = value : Object.defineProperty(record, key, {
+        configurable: !0,
+        enumerable: !0,
+        value: value,
+        writable: !0
+    });
+}
+
+export function setRecordFieldValue(record, field, value) {
+    if (null == record) return;
+    const path = getRecordFieldPath(field);
+    if (!path || !Array.isArray(field) && isRecordContainer(record) && field in record) return void setRecordProperty(record, field, value);
+    if (0 === path.length) return;
+    let target = record;
+    for (let i = 0; i < path.length - 1; i++) {
+        const key = path[i];
+        Object.prototype.hasOwnProperty.call(target, key) && null !== target[key] && "object" == typeof target[key] || setRecordProperty(target, key, {}), 
+        target = target[key];
+    }
+    setRecordProperty(target, path[path.length - 1], value);
+}
+
 function _getIndex(sortedIndexMap, index) {
     if (!sortedIndexMap) return index;
     const mapIndex = sortedIndexMap[index];
@@ -308,23 +358,22 @@ export class DataSource extends EventTarget {
         return childrenLength;
     }
     changeFieldValue(value, index, field, col, row, table) {
-        var _a;
         if (null !== field && index >= 0) {
             const dataIndex = this.getIndexKey(index);
             if (this.cacheBeforeChangedRecord(dataIndex, table), void 0 !== field && "" !== field || (field = col - table.leftRowSeriesNumberCount), 
-            "string" == typeof field || "number" == typeof field) {
-                const beforeChangedValue = null === (_a = this.beforeChangedRecordsMap.get(dataIndex.toString())) || void 0 === _a ? void 0 : _a[field], record = this.getOriginalRecord(dataIndex);
+            "string" == typeof field || "number" == typeof field || Array.isArray(field)) {
+                const beforeChangedValue = getRecordFieldValue(this.beforeChangedRecordsMap.get(dataIndex.toString()), field), record = this.getOriginalRecord(dataIndex);
                 let formatValue = value;
-                "number" == typeof beforeChangedValue && isAllDigits(value) && (formatValue = parseFloat(value)), 
-                isPromise(record) ? record.then((record => {
-                    record[field] = formatValue;
-                })).catch((err => {})) : record ? record[field] = formatValue : (this.records[dataIndex] = "Array" === this.addRecordRule ? [] : {}, 
-                this.records[dataIndex][field] = formatValue);
+                if ("number" == typeof beforeChangedValue && isAllDigits(value) && (formatValue = parseFloat(value)), 
+                isPromise(record)) return record.then((record => (setRecordFieldValue(record, field, formatValue), 
+                formatValue))).catch((err => {}));
+                record ? setRecordFieldValue(record, field, formatValue) : (this.records[dataIndex] = "Array" === this.addRecordRule ? [] : {}, 
+                setRecordFieldValue(this.records[dataIndex], field, formatValue));
             }
         }
     }
     changeFieldValueByRecordIndex(value, recordIndex, field, table) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c;
         if (null === field) return;
         if (null == recordIndex) return;
         const rawKey = recordIndex.toString();
@@ -332,12 +381,12 @@ export class DataSource extends EventTarget {
             const rawRecords = Array.isArray(null === (_a = this.dataSourceObj) || void 0 === _a ? void 0 : _a.records) ? this.dataSourceObj.records : null, originRecord = rawRecords ? Array.isArray(recordIndex) ? getValueFromDeepArray(rawRecords, recordIndex) : rawRecords[recordIndex] : void 0;
             this.beforeChangedRecordsMap.set(rawKey, null !== (_b = cloneDeep(originRecord, void 0, [ "vtable_gantt_linkedFrom", "vtable_gantt_linkedTo" ])) && void 0 !== _b ? _b : {});
         }
-        if ("string" == typeof field || "number" == typeof field) {
-            const beforeChangedValue = null === (_c = this.beforeChangedRecordsMap.get(rawKey)) || void 0 === _c ? void 0 : _c[field], rawRecords = Array.isArray(null === (_d = this.dataSourceObj) || void 0 === _d ? void 0 : _d.records) ? this.dataSourceObj.records : null, record = rawRecords ? Array.isArray(recordIndex) ? getValueFromDeepArray(rawRecords, recordIndex) : rawRecords[recordIndex] : void 0;
+        if ("string" == typeof field || "number" == typeof field || Array.isArray(field)) {
+            const beforeChangedValue = getRecordFieldValue(this.beforeChangedRecordsMap.get(rawKey), field), rawRecords = Array.isArray(null === (_c = this.dataSourceObj) || void 0 === _c ? void 0 : _c.records) ? this.dataSourceObj.records : null, record = rawRecords ? Array.isArray(recordIndex) ? getValueFromDeepArray(rawRecords, recordIndex) : rawRecords[recordIndex] : void 0;
             let formatValue = value;
             "number" == typeof beforeChangedValue && isAllDigits(value) && (formatValue = parseFloat(value)), 
-            record ? record[field] = formatValue : rawRecords && "number" == typeof recordIndex && (rawRecords[recordIndex] = "Array" === this.addRecordRule ? [] : {}, 
-            rawRecords[recordIndex][field] = formatValue);
+            record ? setRecordFieldValue(record, field, formatValue) : rawRecords && "number" == typeof recordIndex && (rawRecords[recordIndex] = "Array" === this.addRecordRule ? [] : {}, 
+            setRecordFieldValue(rawRecords[recordIndex], field, formatValue));
         }
     }
     cacheBeforeChangedRecord(dataIndex, table) {
@@ -730,8 +779,7 @@ export class DataSource extends EventTarget {
     hasOriginalField(index, field) {
         if (null === field) return !1;
         if ("function" == typeof field) return !0;
-        const record = this.getOriginalRecord(index);
-        return Boolean(record && field in record);
+        return hasRecordField(this.getOriginalRecord(index), field);
     }
     fieldPromiseCallBack(_index, _field, _value) {}
     recordPromiseCallBack(_index, _record) {}