@zhongguo168a/yxeditor-common 0.0.57 → 0.0.58

package/dist/index.esm.js

@@ -1029,6 +1029,280 @@ let eventItemPool = new Pool({
     }
 });
 
+class DictIterator {
+    break() {
+        this._isBreak = true;
+    }
+    isBreak() {
+        return this._isBreak;
+    }
+}
+class Dictionary {
+    constructor(data) {
+        this.size = 0;
+        if (data) {
+            this._data = data;
+        }
+        else {
+            this._data = {};
+        }
+        this._onSet = null;
+        this._onDelete = null;
+    }
+    reset(data) {
+        this._reset(data);
+    }
+    _reset(data, size) {
+        this._data = data;
+        if (size == undefined) {
+            for (let _ in data) {
+                size++;
+            }
+        }
+        this.size = size;
+    }
+    getData() {
+        return this._data;
+    }
+    /**
+     * 如果使用了 onSet or onDelete，需要注意清理
+     */
+    clear() {
+        this._data = {};
+        this.size = 0;
+    }
+    /**
+     * 克隆自身所有项到【target】对象，并返回【target】对象
+     * @param target
+     */
+    clone(target) {
+        for (const key in this._data) {
+            let item = this._data[key];
+            // @ts-ignore
+            target.setData(key, item);
+        }
+        return target;
+    }
+    resetByDict(dict) {
+        this._data = dict._data;
+        this.size = dict.size;
+    }
+    onSet(caller, handler) {
+        this._onSetCaller = caller;
+        this._onSet = handler;
+    }
+    onDelete(caller, handler) {
+        this._onDelete = handler;
+        this._onDeleteCaller = caller;
+    }
+    /**
+     * 设置键值对，如果没有发生变化，不会触发onSet函数
+     * @param key
+     * @param value
+     */
+    set(key, value) {
+        this.setData(key, value);
+    }
+    setData(key, value) {
+        if (this._data.hasOwnProperty(key)) ;
+        else {
+            this.size++;
+        }
+        let existed = this._data[key];
+        if (existed == value) {
+            return;
+        }
+        this._data[key] = value;
+        if (this._onSet !== null) {
+            this._onSet.call(this._onSetCaller, key, value);
+        }
+    }
+    setByMap(m) {
+        for (const key in m) {
+            let item = m[key];
+            // @ts-ignore
+            this.setData(key, item);
+        }
+    }
+    addDictionary(other) {
+        if (other.length() == 0) {
+            return;
+        }
+        for (const key in other._data) {
+            let item = other._data[key];
+            // @ts-ignore
+            this.setData(key, item);
+        }
+    }
+    deleteDictionary(other) {
+        if (other.length() == 0) {
+            return;
+        }
+        for (const key in other._data) {
+            // @ts-ignore
+            this.delete(key);
+        }
+    }
+    /**
+     * 如果不存在，返回 undefined
+     * @param key
+     */
+    get(key) {
+        return this._data[key];
+    }
+    exist(key) {
+        return !!this._data[key];
+    }
+    delete(key) {
+        this.deleteData(key);
+    }
+    deleteData(key) {
+        const value = this._data[key];
+        if (value === undefined) {
+            return;
+        }
+        if (this._onDelete !== null) {
+            this._onDelete.call(this._onDeleteCaller, key, value);
+        }
+        this._data[key] = null;
+        delete this._data[key];
+        this.size--;
+    }
+    exists(key) {
+        return !!this._data[key];
+    }
+    length() {
+        return this.size;
+    }
+    pop(key) {
+        const value = this._data[key];
+        this.deleteData(key);
+        return [value, value !== undefined];
+    }
+    isEmpty() {
+        return this.length() === 0;
+    }
+    items() {
+        const items = [];
+        for (const key in this._data) {
+            let item = this._data[key];
+            items.push(item);
+        }
+        return items;
+    }
+    keys() {
+        const keys = [];
+        for (const key in this._data) {
+            keys.push(key);
+        }
+        return keys;
+    }
+    /**
+     *
+     * @param handler 可以使用【iterator】中断遍历
+     * @return iterator 获取是否中断了
+     */
+    forEach(handler) {
+        let iterator = new DictIterator();
+        for (const key in this._data) {
+            let val = this._data[key];
+            // @ts-ignore
+            handler(key, val, iterator);
+            if (iterator.isBreak()) {
+                return iterator;
+            }
+        }
+        return iterator;
+    }
+    /**
+     */
+    first() {
+        for (const key in this._data) {
+            return this._data[key];
+        }
+        return undefined;
+    }
+    /**
+     * @param handler 返回true结束迭代
+     */
+    firstByCondition(handler) {
+        for (const key in this._data) {
+            let val = this._data[key];
+            // @ts-ignore
+            if (handler(key, val)) {
+                return val;
+            }
+        }
+    }
+    /**
+     * 移除符合条件的项
+     * @param cond 可以使用【iterator】中断遍历
+     */
+    removeByCondition(cond) {
+        let newdata = this._data;
+        let newsize = this.size;
+        let iterator = new DictIterator();
+        for (const key in this._data) {
+            let val = this._data[key];
+            // @ts-ignore
+            if (cond(key, val, iterator)) {
+                newsize--;
+                delete newdata[key];
+            }
+            if (iterator.isBreak()) {
+                break;
+            }
+        }
+        this.size = newsize;
+    }
+    /**
+     * 查找符合条件的项保存到【target】对象中，并返回【target】对象
+     * @param cond 可以使用【iterator】中断遍历
+     * @param target 存到目标对象中
+     */
+    findByCondition(cond, target) {
+        if (!target) {
+            throw new Error("需要设置目标对象");
+        }
+        let iterator = new DictIterator();
+        let newdata = {};
+        let newsize = 0;
+        for (const key in this._data) {
+            let val = this._data[key];
+            // @ts-ignore
+            if (cond(key, val, iterator)) {
+                newsize++;
+                newdata[key] = val;
+            }
+            if (iterator.isBreak()) {
+                break;
+            }
+        }
+        target._reset(newdata, newsize);
+        return target;
+    }
+    groupByCondition(createKey, ITEM_CLASS) {
+        let newdata = {};
+        for (const key in this._data) {
+            let val = this._data[key];
+            // @ts-ignore
+            let newkey = createKey(key, val);
+            let dict = newdata[newkey];
+            if (!dict) {
+                if (ITEM_CLASS) {
+                    dict = new ITEM_CLASS();
+                }
+                else {
+                    dict = new Dictionary();
+                }
+                newdata[newkey] = dict;
+            }
+            dict.set(key, val);
+        }
+        return newdata;
+    }
+}
+
 class ConvertUtil {
     anyToBoolean(val, defaultValue = false) {
         if (val == null) {
@@ -2472,597 +2746,323 @@ class TreeRoot extends EventDispatcher {
                 let child = children[i];
                 child.id = i.toString();
                 child.setTag("title", i.toString());
-                this.refresh(child);
-            }
-        }
-        this.dispatch(TreeRoot.EVENT_INSERT, { node: node, before: before });
-    }
-    walk(f, inChild) {
-        this.origin.walk(f, inChild);
-    }
-    walkPrev(f, inChild) {
-        this.origin.walkPrev(f, inChild);
-    }
-    /**
-     * 派发 refresh 消息
-     * @param node
-     */
-    refresh(node) {
-        this.dispatch(TreeRoot.EVENT_REFRESH, { node: node });
-    }
-    /**
-     * 克隆当前的树结
-     * * 新的tags克隆旧的data
-     * * 新的data指向旧的data
-     */
-    clone() {
-        let root = TreeRoot.create();
-        root.origin = this.origin.clone();
-        root.origin.fixDepthAndRoot(0, root);
-        return root;
-    }
-    toString() {
-        return `TreeRoot`;
-    }
-    createNode(id, isLeaf) {
-        let node = new TreeNode(id, isLeaf);
-        node.setRoot(this);
-        return node;
-    }
-    /**
-     * origin的第一个child
-     */
-    get firstNode() {
-        if (!this.origin) {
-            return null;
-        }
-        if (!this.origin.children) {
-            return null;
-        }
-        return this.origin.children[0];
-    }
-}
-/**
- * 添加数据节点
- * dispatchParams = {node:TreeNode, parent:TreeNode|TreeRoot}
- */
-TreeRoot.EVENT_ADD = "add";
-/**
- * 移除数据节点
- * dispatchParams = {node:TreeNode, parent:TreeNode|TreeRoot}
- */
-TreeRoot.EVENT_REMOVE = "remove";
-/**
- * 插入数据节点
- * dispatchParams = {node:TreeNode, before:TreeNode}
- */
-TreeRoot.EVENT_INSERT = "insert";
-/**
- * 刷新数据节点
- * dispatchParams = {node:TreeNode}
- */
-TreeRoot.EVENT_REFRESH = "refresh";
-/**
- * 设置数据时触发
- * dispatchParams = {node:TreeNode}
- */
-TreeRoot.EVENT_DATA_SET = "data_set";
-/**
- * 设置数据时触发
- * dispatchParams = {node:TreeNode, tag:string, value:any}
- */
-TreeRoot.EVENT_TAGS_SET = "tags_set";
-///////////////////////////
-class TreeRootPlugin {
-}
-class TreeNodePlugin {
-}
-
-class ListNode {
-    static create(id, data) {
-        let node = new ListNode();
-        node.id = id;
-        node.data = data;
-        return node;
-    }
-    constructor() {
-        this.tags = {};
-        this.uuid = identutil.genOne();
-    }
-    getTags() {
-        if (!this.tags) {
-            this.tags = {};
-        }
-        return this.tags;
-    }
-    setTags(tags) {
-        let obj = this.getTags();
-        for (const key in tags) {
-            obj[key] = tags[key];
-        }
-    }
-    getTag(name) {
-        return this.getTags()[name];
-    }
-    setTag(name, value) {
-        this.getTags()[name] = value;
-    }
-}
-class ListSource extends EventDispatcher {
-    constructor() {
-        super(...arguments);
-        this._data = [];
-    }
-    /**
-     * 通过数组创建 ListSource。ListSource的id自动生成。如果需要指定编号，可设置 idCreator
-     * @param arr
-     * @param idCreator
-     */
-    static createByArray(arr, idCreator) {
-        let root = new ListSource();
-        for (let i = 0; i < arr.length; i++) {
-            let item = arr[i];
-            let id = "";
-            if (idCreator) {
-                id = idCreator(item);
-            }
-            else {
-                id = identutil.genOne();
-            }
-            let node = ListNode.create(id, item);
-            root.add(node, false);
-        }
-        return root;
-    }
-    static createByListItem(arr, target) {
-        if (!target) {
-            target = new ListSource();
-        }
-        for (let i = 0; i < arr.length; i++) {
-            let item = arr[i];
-            let id = "";
-            let node = ListNode.create(id);
-            node.id = item.id;
-            node.tags = item.tags;
-            node.data = item.data;
-            target.add(node, false);
-        }
-        return target;
-    }
-    at(index) {
-        return this._data[index];
-    }
-    first() {
-        return this._data[0];
-    }
-    last() {
-        return this._data[this._data.length - 1];
-    }
-    length() {
-        return this._data.length;
-    }
-    /**
-     * 添加项，无法添加相同的项
-     * @param node
-     * @param enableDispatch 默认为true
-     */
-    add(node, enableDispatch = true) {
-        if (this.contains(node)) {
-            return;
-        }
-        this._data.push(node);
-        node.root = this;
-        if (enableDispatch) {
-            this.dispatch(ListSource.EVENT_ADD, { node: node });
-        }
-    }
-    getById(id) {
-        for (let i = 0; i < this._data.length; i++) {
-            let node = this._data[i];
-            if (node.id == id) {
-                return node;
-            }
-        }
-        return null;
-    }
-    remove(node) {
-        let index = this._data.indexOf(node);
-        if (index == -1) {
-            return;
-        }
-        node.root = null;
-        this._data.splice(index, 1);
-        this.dispatch(ListSource.EVENT_REMOVE, { node: node, index: index });
-    }
-    removeAll() {
-        this._data.length = 0;
-        this.dispatch(ListSource.EVENT_REMOVE_ALL);
-    }
-    swap(a, b) {
-        let aidx = this.indexOf(a);
-        let bidx = this.indexOf(b);
-        let d = this._data;
-        [d[aidx], d[bidx]] = [d[bidx], a[aidx]];
-        this.dispatch(ListSource.EVENT_SWAP, { nodes: [a, b], indexs: [aidx, bidx] });
-    }
-    contains(node) {
-        return this.indexOf(node) != -1;
-    }
-    containsById(id) {
-        return this.indexOfById(id) != -1;
-    }
-    indexOf(node) {
-        for (let i = 0; i < this._data.length; i++) {
-            let item = this._data[i];
-            if (item.id == node.id) {
-                return i;
-            }
-        }
-        return -1;
-    }
-    indexOfById(id) {
-        for (let i = 0; i < this._data.length; i++) {
-            let item = this._data[i];
-            if (item.id == id) {
-                return i;
-            }
-        }
-        return -1;
-    }
-    setData(node, data) {
-        if (!node) {
-            return;
+                this.refresh(child);
+            }
         }
-        node.data = data;
-        this.dispatch(ListSource.EVENT_DATA_SET, { node: node, data: data });
+        this.dispatch(TreeRoot.EVENT_INSERT, { node: node, before: before });
     }
