@flowlist/js-core 4.0.8-beta.0 → 4.0.10-beta.0

package/dist/index.global.js

@@ -1,15 +1,9 @@
 var FlowList = (function (exports) {
   'use strict';
 
-  var __defProp = Object.defineProperty;
-  var __export = (target, all) => {
-    for (var name in all)
-      __defProp(target, name, { get: all[name], enumerable: true });
-  };
-
-  // src/enum.ts
+  // src/constants.ts
   var FETCH_TYPE_ARRAY = ["jump", "sinceId", "page", "seenIds", "auto"];
-  var enum_default = {
+  var constants_default = {
     SETTER_TYPE: {
       RESET: 0,
       MERGE: 1
@@ -41,104 +35,63 @@ var FlowList = (function (exports) {
     DEFAULT_UNIQUE_KEY_NAME: "id"
   };
 
-  // src/utils.ts
-  var utils_exports = {};
-  __export(utils_exports, {
-    combineArrayData: () => combineArrayData,
-    computeMatchedItemIndex: () => computeMatchedItemIndex,
-    computeResultLength: () => computeResultLength,
-    generateDefaultField: () => generateDefaultField,
-    generateFieldName: () => generateFieldName,
-    generateRequestParams: () => generateRequestParams,
-    getObjectDeepValue: () => getObjectDeepValue,
-    getResultAsArray: () => getResultAsArray,
-    isArray: () => isArray,
-    isKeyMap: () => isKeyMap,
-    isKeyMapArray: () => isKeyMapArray,
-    isObjectKey: () => isObjectKey,
-    isObjectKeyArray: () => isObjectKeyArray,
-    isObjectResult: () => isObjectResult,
-    isResultObject: () => isResultObject,
-    searchValueByKey: () => searchValueByKey,
-    setReactivityField: () => setReactivityField,
-    stableSerialize: () => stableSerialize,
-    toObjectKey: () => toObjectKey,
-    updateArrayItem: () => updateArrayItem,
-    updateObjectDeepValue: () => updateObjectDeepValue
-  });
+  // src/_internal/utils.ts
   var isArray = (data) => Array.isArray(data);
-  var isResultObject = (data) => !isArray(data) && typeof data === "object" && data !== null;
   var isObjectKey = (value) => typeof value === "string" || typeof value === "number";
   var isKeyMap = (value) => typeof value === "object" && value !== null && !isArray(value);
-  var isKeyMapArray = (value) => {
-    if (!isArray(value)) return false;
-    const len = value.length;
-    for (let i = 0; i < len; i++) {
-      const item = value[i];
-      if (typeof item !== "object" || item === null) {
-        return false;
-      }
-    }
-    return true;
-  };
-  var isObjectKeyArray = (value) => {
-    if (!isArray(value)) return false;
-    const len = value.length;
-    for (let i = 0; i < len; i++) {
-      const item = value[i];
-      const itemType = typeof item;
-      if (itemType !== "string" && itemType !== "number") {
-        return false;
-      }
+  var isKeyMapArray = (value) => isArray(value) && value.every((item) => typeof item === "object" && item !== null);
+  var isObjectKeyArray = (value) => isArray(value) && value.every((item) => typeof item === "string" || typeof item === "number");
+  var stableSerialize = (value) => {
+    if (value === null || typeof value !== "object") return String(value);
+    try {
+      if (isArray(value)) return JSON.stringify(value);
+      return JSON.stringify(
+        Object.fromEntries(
+          Object.entries(value).sort(
+            ([a], [b]) => a.localeCompare(b)
+          )
+        )
+      );
+    } catch {
+      return "[Circular]";
     }
-    return true;
   };
-  var stableSerialize = (value) => {
-    if (value === null || typeof value !== "object") {
-      return String(value);
+  var getObjectDeepValue = (field, keys) => {
+    if (!keys || isArray(keys) && keys.length === 0) return field;
+    const keysArr = isArray(keys) ? keys : keys.split(".");
+    let cur = field;
+    for (let i = 0; i < keysArr.length; i++) {
+      if (cur == null || typeof cur !== "object") return void 0;
+      cur = cur[keysArr[i]];
     }
-    try {
-      if (isArray(value)) {
-        return JSON.stringify(value);
-      }
-      if (isKeyMap(value)) {
-        const keys = Object.keys(value).sort();
-        const obj = {};
-        const len = keys.length;
-        for (let i = 0; i < len; i++) {
-          const k = keys[i];
-          obj[k] = value[k];
-        }
-        return JSON.stringify(obj);
+    return cur;
+  };
+  var updateObjectDeepValue = (field, changeKey, value) => {
+    const keys = changeKey.split(".");
+    const lastKey = keys.pop();
+    if (!lastKey) return;
+    let current = field;
+    for (const key of keys) {
+      if (current[key] == null || typeof current[key] !== "object") {
+        current[key] = {};
       }
-      return "[Unsupported Object]";
-    } catch {
-      return "[Circular Object/Value]";
+      if (!isKeyMap(current[key])) return;
+      current = current[key];
     }
+    current[lastKey] = value;
   };
   var extractUniqueKey = (item, uniqueKey) => {
     if (!isKeyMap(item)) return void 0;
     const val = item[uniqueKey];
-    if (isObjectKey(val)) {
-      return val;
-    }
+    if (isObjectKey(val)) return val;
     if (uniqueKey.includes(".")) {
       const deepVal = getObjectDeepValue(item, uniqueKey);
-      if (isObjectKey(deepVal)) {
-        return deepVal;
-      }
+      if (isObjectKey(deepVal)) return deepVal;
     }
     return void 0;
   };
-  var isObjectResult = (data) => {
-    if (typeof data !== "object" || data === null) {
-      return false;
-    }
-    return !Object.prototype.hasOwnProperty.call(data, "result");
-  };
   var generateDefaultField = (opts = {}) => ({
     result: [],
-    // 默认为空数组，但强制转换为泛型 T
     noMore: false,
     nothing: false,
     loading: false,
@@ -149,73 +102,33 @@ var FlowList = (function (exports) {
     total: 0,
     ...opts
   });
-  var generateFieldName = ({
-    func,
-    query
-  }) => {
-    if (!query) {
-      return func.id;
-    }
-    let result = func.id;
-    const keys = Object.keys(query);
-    const paramsIgnore = func.paramsIgnore;
-    const filteredKeys = [];
-    const keysLen = keys.length;
-    for (let i = 0; i < keysLen; i++) {
-      const key = keys[i];
-      if (!paramsIgnore.includes(key)) {
-        filteredKeys.push(key);
-      }
-    }
-    filteredKeys.sort();
-    const len = filteredKeys.length;
-    for (let i = 0; i < len; i++) {
-      const key = filteredKeys[i];
-      const value = query[key];
-      let safeValue;
-      if (typeof value === "object" && value !== null) {
-        safeValue = stableSerialize(value);
-      } else {
-        safeValue = String(value);
-      }
-      const encoded = encodeURIComponent(safeValue);
-      result += `-${key}-${encoded}`;
+  var computeMatchedItemIndex = (itemId, fieldArr, changingKey) => {
+    const stringId = String(itemId);
+    for (let i = 0; i < fieldArr.length; i++) {
+      const item = fieldArr[i];
+      if (!isKeyMap(item)) continue;
+      const val = getObjectDeepValue(item, changingKey);
+      if (String(val) === stringId) return i;
     }
-    return result;
+    return -1;
   };
-  var getObjectDeepValue = (field, keys) => {
-    if (!keys || Array.isArray(keys) && keys.length === 0)
-      return field;
-    const keysArr = Array.isArray(keys) ? keys : keys.split(".");
-    let cur = field;
-    for (let i = 0, n = keysArr.length; i < n; ++i) {
-      if (cur == null || typeof cur !== "object") return void 0;
-      cur = cur[keysArr[i]];
-    }
-    return cur;
+  var computeResultLength = (data) => {
+    if (isArray(data)) return data.length;
+    return 0;
   };
-  var updateObjectDeepValue = (field, changeKey, value) => {
-    if (!changeKey) return;
-    const keys = changeKey.split(".");
-    const lastKey = keys.pop();
-    if (!lastKey) return;
-    let current = field;
-    const len = keys.length;
-    for (let i = 0; i < len; i++) {
-      const key = keys[i];
-      const currentVal = current[key];
-      if (currentVal == null || typeof currentVal !== "object") {
-        current[key] = {};
-      }
-      const next = current[key];
-      if (isKeyMap(next)) {
-        current = next;
-      } else {
-        return;
-      }
-    }
-    if (current != null && typeof current === "object") {
-      current[lastKey] = value;
+  var toObjectKey = (id) => {
+    if (id === void 0) return void 0;
+    if (isObjectKey(id)) return id;
+    if (isObjectKeyArray(id) && id.length > 0) return id[0];
+    return void 0;
+  };
+  var getResultAsArray = (field) => {
+    const result = field[constants_default.FIELD_DATA.RESULT_KEY];
+    return isArray(result) ? result : null;
+  };
+  var updateArrayItem = (arr, index, updater) => {
+    if (index >= 0 && index < arr.length && isKeyMap(arr[index])) {
+      arr[index] = updater(arr[index]);
     }
   };
   var searchValueByKey = (result, id, key) => {
@@ -223,237 +136,154 @@ var FlowList = (function (exports) {
       const index = computeMatchedItemIndex(id, result, key);
       return index >= 0 ? result[index] : void 0;
     }
-    if (isResultObject(result)) {
-      return result[String(id)];
-    }
+    if (isKeyMap(result)) return result[String(id)];
     return void 0;
   };
-  var computeMatchedItemIndex = (itemId, fieldArr, changingKey) => {
-    const stringifiedItemId = String(itemId);
-    const len = fieldArr.length;
-    const isSimpleKey = !changingKey.includes(".");
-    if (isSimpleKey) {
-      for (let i = 0; i < len; i++) {
-        const item = fieldArr[i];
-        if (!isKeyMap(item)) continue;
-        if (String(item[changingKey]) === stringifiedItemId) {
-          return i;
-        }
-      }
-    } else {
-      for (let i = 0; i < len; i++) {
-        const item = fieldArr[i];
-        if (!isKeyMap(item)) continue;
-        const itemValue = getObjectDeepValue(item, changingKey);
-        if (String(itemValue) === stringifiedItemId) {
-          return i;
-        }
-      }
-    }
-    return -1;
-  };
   var combineArrayData = (fieldArray, value, changingKey) => {
-    const fieldArrayMap = /* @__PURE__ */ new Map();
-    const arrLen = fieldArray.length;
-    for (let i = 0; i < arrLen; i++) {
+    const indexMap = /* @__PURE__ */ new Map();
+    for (let i = 0; i < fieldArray.length; i++) {
       const item = fieldArray[i];
       if (!isKeyMap(item)) continue;
       const id = getObjectDeepValue(item, changingKey);
-      if (id !== void 0) {
-        fieldArrayMap.set(String(id), i);
-      }
+      if (id !== void 0) indexMap.set(String(id), i);
     }
+    const mergeItem = (uniqueId, col) => {
+      const index = indexMap.get(uniqueId);
+      if (index !== void 0 && isKeyMap(fieldArray[index])) {
+        fieldArray[index] = { ...fieldArray[index], ...col };
+      }
+    };
     if (isArray(value)) {
-      const valLen = value.length;
-      for (let i = 0; i < valLen; i++) {
-        const col = value[i];
+      for (const col of value) {
         if (!isKeyMap(col)) continue;
-        const stringifyId = String(getObjectDeepValue(col, changingKey));
-        const index = fieldArrayMap.get(stringifyId);
-        if (index !== void 0) {
-          const existingItem = fieldArray[index];
-          if (isKeyMap(existingItem)) {
-            fieldArray[index] = { ...existingItem, ...col };
-          }
-        }
+        mergeItem(String(getObjectDeepValue(col, changingKey)), col);
       }
     } else if (isKeyMap(value)) {
-      const entries = Object.entries(value);
-      const entLen = entries.length;
-      for (let i = 0; i < entLen; i++) {
-        const [uniqueId, col] = entries[i];
-        if (!isKeyMap(col)) continue;
-        const index = fieldArrayMap.get(uniqueId);
-        if (index !== void 0) {
-          const existingItem = fieldArray[index];
-          if (isKeyMap(existingItem)) {
-            fieldArray[index] = { ...existingItem, ...col };
-          }
-        }
+      for (const [uniqueId, col] of Object.entries(value)) {
+        if (isKeyMap(col)) mergeItem(uniqueId, col);
       }
     }
   };
   var setReactivityField = (field, key, value, type, insertBefore) => {
     const fieldAny = field;
-    if (type === enum_default.FETCH_TYPE.PAGINATION) {
+    if (type === constants_default.FETCH_TYPE.PAGINATION) {
       fieldAny[key] = value;
       return;
     }
-    if (key !== enum_default.FIELD_DATA.RESULT_KEY) {
+    if (key !== constants_default.FIELD_DATA.RESULT_KEY) {
       if (isArray(value)) {
-        const current = fieldAny[key];
-        const currentArr = isArray(current) ? current : [];
-        fieldAny[key] = insertBefore ? value.concat(currentArr) : currentArr.concat(value);
+        const current = isArray(fieldAny[key]) ? fieldAny[key] : [];
+        fieldAny[key] = insertBefore ? [...value, ...current] : [...current, ...value];
       } else {
         fieldAny[key] = value;
       }
       return;
     }
-    const resultField = field.result;
     if (isArray(value)) {
-      const valueArr = value;
-      const valueLen = valueArr.length;
-      if (valueLen === 0) return;
-      const currentArr = isArray(resultField) ? resultField : [];
-      const currentLen = currentArr.length;
-      if (currentLen === 0) {
-        field.result = valueArr;
+      if (value.length === 0) return;
+      const current = isArray(field.result) ? field.result : [];
+      if (current.length === 0) {
+        field.result = value;
         return;
       }
-      field.result = insertBefore ? valueArr.concat(currentArr) : currentArr.concat(valueArr);
+      field.result = insertBefore ? [...value, ...current] : [...current, ...value];
       return;
     }
     const valueObj = value;
-    let target = resultField;
-    if (isArray(resultField) || typeof resultField !== "object" || resultField === null) {
+    let target = field.result;
+    if (isArray(field.result) || typeof field.result !== "object" || field.result === null) {
       target = {};
       field.result = target;
     }
-    const keys = Object.keys(valueObj);
-    const len = keys.length;
-    for (let i = 0; i < len; i++) {
-      const subKey = keys[i];
+    for (const subKey of Object.keys(valueObj)) {
       const existing = target[subKey];
       const incoming = valueObj[subKey];
-      if (existing !== void 0) {
-        if (isArray(existing) && isArray(incoming)) {
-          target[subKey] = insertBefore ? incoming.concat(existing) : existing.concat(incoming);
-        } else {
-          target[subKey] = incoming;
-        }
+      if (existing !== void 0 && isArray(existing) && isArray(incoming)) {
+        target[subKey] = insertBefore ? [...incoming, ...existing] : [...existing, ...incoming];
       } else {
         target[subKey] = incoming;
       }
     }
   };
-  var computeResultLength = (data) => {
-    if (isArray(data)) {
-      return data.length;
-    }
-    if (isKeyMap(data)) {
-      let acc = 0;
-      const values = Object.values(data);
-      const len = values.length;
-      for (let i = 0; i < len; i++) {
-        const val = values[i];
-        if (isArray(val)) {
-          acc += val.length;
-        }
-      }
-      return acc;
-    }
-    return 0;
-  };
   var getSeenIdsString = (arr, uniqueKey) => {
     if (!isArray(arr)) return "";
     const ids = [];
-    const len = arr.length;
-    for (let i = 0; i < len; i++) {
-      const id = extractUniqueKey(arr[i], uniqueKey);
-      if (id !== void 0) {
-        ids.push(id);
-      }
+    for (const item of arr) {
+      const id = extractUniqueKey(item, uniqueKey);
+      if (id !== void 0) ids.push(id);
     }
     return ids.join(",");
   };
   var generateRequestParams = ({
     field,
-    uniqueKey = enum_default.DEFAULT_UNIQUE_KEY_NAME,
+    uniqueKey = constants_default.DEFAULT_UNIQUE_KEY_NAME,
     query = {},
     is_up = false,
     type
   }) => {
     const result = { ...query };
     const isFetched = field.fetched;
-    const fieldResultAny = field.result;
-    const getSafeObjectKey = (item) => {
-      return extractUniqueKey(item, uniqueKey);
-    };
+    const fieldResult = field.result;
+    const getSafeObjectKey = (item) => extractUniqueKey(item, uniqueKey);
     if (isFetched) {
-      if (type === enum_default.FETCH_TYPE.AUTO) {
-        if (isArray(fieldResultAny)) {
-          result.seen_ids = getSeenIdsString(fieldResultAny, uniqueKey);
-          const targetIndex = is_up ? 0 : fieldResultAny.length - 1;
-          const targetItem = fieldResultAny[targetIndex];
-          result.since_id = getSafeObjectKey(targetItem);
-        }
-        result.is_up = is_up ? 1 : 0;
-        result.page = typeof query.page === "number" ? query.page : field.page + 1;
-      } else if (type === enum_default.FETCH_TYPE.HAS_LOADED_IDS) {
-        if (isArray(fieldResultAny)) {
-          result.seen_ids = getSeenIdsString(fieldResultAny, uniqueKey);
-        }
-      } else if (type === enum_default.FETCH_TYPE.SINCE_FIRST_OR_END_ID) {
-        if (isArray(fieldResultAny)) {
-          const targetIndex = is_up ? 0 : fieldResultAny.length - 1;
-          const targetItem = fieldResultAny[targetIndex];
-          result.since_id = getSafeObjectKey(targetItem);
-        }
-        result.is_up = is_up ? 1 : 0;
-      } else if (type === enum_default.FETCH_TYPE.PAGINATION) {
-        result.page = typeof query.page === "number" ? query.page : void 0;
-      } else if (type === enum_default.FETCH_TYPE.SCROLL_LOAD_MORE) {
-        result.page = field.page + 1;
+      switch (type) {
+        case constants_default.FETCH_TYPE.AUTO:
+          if (isArray(fieldResult)) {
+            result.seen_ids = getSeenIdsString(fieldResult, uniqueKey);
+            result.since_id = getSafeObjectKey(
+              fieldResult[is_up ? 0 : fieldResult.length - 1]
+            );
+          }
+          result.is_up = is_up ? 1 : 0;
+          result.page = typeof query.page === "number" ? query.page : field.page + 1;
+          break;
+        case constants_default.FETCH_TYPE.HAS_LOADED_IDS:
+          if (isArray(fieldResult)) {
+            result.seen_ids = getSeenIdsString(fieldResult, uniqueKey);
+          }
+          break;
+        case constants_default.FETCH_TYPE.SINCE_FIRST_OR_END_ID:
+          if (isArray(fieldResult)) {
+            result.since_id = getSafeObjectKey(
+              fieldResult[is_up ? 0 : fieldResult.length - 1]
+            );
+          }
+          result.is_up = is_up ? 1 : 0;
+          break;
+        case constants_default.FETCH_TYPE.PAGINATION:
+          result.page = typeof query.page === "number" ? query.page : void 0;
+          break;
+        case constants_default.FETCH_TYPE.SCROLL_LOAD_MORE:
+          result.page = field.page + 1;
+          break;
       }
     } else {
-      if (type === enum_default.FETCH_TYPE.AUTO) {
-        result.seen_ids = "";
-        result.since_id = isObjectKey(query.sinceId) ? query.sinceId : "";
-        result.is_up = is_up ? 1 : 0;
-        result.page = typeof query.page === "number" ? query.page : field.page || 1;
-      } else if (type === enum_default.FETCH_TYPE.HAS_LOADED_IDS) {
-        result.seen_ids = "";
-      } else if (type === enum_default.FETCH_TYPE.SINCE_FIRST_OR_END_ID) {
-        result.since_id = isObjectKey(query.sinceId) ? query.sinceId : "";
-        result.is_up = is_up ? 1 : 0;
-      } else if (type === enum_default.FETCH_TYPE.PAGINATION) {
-        result.page = typeof query.page === "number" ? query.page : field.page;
-      } else if (type === enum_default.FETCH_TYPE.SCROLL_LOAD_MORE) {
-        result.page = 1;
+      switch (type) {
+        case constants_default.FETCH_TYPE.AUTO:
+          result.seen_ids = "";
+          result.since_id = isObjectKey(query.sinceId) ? query.sinceId : "";
+          result.is_up = is_up ? 1 : 0;
+          result.page = typeof query.page === "number" ? query.page : field.page || 1;
+          break;
+        case constants_default.FETCH_TYPE.HAS_LOADED_IDS:
+          result.seen_ids = "";
+          break;
+        case constants_default.FETCH_TYPE.SINCE_FIRST_OR_END_ID:
+          result.since_id = isObjectKey(query.sinceId) ? query.sinceId : "";
+          result.is_up = is_up ? 1 : 0;
+          break;
+        case constants_default.FETCH_TYPE.PAGINATION:
+          result.page = typeof query.page === "number" ? query.page : field.page;
+          break;
+        case constants_default.FETCH_TYPE.SCROLL_LOAD_MORE:
+          result.page = 1;
+          break;
       }
     }
     return result;
   };
-  var toObjectKey = (id) => {
-    if (id === void 0) return void 0;
-    if (isObjectKey(id)) return id;
-    if (isObjectKeyArray(id) && id.length > 0) return id[0];
-    return void 0;
-  };
-  var getResultAsArray = (field) => {
-    const result = field[enum_default.FIELD_DATA.RESULT_KEY];
-    return isArray(result) ? result : null;
-  };
-  var updateArrayItem = (arr, index, updater) => {
-    if (index >= 0 && index < arr.length) {
-      const item = arr[index];
-      if (isKeyMap(item)) {
-        arr[index] = updater(item);
-      }
-    }
-  };
 
-  // src/setters.ts
+  // src/_internal/setters.ts
   var SET_DATA = ({
     getter,
     setter,
@@ -472,7 +302,8 @@ var FlowList = (function (exports) {
       const field = fieldData;
       let result;
       let extra;
-      if (isObjectResult(data)) {
+      const hasResult = Object.prototype.hasOwnProperty.call(data, "result");
+      if (!hasResult) {
         result = data;
         field.nothing = false;
         field.fetched = true;
@@ -486,7 +317,7 @@ var FlowList = (function (exports) {
         field.nothing = field.fetched ? false : isEmpty;
         field.fetched = true;
         field.total = apiResponse.total || 0;
-        if (type === enum_default.FETCH_TYPE.PAGINATION) {
+        if (type === constants_default.FETCH_TYPE.PAGINATION) {
           field.noMore = false;
           field.page = +page;
         } else {
@@ -497,7 +328,7 @@ var FlowList = (function (exports) {
       field.loading = false;
       setReactivityField(
         field,
-        enum_default.FIELD_DATA.RESULT_KEY,
+        constants_default.FIELD_DATA.RESULT_KEY,
         result,
         type,
         insertBefore
@@ -505,7 +336,7 @@ var FlowList = (function (exports) {
       if (extra !== void 0 && extra !== null) {
         setReactivityField(
           field,
-          enum_default.FIELD_DATA.EXTRA_KEY,
+          constants_default.FIELD_DATA.EXTRA_KEY,
           extra,
           type,
           insertBefore
@@ -513,27 +344,22 @@ var FlowList = (function (exports) {
       }
       setter({
         key: fieldName,
-        type: enum_default.SETTER_TYPE.RESET,
+        type: constants_default.SETTER_TYPE.RESET,
         value: field,
-        callback: () => {
-          resolve();
-        }
+        callback: () => resolve()
       });
     });
   };
   var SET_ERROR = ({ setter, fieldName, error }) => {
     setter({
       key: fieldName,
-      type: enum_default.SETTER_TYPE.MERGE,
-      value: {
-        error,
-        loading: false
-      }
+      type: constants_default.SETTER_TYPE.MERGE,
+      value: { error, loading: false }
     });
   };
 
-  // src/actions.ts
-  var generateFieldName2 = ({
+  // src/core.ts
+  var generateFieldName = ({
     func,
     query
   }) => {
@@ -552,8 +378,8 @@ var FlowList = (function (exports) {
     const fn = ((params) => options.fetcher(params));
     const metadata = {
       id: options.id,
-      type: options.type || enum_default.FETCH_TYPE.SCROLL_LOAD_MORE,
-      uniqueKey: options.uniqueKey || enum_default.DEFAULT_UNIQUE_KEY_NAME,
+      type: options.type || constants_default.FETCH_TYPE.SCROLL_LOAD_MORE,
+      uniqueKey: options.uniqueKey || constants_default.DEFAULT_UNIQUE_KEY_NAME,
       is_up: options.is_up || false,
       paramsIgnore: [
         "page",
@@ -574,11 +400,11 @@ var FlowList = (function (exports) {
     opts
   }) => {
     return new Promise((resolve) => {
-      const fieldName = generateFieldName2({ func, query });
+      const fieldName = generateFieldName({ func, query });
       if (getter(fieldName)) return resolve();
       setter({
         key: fieldName,
-        type: enum_default.SETTER_TYPE.RESET,
+        type: constants_default.SETTER_TYPE.RESET,
         value: generateDefaultField(opts),
         callback: () => resolve()
       });
@@ -591,7 +417,7 @@ var FlowList = (function (exports) {
     query,
     callback
   }) => new Promise((resolve, reject) => {
-    const fieldName = generateFieldName2({ func, query });
+    const fieldName = generateFieldName({ func, query });
     const fieldData = getter(fieldName);
     const doRefresh = !!query?.__refresh__;
     const needReset = !!query?.__reload__;
@@ -625,7 +451,7 @@ var FlowList = (function (exports) {
         if (directlyLoadData) {
           setter({
             key: fieldName,
-            type: enum_default.SETTER_TYPE.RESET,
+            type: constants_default.SETTER_TYPE.RESET,
             value: generateDefaultField(),
             callback: commitData
           });
@@ -642,7 +468,7 @@ var FlowList = (function (exports) {
     } else {
       setter({
         key: fieldName,
-        type: enum_default.SETTER_TYPE.RESET,
+        type: constants_default.SETTER_TYPE.RESET,
         value: { ...generateDefaultField(), loading: true, error: null },
         callback: executeFetch
       });
@@ -656,15 +482,15 @@ var FlowList = (function (exports) {
     errorRetry,
     callback
   }) => new Promise((resolve, reject) => {
-    const fieldName = generateFieldName2({ func, query });
+    const fieldName = generateFieldName({ func, query });
     const fieldData = getter(fieldName);
     if (!fieldData || fieldData.loading || fieldData.nothing) return resolve();
     if (fieldData.noMore && !errorRetry) return resolve();
     const type = func.type;
-    if (type === enum_default.FETCH_TYPE.PAGINATION && query?.page != null && Number(query.page) === fieldData.page) {
+    if (type === constants_default.FETCH_TYPE.PAGINATION && query?.page != null && Number(query.page) === fieldData.page) {
       return resolve();
     }
-    const loadingState = type === enum_default.FETCH_TYPE.PAGINATION ? { loading: true, error: null, result: [], extra: null } : { loading: true, error: null };
+    const loadingState = type === constants_default.FETCH_TYPE.PAGINATION ? { loading: true, error: null, result: [], extra: null } : { loading: true, error: null };
     const params = generateRequestParams({
       field: fieldData,
       uniqueKey: func.uniqueKey,
@@ -675,7 +501,7 @@ var FlowList = (function (exports) {
     if (fieldData.extra) params.extra = fieldData.extra;
     setter({
       key: fieldName,
-      type: enum_default.SETTER_TYPE.MERGE,
+      type: constants_default.SETTER_TYPE.MERGE,
       value: loadingState,
       callback: () => {
         func(params).then((data) => {
@@ -698,198 +524,240 @@ var FlowList = (function (exports) {
       }
     });
   });
-  var updateState = ({
-    getter,
-    setter,
-    func,
-    query,
-    method,
-    id,
-    value,
-    changeKey
-  }) => {
-    return new Promise((resolve, reject) => {
-      const fieldName = generateFieldName2({ func, query });
-      const fieldData = getter(fieldName);
-      if (!fieldData) {
-        reject(new Error(`Field ${fieldName} not found.`));
-        return;
-      }
-      if (fieldData.page === -1) {
-        resolve(null);
-        return;
-      }
-      const _id = id;
-      const _uniqueKey = func.uniqueKey || enum_default.DEFAULT_UNIQUE_KEY_NAME;
-      const _changeKey = changeKey || enum_default.FIELD_DATA.RESULT_KEY;
-      const beforeLength = computeResultLength(
-        fieldData[enum_default.FIELD_DATA.RESULT_KEY]
+
+  // src/mutations/core.ts
+  var pushHandler = (ctx) => {
+    if (!isArray(ctx.resultArray)) return;
+    return {
+      modifyValue: isArray(ctx.value) ? [...ctx.resultArray, ...ctx.value] : [...ctx.resultArray, ctx.value]
+    };
+  };
+  var unshiftHandler = (ctx) => {
+    if (!isArray(ctx.resultArray)) return;
+    return {
+      modifyValue: isArray(ctx.value) ? [...ctx.value, ...ctx.resultArray] : [ctx.value, ...ctx.resultArray]
+    };
+  };
+  var deleteHandler = (ctx) => {
+    if (!isKeyMapArray(ctx.resultArray)) return;
+    const objectKeyId = toObjectKey(ctx._id);
+    if (objectKeyId !== void 0) {
+      const matchedIndex = computeMatchedItemIndex(
+        objectKeyId,
+        ctx.resultArray,
+        ctx._uniqueKey
       );
-      const newFieldData = { ...fieldData };
-      let resultArray = getResultAsArray(fieldData);
-      if (resultArray) {
-        resultArray = [...resultArray];
-        newFieldData.result = resultArray;
+      if (matchedIndex >= 0) {
+        const newArray = [...ctx.resultArray];
+        newArray.splice(matchedIndex, 1);
+        return { modifyValue: newArray };
       }
-      if (method === enum_default.CHANGE_TYPE.SEARCH_FIELD) {
-        const objectKeyId = toObjectKey(_id);
-        if (objectKeyId === void 0) {
-          reject(new Error("ID is required for SEARCH_FIELD."));
+    }
+    if (isObjectKeyArray(ctx._id)) {
+      const idSet = new Set(ctx._id);
+      return {
+        modifyValue: ctx.resultArray.filter((item) => {
+          const itemKey = getObjectDeepValue(item, ctx._uniqueKey);
+          return typeof itemKey !== "string" && typeof itemKey !== "number" ? true : !idSet.has(itemKey);
+        })
+      };
+    }
+    return void 0;
+  };
+  var mergeHandler = (ctx) => {
+    const objectKeyId = toObjectKey(ctx._id);
+    if (objectKeyId === void 0 || !ctx.resultArray || !isKeyMap(ctx.value))
+      return;
+    const matchedIndex = computeMatchedItemIndex(
+      objectKeyId,
+      ctx.resultArray,
+      ctx._uniqueKey
+    );
+    updateArrayItem(ctx.resultArray, matchedIndex, (item) => ({
+      ...item,
+      ...ctx.value
+    }));
+  };
+  var resetHandler = (ctx) => {
+    if (ctx._changeKey === constants_default.FIELD_DATA.RESULT_KEY && isKeyMapArray(ctx.value)) {
+      ctx.newFieldData.result = ctx.value;
+    } else if (ctx._changeKey === constants_default.FIELD_DATA.EXTRA_KEY && isKeyMap(ctx.value)) {
+      ctx.newFieldData.extra = ctx.value;
+    }
+  };
+  var coreMutations = {
+    [constants_default.CHANGE_TYPE.RESULT_ADD_AFTER]: pushHandler,
+    [constants_default.CHANGE_TYPE.RESULT_ADD_BEFORE]: unshiftHandler,
+    [constants_default.CHANGE_TYPE.RESULT_REMOVE_BY_ID]: deleteHandler,
+    [constants_default.CHANGE_TYPE.RESULT_ITEM_MERGE]: mergeHandler,
+    [constants_default.CHANGE_TYPE.RESET_FIELD]: resetHandler
+  };
+
+  // src/mutations/extended.ts
+  var searchHandler = (ctx) => {
+    const objectKeyId = toObjectKey(ctx._id);
+    if (objectKeyId === void 0) return;
+    const searchResult = ctx.resultArray ? searchValueByKey(ctx.resultArray, objectKeyId, ctx._uniqueKey) : void 0;
+    return { resolved: searchResult };
+  };
+  var updateKVHandler = (ctx) => {
+    const objectKeyId = toObjectKey(ctx._id);
+    if (objectKeyId === void 0 || !ctx.resultArray) return;
+    const matchedIndex = computeMatchedItemIndex(
+      objectKeyId,
+      ctx.resultArray,
+      ctx._uniqueKey
+    );
+    if (matchedIndex >= 0 && isKeyMap(ctx.resultArray[matchedIndex])) {
+      const newItem = { ...ctx.resultArray[matchedIndex] };
+      updateObjectDeepValue(newItem, ctx._changeKey, ctx.value);
+      ctx.resultArray[matchedIndex] = newItem;
+    }
+  };
+  var insertBeforeHandler = (ctx) => {
+    const objectKeyId = toObjectKey(ctx._id);
+    if (!isArray(ctx.resultArray) || objectKeyId === void 0) return void 0;
+    const matchedIndex = computeMatchedItemIndex(
+      objectKeyId,
+      ctx.resultArray,
+      ctx._uniqueKey
+    );
+    if (matchedIndex >= 0) {
+      const newArray = [...ctx.resultArray];
+      newArray.splice(matchedIndex, 0, ctx.value);
+      return { modifyValue: newArray };
+    }
+    return void 0;
+  };
+  var insertAfterHandler = (ctx) => {
+    const objectKeyId = toObjectKey(ctx._id);
+    if (!isArray(ctx.resultArray) || objectKeyId === void 0) return void 0;
+    const matchedIndex = computeMatchedItemIndex(
+      objectKeyId,
+      ctx.resultArray,
+      ctx._uniqueKey
+    );
+    if (matchedIndex >= 0) {
+      const newArray = [...ctx.resultArray];
+      newArray.splice(matchedIndex + 1, 0, ctx.value);
+      return { modifyValue: newArray };
+    }
+    return void 0;
+  };
+  var patchHandler = (ctx) => {
+    if (!isKeyMapArray(ctx.resultArray)) return;
+    const newArray = [...ctx.resultArray];
+    if (isKeyMapArray(ctx.value)) {
+      combineArrayData(newArray, ctx.value, ctx._uniqueKey);
+    } else if (isKeyMap(ctx.value)) {
+      const valueAsRecord = {};
+      for (const [k, v] of Object.entries(ctx.value)) {
+        if (isKeyMap(v)) valueAsRecord[k] = v;
+      }
+      combineArrayData(newArray, valueAsRecord, ctx._uniqueKey);
+    }
+    return { modifyValue: newArray };
+  };
+  var extendedMutations = {
+    [constants_default.CHANGE_TYPE.SEARCH_FIELD]: searchHandler,
+    [constants_default.CHANGE_TYPE.RESULT_UPDATE_KV]: updateKVHandler,
+    [constants_default.CHANGE_TYPE.RESULT_INSERT_TO_BEFORE]: insertBeforeHandler,
+    [constants_default.CHANGE_TYPE.RESULT_INSERT_TO_AFTER]: insertAfterHandler,
+    [constants_default.CHANGE_TYPE.RESULT_LIST_MERGE]: patchHandler
+  };
+
+  // src/mutations/index.ts
+  var allMutations = {
+    ...coreMutations,
+    ...extendedMutations
+  };
+  var createUpdateState = (handlers = allMutations) => {
+    return ({
+      getter,
+      setter,
+      func,
+      query,
+      method,
+      id,
+      value,
+      changeKey
+    }) => {
+      return new Promise((resolve, reject) => {
+        const fieldName = generateFieldName({ func, query });
+        const fieldData = getter(fieldName);
+        if (!fieldData) {
+          reject(new Error(`Field ${fieldName} not found.`));
           return;
         }
-        const searchResult = resultArray ? searchValueByKey(resultArray, objectKeyId, _uniqueKey) : void 0;
-        resolve(searchResult);
-        return;
-      } else if (method === enum_default.CHANGE_TYPE.RESULT_UPDATE_KV) {
-        const objectKeyId = toObjectKey(_id);
-        if (objectKeyId === void 0) {
-          reject(new Error("ID is required for RESULT_UPDATE_KV."));
+        if (fieldData.page === -1) {
+          resolve(null);
           return;
         }
+        const _uniqueKey = func.uniqueKey || constants_default.DEFAULT_UNIQUE_KEY_NAME;
+        const _changeKey = changeKey || constants_default.FIELD_DATA.RESULT_KEY;
+        const beforeLength = computeResultLength(
+          fieldData[constants_default.FIELD_DATA.RESULT_KEY]
+        );
+        const newFieldData = { ...fieldData };
+        let resultArray = getResultAsArray(fieldData);
         if (resultArray) {
-          const matchedIndex = computeMatchedItemIndex(
-            objectKeyId,
-            resultArray,
-            _uniqueKey
-          );
-          if (matchedIndex >= 0 && isKeyMap(resultArray[matchedIndex])) {
-            const newItem = { ...resultArray[matchedIndex] };
-            updateObjectDeepValue(newItem, _changeKey, value);
-            resultArray[matchedIndex] = newItem;
-          }
+          resultArray = [...resultArray];
+          newFieldData.result = resultArray;
         }
-        resolve(null);
-      } else if (method === enum_default.CHANGE_TYPE.RESULT_ITEM_MERGE) {
-        const objectKeyId = toObjectKey(_id);
-        if (objectKeyId === void 0) {
-          reject(new Error("ID is required for RESULT_ITEM_MERGE."));
+        const handler = handlers[method];
+        if (!handler) {
+          resolve(null);
           return;
         }
-        if (resultArray && isKeyMap(value)) {
-          const matchedIndex = computeMatchedItemIndex(
-            objectKeyId,
-            resultArray,
-            _uniqueKey
-          );
-          updateArrayItem(resultArray, matchedIndex, (item) => ({
-            ...item,
-            ...value
-          }));
-        }
-        resolve(null);
-      } else if (method === enum_default.CHANGE_TYPE.RESET_FIELD) {
-        if (_changeKey === enum_default.FIELD_DATA.RESULT_KEY && isKeyMapArray(value)) {
-          newFieldData.result = value;
-        } else if (_changeKey === enum_default.FIELD_DATA.EXTRA_KEY && isKeyMap(value)) {
-          newFieldData.extra = value;
-        }
-        resolve(null);
-      } else {
-        let modifyValue;
-        if (_changeKey === enum_default.FIELD_DATA.RESULT_KEY) {
-          modifyValue = resultArray || newFieldData.result;
-        } else if (_changeKey === enum_default.FIELD_DATA.EXTRA_KEY) {
-          modifyValue = newFieldData.extra;
-        } else {
-          modifyValue = getObjectDeepValue(newFieldData, _changeKey);
-        }
-        if (modifyValue == null) {
-          modifyValue = [];
-        }
-        const objectKeyId = toObjectKey(_id);
-        const matchedIndex = objectKeyId !== void 0 && isKeyMapArray(modifyValue) ? computeMatchedItemIndex(objectKeyId, modifyValue, _uniqueKey) : -1;
-        switch (method) {
-          case enum_default.CHANGE_TYPE.RESULT_ADD_AFTER:
-            if (isArray(modifyValue)) {
-              modifyValue = isArray(value) ? [...modifyValue, ...value] : [...modifyValue, value];
-            }
-            break;
-          case enum_default.CHANGE_TYPE.RESULT_ADD_BEFORE:
-            if (isArray(modifyValue)) {
-              modifyValue = isArray(value) ? [...value, ...modifyValue] : [value, ...modifyValue];
-            }
-            break;
-          case enum_default.CHANGE_TYPE.RESULT_REMOVE_BY_ID:
-            if (isKeyMapArray(modifyValue)) {
-              if (matchedIndex >= 0) {
-                const newArray = [...modifyValue];
-                newArray.splice(matchedIndex, 1);
-                modifyValue = newArray;
-              } else if (isObjectKeyArray(_id)) {
-                const idSet = new Set(_id);
-                modifyValue = modifyValue.filter((item) => {
-                  const itemKey = getObjectDeepValue(item, _uniqueKey);
-                  return !isObjectKey(itemKey) || !idSet.has(itemKey);
-                });
-              }
-            }
-            break;
-          case enum_default.CHANGE_TYPE.RESULT_INSERT_TO_BEFORE:
-            if (isArray(modifyValue) && matchedIndex >= 0) {
-              const newArray = [...modifyValue];
-              newArray.splice(matchedIndex, 0, value);
-              modifyValue = newArray;
-            }
-            break;
-          case enum_default.CHANGE_TYPE.RESULT_INSERT_TO_AFTER:
-            if (isArray(modifyValue) && matchedIndex >= 0) {
-              const newArray = [...modifyValue];
-              newArray.splice(matchedIndex + 1, 0, value);
-              modifyValue = newArray;
-            }
-            break;
-          case enum_default.CHANGE_TYPE.RESULT_LIST_MERGE:
-            if (isKeyMapArray(modifyValue)) {
-              const newArray = [...modifyValue];
-              if (isKeyMapArray(value)) {
-                combineArrayData(newArray, value, _uniqueKey);
-              } else if (isKeyMap(value)) {
-                const valueAsRecord = {};
-                for (const [k, v] of Object.entries(value)) {
-                  if (isKeyMap(v)) {
-                    valueAsRecord[k] = v;
-                  }
-                }
-                combineArrayData(newArray, valueAsRecord, _uniqueKey);
-              }
-              modifyValue = newArray;
-            }
-            break;
-          default:
-            resolve(null);
+        const ctx = {
+          resultArray,
+          newFieldData,
+          _id: id,
+          _uniqueKey,
+          _changeKey,
+          value
+        };
+        const handlerResult = handler(ctx);
+        if (handlerResult) {
+          if ("resolved" in handlerResult) {
+            resolve(handlerResult.resolved);
             return;
+          }
+          if ("modifyValue" in handlerResult && handlerResult.modifyValue !== void 0) {
+            const modifyValue = handlerResult.modifyValue;
+            if (_changeKey === constants_default.FIELD_DATA.RESULT_KEY && isKeyMapArray(modifyValue)) {
+              newFieldData.result = modifyValue;
+            } else if (_changeKey === constants_default.FIELD_DATA.EXTRA_KEY && isKeyMap(modifyValue)) {
+              newFieldData.extra = modifyValue;
+            }
+          }
         }
-        if (_changeKey === enum_default.FIELD_DATA.RESULT_KEY && isKeyMapArray(modifyValue)) {
-          newFieldData.result = modifyValue;
-        } else if (_changeKey === enum_default.FIELD_DATA.EXTRA_KEY && isKeyMap(modifyValue)) {
-          newFieldData.extra = modifyValue;
-        }
-        resolve(null);
-      }
-      const afterLength = computeResultLength(
-        newFieldData[enum_default.FIELD_DATA.RESULT_KEY]
-      );
-      newFieldData.total = newFieldData.total + afterLength - beforeLength;
-      newFieldData.nothing = afterLength === 0;
-      setter({
-        key: fieldName,
-        type: enum_default.SETTER_TYPE.RESET,
-        value: newFieldData,
-        callback: () => {
-          resolve(null);
-        }
+        const afterLength = computeResultLength(
+          newFieldData[constants_default.FIELD_DATA.RESULT_KEY]
+        );
+        newFieldData.total = newFieldData.total + afterLength - beforeLength;
+        newFieldData.nothing = afterLength === 0;
+        setter({
+          key: fieldName,
+          type: constants_default.SETTER_TYPE.RESET,
+          value: newFieldData,
+          callback: () => resolve(null)
+        });
       });
-    });
+    };
   };
+  var updateState = createUpdateState();
 
-  exports.ENUM = enum_default;
+  exports.ENUM = constants_default;
+  exports.coreMutations = coreMutations;
   exports.createApi = createApi;
-  exports.generateFieldName = generateFieldName2;
+  exports.createUpdateState = createUpdateState;
+  exports.extendedMutations = extendedMutations;
+  exports.generateFieldName = generateFieldName;
   exports.initData = initData;
   exports.initState = initState;
   exports.loadMore = loadMore;
   exports.updateState = updateState;
-  exports.utils = utils_exports;
 
   return exports;