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

package/dist/index.js

@@ -1,14 +1,8 @@
 '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
@@ -40,104 +34,63 @@ var enum_default = {
   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,
@@ -148,73 +101,33 @@ var generateDefaultField = (opts = {}) => ({
   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) => {
@@ -222,237 +135,154 @@ var searchValueByKey = (result, id, key) => {
     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,
@@ -471,7 +301,8 @@ var SET_DATA = ({
     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;
@@ -485,7 +316,7 @@ var SET_DATA = ({
       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 {
@@ -496,7 +327,7 @@ var SET_DATA = ({
     field.loading = false;
     setReactivityField(
       field,
-      enum_default.FIELD_DATA.RESULT_KEY,
+      constants_default.FIELD_DATA.RESULT_KEY,
       result,
       type,
       insertBefore
@@ -504,7 +335,7 @@ var SET_DATA = ({
     if (extra !== void 0 && extra !== null) {
       setReactivityField(
         field,
-        enum_default.FIELD_DATA.EXTRA_KEY,
+        constants_default.FIELD_DATA.EXTRA_KEY,
         extra,
         type,
         insertBefore
@@ -512,27 +343,22 @@ var SET_DATA = ({
     }
     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
 }) => {
@@ -551,8 +377,8 @@ var createApi = (options) => {
   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",
@@ -573,11 +399,11 @@ var initState = ({
   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()
     });
@@ -590,7 +416,7 @@ var initData = ({
   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__;
@@ -624,7 +450,7 @@ var initData = ({
       if (directlyLoadData) {
         setter({
           key: fieldName,
-          type: enum_default.SETTER_TYPE.RESET,
+          type: constants_default.SETTER_TYPE.RESET,
           value: generateDefaultField(),
           callback: commitData
         });
@@ -641,7 +467,7 @@ var initData = ({
   } else {
     setter({
       key: fieldName,
-      type: enum_default.SETTER_TYPE.RESET,
+      type: constants_default.SETTER_TYPE.RESET,
       value: { ...generateDefaultField(), loading: true, error: null },
       callback: executeFetch
     });
@@ -655,15 +481,15 @@ var loadMore = ({
   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,
@@ -674,7 +500,7 @@ var loadMore = ({
   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) => {
@@ -697,197 +523,239 @@ var loadMore = ({
     }
   });
 });
-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;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map