-    setNodeTags(node, tag, value) {
-        let tags = node.getTags();
-        if (tags[tag] === value) {
-            return;
-        }
-        tags[tag] = value;
-        this.dispatch(ListSource.EVENT_TAGS_SET, { node: node, tag: tag, value: value });
+    walk(f, inChild) {
+        this.origin.walk(f, inChild);
+    }
+    walkPrev(f, inChild) {
+        this.origin.walkPrev(f, inChild);
     }
     /**
      * 派发 refresh 消息
      * @param node
      */
     refresh(node) {
-        this.dispatch(ListSource.EVENT_REFRESH, { node: node });
+        this.dispatch(TreeRoot.EVENT_REFRESH, { node: node });
     }
-    walk(f) {
-        for (let i = 0; i < this.length(); i++) {
-            let item = this._data[i];
-            if (!f(item)) {
-                return false;
-            }
-        }
+    /**
+     * 克隆当前的树结
+     * * 新的tags克隆旧的data
+     * * 新的data指向旧的data
+     */
+    clone() {
+        let root = TreeRoot.create();
+        root.origin = this.origin.clone();
+        root.origin.fixDepthAndRoot(0, root);
+        return root;
     }
-    walkPrev(node, f) {
-        let index = this.indexOf(node);
-        if (index == -1) {
-            return;
+    toString() {
+        return `TreeRoot`;
+    }
+    createNode(id, isLeaf) {
+        let node = new TreeNode(id, isLeaf);
+        node.setRoot(this);
+        return node;
+    }
+    /**
+     * origin的第一个child
+     */
+    get firstNode() {
+        if (!this.origin) {
+            return null;
         }
-        for (let i = index; i >= 0; i--) {
-            let item = this._data[i];
-            if (!f(item)) {
-                return false;
-            }
+        if (!this.origin.children) {
+            return null;
         }
-    }
-    get data() {
-        return this._data;
+        return this.origin.children[0];
     }
 }
 /**
- * 设置数据时触发
- * dispatchParams = {node:ListNode}
+ * 添加数据节点
+ * dispatchParams = {node:TreeNode, parent:TreeNode|TreeRoot}
  */
-ListSource.EVENT_ADD = "add";
+TreeRoot.EVENT_ADD = "add";
 /**
- * 设置数据时触发
- * dispatchParams = {node:ListNode, index:number}
+ * 移除数据节点
+ * dispatchParams = {node:TreeNode, parent:TreeNode|TreeRoot}
  */
-ListSource.EVENT_REMOVE = "remove";
+TreeRoot.EVENT_REMOVE = "remove";
 /**
- * 设置数据时触发
+ * 插入数据节点
+ * dispatchParams = {node:TreeNode, before:TreeNode}
  */
-ListSource.EVENT_REMOVE_ALL = "remove_all";
+TreeRoot.EVENT_INSERT = "insert";
 /**
  * 刷新数据节点
- * dispatchParams = {node:ListNode}
- */
-ListSource.EVENT_REFRESH = "refresh";
-/**
- * 设置数据时触发
- * dispatchParams = nodes: [ListNode], indexs: [number]
+ * dispatchParams = {node:TreeNode}
  */
-ListSource.EVENT_SWAP = "swap";
+TreeRoot.EVENT_REFRESH = "refresh";
 /**
  * 设置数据时触发
- * dispatchParams = {node:ListNode, data:any}
+ * dispatchParams = {node:TreeNode}
  */
-ListSource.EVENT_DATA_SET = "data_set";
+TreeRoot.EVENT_DATA_SET = "data_set";
 /**
  * 设置数据时触发
- * dispatchParams = {node:ListNode, tag:string, value:any}
+ * dispatchParams = {node:TreeNode, tag:string, value:any}
  */
-ListSource.EVENT_TAGS_SET = "tags_set";
-
-class DictIterator {
-    break() {
-        this._isBreak = true;
-    }
-    isBreak() {
-        return this._isBreak;
-    }
+TreeRoot.EVENT_TAGS_SET = "tags_set";
+///////////////////////////
+class TreeRootPlugin {
 }
-class Dictionary {
-    constructor(data) {
-        this.size = 0;
-        if (data) {
-            this._data = data;
-        }
-        else {
-            this._data = {};
-        }
-        this._onSet = null;
-        this._onDelete = null;
+class TreeNodePlugin {
+}
+
+class ListNode {
+    static create(id, data) {
+        let node = new ListNode();
+        node.id = id;
+        node.data = data;
+        return node;
     }
-    reset(data) {
-        this._reset(data);
+    constructor() {
+        this.tags = {};
+        this.uuid = identutil.genOne();
     }
-    _reset(data, size) {
-        this._data = data;
-        if (size == undefined) {
-            for (let _ in data) {
-                size++;
-            }
+    getTags() {
+        if (!this.tags) {
+            this.tags = {};
         }
-        this.size = size;
-    }
-    getData() {
-        return this._data;
-    }
-    /**
-     * 如果使用了 onSet or onDelete，需要注意清理
-     */
-    clear() {
-        this._data = {};
-        this.size = 0;
+        return this.tags;
     }
-    /**
-     * 克隆自身所有项到【target】对象，并返回【target】对象
-     * @param target
-     */
-    clone(target) {
-        for (const key in this._data) {
-            let item = this._data[key];
-            // @ts-ignore
-            target.setData(key, item);
+    setTags(tags) {
+        let obj = this.getTags();
+        for (const key in tags) {
+            obj[key] = tags[key];
         }
-        return target;
     }
-    resetByDict(dict) {
-        this._data = dict._data;
-        this.size = dict.size;
+    getTag(name) {
+        return this.getTags()[name];
     }
-    onSet(caller, handler) {
-        this._onSetCaller = caller;
-        this._onSet = handler;
+    setTag(name, value) {
+        this.getTags()[name] = value;
     }
-    onDelete(caller, handler) {
-        this._onDelete = handler;
-        this._onDeleteCaller = caller;
+}
+class ListSource extends EventDispatcher {
+    constructor() {
+        super(...arguments);
+        this._data = [];
     }
     /**
-     * 设置键值对，如果没有发生变化，不会触发onSet函数
-     * @param key
-     * @param value
+     * 通过数组创建 ListSource。ListSource的id自动生成。如果需要指定编号，可设置 idCreator
+     * @param arr
+     * @param idCreator
      */
-    set(key, value) {
-        this.setData(key, value);
-    }
-    setData(key, value) {
-        if (this._data.hasOwnProperty(key)) ;
-        else {
-            this.size++;
-        }
-        let existed = this._data[key];
-        if (existed == value) {
-            return;
-        }
-        this._data[key] = value;
-        if (this._onSet !== null) {
-            this._onSet.call(this._onSetCaller, key, value);
-        }
-    }
-    setByMap(m) {
-        for (const key in m) {
-            let item = m[key];
-            // @ts-ignore
-            this.setData(key, item);
-        }
-    }
-    addDictionary(other) {
-        if (other.length() == 0) {
-            return;
-        }
-        for (const key in other._data) {
-            let item = other._data[key];
-            // @ts-ignore
-            this.setData(key, item);
+    static createByArray(arr, idCreator) {
+        let root = new ListSource();
+        for (let i = 0; i < arr.length; i++) {
+            let item = arr[i];
+            let id = "";
+            if (idCreator) {
+                id = idCreator(item);
+            }
+            else {
+                id = identutil.genOne();
+            }
+            let node = ListNode.create(id, item);
+            root.add(node, false);
         }
+        return root;
     }
-    deleteDictionary(other) {
-        if (other.length() == 0) {
-            return;
+    static createByListItem(arr, target) {
+        if (!target) {
+            target = new ListSource();
         }
-        for (const key in other._data) {
-            // @ts-ignore
-            this.delete(key);
+        for (let i = 0; i < arr.length; i++) {
+            let item = arr[i];
+            let id = "";
+            let node = ListNode.create(id);
+            node.id = item.id;
+            node.tags = item.tags;
+            node.data = item.data;
+            target.add(node, false);
         }
+        return target;
     }
-    /**
-     * 如果不存在，返回 undefined
-     * @param key
-     */
-    get(key) {
-        return this._data[key];
+    at(index) {
+        return this._data[index];
     }
-    exist(key) {
-        return !!this._data[key];
+    first() {
+        return this._data[0];
     }
-    delete(key) {
-        this.deleteData(key);
+    last() {
+        return this._data[this._data.length - 1];
     }
-    deleteData(key) {
-        const value = this._data[key];
-        if (value === undefined) {
+    length() {
+        return this._data.length;
+    }
+    /**
+     * 添加项，无法添加相同的项
+     * @param node
+     * @param enableDispatch 默认为true
+     */
+    add(node, enableDispatch = true) {
+        if (this.contains(node)) {
             return;
         }
-        if (this._onDelete !== null) {
-            this._onDelete.call(this._onDeleteCaller, key, value);
+        this._data.push(node);
+        node.root = this;
+        if (enableDispatch) {
+            this.dispatch(ListSource.EVENT_ADD, { node: node });
         }
-        this._data[key] = null;
-        delete this._data[key];
-        this.size--;
     }
-    exists(key) {
-        return !!this._data[key];
+    getById(id) {
+        for (let i = 0; i < this._data.length; i++) {
+            let node = this._data[i];
+            if (node.id == id) {
+                return node;
+            }
+        }
+        return null;
     }
-    length() {
-        return this.size;
+    remove(node) {
+        let index = this._data.indexOf(node);
+        if (index == -1) {
+            return;
+        }
+        node.root = null;
+        this._data.splice(index, 1);
+        this.dispatch(ListSource.EVENT_REMOVE, { node: node, index: index });
     }
-    pop(key) {
-        const value = this._data[key];
-        this.deleteData(key);
-        return [value, value !== undefined];
+    removeAll() {
+        this._data.length = 0;
+        this.dispatch(ListSource.EVENT_REMOVE_ALL);
     }
-    isEmpty() {
-        return this.length() === 0;
+    swap(a, b) {
+        let aidx = this.indexOf(a);
+        let bidx = this.indexOf(b);
+        let d = this._data;
+        [d[aidx], d[bidx]] = [d[bidx], a[aidx]];
+        this.dispatch(ListSource.EVENT_SWAP, { nodes: [a, b], indexs: [aidx, bidx] });
     }
-    items() {
-        const items = [];
-        for (const key in this._data) {
-            let item = this._data[key];
-            items.push(item);
-        }
-        return items;
+    contains(node) {
+        return this.indexOf(node) != -1;
     }
-    keys() {
-        const keys = [];
-        for (const key in this._data) {
-            keys.push(key);
+    containsById(id) {
+        return this.indexOfById(id) != -1;
+    }
+    indexOf(node) {
+        for (let i = 0; i < this._data.length; i++) {
+            let item = this._data[i];
+            if (item.id == node.id) {
+                return i;
+            }
         }
-        return keys;
+        return -1;
     }
-    /**
-     *
-     * @param handler 可以使用【iterator】中断遍历
-     * @return iterator 获取是否中断了
-     */
-    forEach(handler) {
-        let iterator = new DictIterator();
-        for (const key in this._data) {
-            let val = this._data[key];
-            // @ts-ignore
-            handler(key, val, iterator);
-            if (iterator.isBreak()) {
-                return iterator;
+    indexOfById(id) {
+        for (let i = 0; i < this._data.length; i++) {
+            let item = this._data[i];
+            if (item.id == id) {
+                return i;
             }
         }
-        return iterator;
+        return -1;
     }
-    /**
-     */
-    first() {
-        for (const key in this._data) {
-            return this._data[key];
+    setData(node, data) {
+        if (!node) {
+            return;
         }
-        return undefined;
+        node.data = data;
+        this.dispatch(ListSource.EVENT_DATA_SET, { node: node, data: data });
     }
-    /**
-     * @param handler 返回true结束迭代
-     */
-    firstByCondition(handler) {
-        for (const key in this._data) {
-            let val = this._data[key];
-            // @ts-ignore
-            if (handler(key, val)) {
-                return val;
-            }
+    setNodeTags(node, tag, value) {
+        let tags = node.getTags();
+        if (tags[tag] === value) {
+            return;
         }
+        tags[tag] = value;
+        this.dispatch(ListSource.EVENT_TAGS_SET, { node: node, tag: tag, value: value });
     }
     /**
-     * 移除符合条件的项
-     * @param cond 可以使用【iterator】中断遍历
+     * 派发 refresh 消息
+     * @param node
      */
-    removeByCondition(cond) {
-        let newdata = this._data;
-        let newsize = this.size;
-        let iterator = new DictIterator();
-        for (const key in this._data) {
-            let val = this._data[key];
-            // @ts-ignore
-            if (cond(key, val, iterator)) {
-                newsize--;
-                delete newdata[key];
-            }
-            if (iterator.isBreak()) {
-                break;
+    refresh(node) {
+        this.dispatch(ListSource.EVENT_REFRESH, { node: node });
+    }
+    walk(f) {
+        for (let i = 0; i < this.length(); i++) {
+            let item = this._data[i];
+            if (!f(item)) {
+                return false;
             }
         }
-        this.size = newsize;
     }
-    /**
-     * 查找符合条件的项保存到【target】对象中，并返回【target】对象
-     * @param cond 可以使用【iterator】中断遍历
-     * @param target 存到目标对象中
-     */
-    findByCondition(cond, target) {
-        if (!target) {
-            throw new Error("需要设置目标对象");
+    walkPrev(node, f) {
+        let index = this.indexOf(node);
+        if (index == -1) {
+            return;
         }
-        let iterator = new DictIterator();
-        let newdata = {};
-        let newsize = 0;
-        for (const key in this._data) {
-            let val = this._data[key];
-            // @ts-ignore
-            if (cond(key, val, iterator)) {
-                newsize++;
-                newdata[key] = val;
-            }
-            if (iterator.isBreak()) {
-                break;
+        for (let i = index; i >= 0; i--) {
+            let item = this._data[i];
+            if (!f(item)) {
+                return false;
             }
         }
-        target._reset(newdata, newsize);
-        return target;
     }
-    groupByCondition(createKey, ITEM_CLASS) {
-        let newdata = {};
-        for (const key in this._data) {
-            let val = this._data[key];
-            // @ts-ignore
-            let newkey = createKey(key, val);
-            let dict = newdata[newkey];
-            if (!dict) {
-                if (ITEM_CLASS) {
-                    dict = new ITEM_CLASS();
-                }
-                else {
-                    dict = new Dictionary();
-                }
-                newdata[newkey] = dict;
-            }
-            dict.set(key, val);
-        }
-        return newdata;
+    get data() {
+        return this._data;
     }
 }
+/**
+ * 设置数据时触发
+ * dispatchParams = {node:ListNode}
+ */
+ListSource.EVENT_ADD = "add";
+/**
+ * 设置数据时触发
+ * dispatchParams = {node:ListNode, index:number}
+ */
+ListSource.EVENT_REMOVE = "remove";
+/**
+ * 设置数据时触发
+ */
+ListSource.EVENT_REMOVE_ALL = "remove_all";
+/**
+ * 刷新数据节点
+ * dispatchParams = {node:ListNode}
+ */
+ListSource.EVENT_REFRESH = "refresh";
+/**
+ * 设置数据时触发
+ * dispatchParams = nodes: [ListNode], indexs: [number]
+ */
+ListSource.EVENT_SWAP = "swap";
+/**
+ * 设置数据时触发
+ * dispatchParams = {node:ListNode, data:any}
+ */
+ListSource.EVENT_DATA_SET = "data_set";
+/**
+ * 设置数据时触发
+ * dispatchParams = {node:ListNode, tag:string, value:any}
+ */
+ListSource.EVENT_TAGS_SET = "tags_set";
 
 class DictNode {
     static create(id, data) {