@flowlist/js-core 2.3.0 → 3.0.0

package/dist/index.global.js

@@ -0,0 +1,771 @@
+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/utils.ts
+  var utils_exports = {};
+  __export(utils_exports, {
+    combineArrayData: () => combineArrayData,
+    computeMatchedItemIndex: () => computeMatchedItemIndex,
+    computeResultLength: () => computeResultLength,
+    generateDefaultField: () => generateDefaultField,
+    generateFieldName: () => generateFieldName,
+    generateRequestParams: () => generateRequestParams,
+    getObjectDeepValue: () => getObjectDeepValue,
+    isArray: () => isArray,
+    isObjectResult: () => isObjectResult,
+    searchValueByKey: () => searchValueByKey,
+    setReactivityField: () => setReactivityField,
+    updateObjectDeepValue: () => updateObjectDeepValue
+  });
+
+  // src/enum.ts
+  var FETCH_TYPE_ARRAY = ["jump", "sinceId", "page", "seenIds", "auto"];
+  var enum_default = {
+    SETTER_TYPE: {
+      RESET: 0,
+      MERGE: 1
+    },
+    FETCH_TYPE_ARRAY,
+    FETCH_TYPE: {
+      PAGINATION: FETCH_TYPE_ARRAY[0],
+      SINCE_FIRST_OR_END_ID: FETCH_TYPE_ARRAY[1],
+      SCROLL_LOAD_MORE: FETCH_TYPE_ARRAY[2],
+      HAS_LOADED_IDS: FETCH_TYPE_ARRAY[3],
+      AUTO: FETCH_TYPE_ARRAY[4]
+    },
+    CHANGE_TYPE: {
+      SEARCH_FIELD: "search",
+      RESET_FIELD: "reset",
+      RESULT_UPDATE_KV: "update",
+      RESULT_ADD_AFTER: "push",
+      RESULT_ADD_BEFORE: "unshift",
+      RESULT_REMOVE_BY_ID: "delete",
+      RESULT_INSERT_TO_BEFORE: "insert-before",
+      RESULT_INSERT_TO_AFTER: "insert-after",
+      RESULT_LIST_MERGE: "patch",
+      RESULT_ITEM_MERGE: "merge"
+    },
+    FIELD_DATA: {
+      RESULT_KEY: "result",
+      EXTRA_KEY: "extra"
+    },
+    DEFAULT_UNIQUE_KEY_NAME: "id"
+  };
+
+  // src/utils.ts
+  var isObjectResult = (data) => {
+    if (typeof data !== "object" || data === null) {
+      return false;
+    }
+    return !Object.prototype.hasOwnProperty.call(data, "result");
+  };
+  var generateDefaultField = (opts = {}) => ({
+    ...{
+      result: [],
+      // 用户需要确保 T 是兼容的类型，例如 T extends unknown[]
+      noMore: false,
+      nothing: false,
+      loading: false,
+      error: null,
+      extra: null,
+      fetched: false,
+      page: 0,
+      total: 0
+    },
+    ...opts
+  });
+  var generateFieldName = ({
+    func,
+    type,
+    query = {}
+  }) => {
+    const funcName = typeof func === "string" ? func : `api-${Math.random().toString(36).substring(2)}`;
+    const fetchType = type || "auto";
+    let result = `${funcName}-${fetchType}`;
+    const filteredKeys = Object.keys(query).filter(
+      (key) => !["undefined", "object", "function"].includes(typeof query[key]) && ![
+        "page",
+        "is_up",
+        "since_id",
+        "seen_ids",
+        "__refresh__",
+        "__reload__"
+      ].includes(key)
+    );
+    filteredKeys.sort().forEach((key) => {
+      result += `-${key}-${query[key]}`;
+    });
+    return result;
+  };
+  var getObjectDeepValue = (field, keys = "") => {
+    if (!keys || Array.isArray(keys) && keys.length === 0) {
+      return field;
+    }
+    const keysArr = Array.isArray(keys) ? keys : keys.split(".");
+    let result = field;
+    for (const key of keysArr) {
+      if (result == null || typeof result !== "object") {
+        return void 0;
+      }
+      result = result[key];
+    }
+    return result;
+  };
+  var updateObjectDeepValue = (field, changeKey, value) => {
+    if (!changeKey) return;
+    const keys = changeKey.split(".");
+    const lastKey = keys.pop();
+    let current = field;
+    for (const key of keys) {
+      if (current == null || typeof current !== "object") {
+        current[key] = {};
+      }
+      current = current[key];
+    }
+    if (current != null && typeof current === "object") {
+      current[lastKey] = value;
+    }
+  };
+  var searchValueByKey = (result, id, key) => {
+    if (isArray(result)) {
+      const index = computeMatchedItemIndex(id, result, key);
+      return index >= 0 ? result[index] : void 0;
+    } else {
+      return result[id];
+    }
+  };
+  var computeMatchedItemIndex = (itemId, fieldArr, changingKey) => {
+    const stringifiedItemId = String(itemId);
+    const len = fieldArr?.length;
+    if (typeof len !== "number" || len <= 0) return -1;
+    for (let i = 0; i < len; i++) {
+      const item = fieldArr[i];
+      if (typeof item !== "object" || item === null) continue;
+      const itemValue = getObjectDeepValue(item, changingKey);
+      if (String(itemValue) === stringifiedItemId) {
+        return i;
+      }
+    }
+    return -1;
+  };
+  var combineArrayData = (fieldArray, value, changingKey) => {
+    if (isArray(value)) {
+      for (const col of value) {
+        if (typeof col !== "object" || col === null) continue;
+        const stringifyId = String(getObjectDeepValue(col, changingKey));
+        const index = fieldArray.findIndex(
+          (item) => typeof item === "object" && item !== null && String(getObjectDeepValue(item, changingKey)) === stringifyId
+        );
+        if (index !== -1) {
+          fieldArray[index] = { ...fieldArray[index], ...col };
+        }
+      }
+    } else {
+      for (const [uniqueId, col] of Object.entries(value)) {
+        if (typeof col !== "object" || col === null) continue;
+        const stringifyId = String(uniqueId);
+        const index = fieldArray.findIndex(
+          (item) => typeof item === "object" && item !== null && String(getObjectDeepValue(item, changingKey)) === stringifyId
+        );
+        if (index !== -1) {
+          fieldArray[index] = { ...fieldArray[index], ...col };
+        }
+      }
+    }
+  };
+  var isArray = (data) => {
+    return Array.isArray(data);
+  };
+  var setReactivityField = (field, key, value, type, insertBefore) => {
+    if (type === enum_default.FETCH_TYPE.PAGINATION) {
+      field[key] = value;
+      return;
+    }
+    if (isArray(value)) {
+      const current = field[key];
+      const currentArr = isArray(current) ? current : [];
+      const newValue = insertBefore ? value.concat(currentArr) : currentArr.concat(value);
+      field[key] = newValue;
+      return;
+    }
+    if (key !== enum_default.FIELD_DATA.RESULT_KEY) {
+      field[key] = value;
+      return;
+    }
+    const resultField = field.result;
+    if (isArray(resultField)) {
+      field.result = {};
+    }
+    const valueObj = value;
+    const target = field.result;
+    Object.keys(valueObj).forEach((subKey) => {
+      const existing = target[subKey];
+      const incoming = valueObj[subKey];
+      if (existing !== void 0) {
+        if (insertBefore) {
+          target[subKey] = isArray(incoming) && isArray(existing) ? incoming.concat(existing) : incoming;
+        } else {
+          target[subKey] = isArray(existing) && isArray(incoming) ? existing.concat(incoming) : incoming;
+        }
+      } else {
+        target[subKey] = incoming;
+      }
+    });
+  };
+  var computeResultLength = (data) => {
+    if (isArray(data)) {
+      return data.length;
+    }
+    if (data && typeof data === "object") {
+      return Object.values(data).reduce((acc, val) => {
+        if (isArray(val)) {
+          return acc + val.length;
+        }
+        return acc;
+      }, 0);
+    }
+    return 0;
+  };
+  var generateRequestParams = ({
+    field,
+    uniqueKey,
+    query = {},
+    type
+  }) => {
+    const result = {};
+    const changing = uniqueKey || enum_default.DEFAULT_UNIQUE_KEY_NAME;
+    const isFetched = field.fetched;
+    const getSafeObjectKey = (item) => {
+      if (typeof item !== "object" || item === null) return void 0;
+      const val = getObjectDeepValue(item, changing);
+      if (typeof val === "string" || typeof val === "number") {
+        return val;
+      }
+      return void 0;
+    };
+    if (isFetched) {
+      if (type === enum_default.FETCH_TYPE.AUTO) {
+        if (isArray(field.result)) {
+          result.seen_ids = field.result.map((item) => getSafeObjectKey(item)).filter((id) => id !== void 0).join(",");
+          const targetIndex = query.is_up ? 0 : field.result.length - 1;
+          const targetItem = field.result[targetIndex];
+          result.since_id = getSafeObjectKey(targetItem);
+        }
+        result.is_up = query.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(field.result)) {
+          result.seen_ids = field.result.map((item) => getSafeObjectKey(item)).filter((id) => id !== void 0).join(",");
+        }
+      } else if (type === enum_default.FETCH_TYPE.SINCE_FIRST_OR_END_ID) {
+        if (isArray(field.result)) {
+          const targetIndex = query.is_up ? 0 : field.result.length - 1;
+          const targetItem = field.result[targetIndex];
+          result.since_id = getSafeObjectKey(targetItem);
+        }
+        result.is_up = query.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;
+      }
+    } else {
+      if (type === enum_default.FETCH_TYPE.AUTO) {
+        result.seen_ids = "";
+        result.since_id = typeof query.sinceId === "string" || typeof query.sinceId === "number" ? query.sinceId : query.is_up ? 999999999 : 0;
+        result.is_up = query.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 = typeof query.sinceId === "string" || typeof query.sinceId === "number" ? query.sinceId : query.is_up ? 999999999 : 0;
+        result.is_up = query.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;
+      }
+    }
+    return {
+      ...query,
+      ...result
+    };
+  };
+
+  // src/setters.ts
+  var SET_DATA = ({
+    getter,
+    setter,
+    data,
+    fieldName,
+    type,
+    page,
+    insertBefore
+  }) => {
+    return new Promise((resolve, reject) => {
+      const fieldData = getter(fieldName);
+      if (!fieldData) {
+        reject(new Error(`Field ${fieldName} not found.`));
+        return;
+      }
+      const field = fieldData;
+      let result;
+      let extra;
+      if (isObjectResult(data)) {
+        result = data;
+        field.nothing = false;
+        field.fetched = true;
+        field.noMore = true;
+        field.page = -1;
+      } else {
+        const apiResponse = data;
+        result = apiResponse.result;
+        extra = apiResponse.extra;
+        const isEmpty = computeResultLength(result) === 0;
+        field.nothing = field.fetched ? false : isEmpty;
+        field.fetched = true;
+        field.total = apiResponse.total || 0;
+        if (type === enum_default.FETCH_TYPE.PAGINATION) {
+          field.noMore = false;
+          field.page = +page;
+        } else {
+          field.noMore = typeof apiResponse.no_more === "undefined" ? isEmpty : apiResponse.no_more || isEmpty;
+          field.page = field.page + 1;
+        }
+      }
+      field.loading = false;
+      setReactivityField(
+        field,
+        enum_default.FIELD_DATA.RESULT_KEY,
+        result,
+        type,
+        insertBefore
+      );
+      if (extra !== void 0 && extra !== null) {
+        setReactivityField(
+          field,
+          enum_default.FIELD_DATA.EXTRA_KEY,
+          extra,
+          type,
+          insertBefore
+        );
+      }
+      setter({
+        key: fieldName,
+        type: enum_default.SETTER_TYPE.RESET,
+        // or MUTATE if you have such type
+        value: field,
+        // same reference
+        callback: () => {
+          resolve();
+        }
+      });
+    });
+  };
+  var SET_ERROR = ({ setter, fieldName, error }) => {
+    setter({
+      key: fieldName,
+      type: enum_default.SETTER_TYPE.MERGE,
+      value: {
+        error,
+        loading: false
+      }
+    });
+  };
+
+  // src/actions.ts
+  var initState = ({
+    getter,
+    setter,
+    func,
+    // string only
+    type,
+    query,
+    opts
+  }) => {
+    return new Promise((resolve) => {
+      const fieldName = generateFieldName({ func, type, query });
+      const fieldData = getter(fieldName);
+      if (fieldData) {
+        resolve();
+        return;
+      }
+      setter({
+        key: fieldName,
+        type: enum_default.SETTER_TYPE.RESET,
+        value: generateDefaultField(opts),
+        callback: () => {
+          resolve();
+        }
+      });
+    });
+  };
+  var initData = ({
+    getter,
+    setter,
+    func,
+    // string | function
+    type,
+    query,
+    api,
+    uniqueKey,
+    callback
+  }) => new Promise((resolve, reject) => {
+    const fieldName = generateFieldName({ func, type, query });
+    const fieldData = getter(fieldName);
+    const doRefresh = !!query?.__refresh__;
+    const needReset = !!query?.__reload__;
+    if (fieldData && fieldData.error && !doRefresh) {
+      resolve();
+      return;
+    }
+    if (fieldData && fieldData.loading) {
+      resolve();
+      return;
+    }
+    const dontFetch = fieldData && fieldData.fetched && !doRefresh;
+    if (dontFetch) {
+      resolve();
+      return;
+    }
+    const params = generateRequestParams({
+      field: {
+        ...fieldData || generateDefaultField(),
+        fetched: false
+      },
+      uniqueKey,
+      query,
+      type
+    });
+    const getData = () => {
+      const loadData = () => new Promise((res, rej) => {
+        const getDataFromAPI = () => {
+          const funcCaller = typeof func === "string" ? api[func] : func;
+          funcCaller(params).then(res).catch((error) => {
+            SET_ERROR({ setter, fieldName, error });
+            rej(error);
+          });
+        };
+        getDataFromAPI();
+      });
+      loadData().then((data) => {
+        const setData = () => {
+          SET_DATA({
+            getter,
+            setter,
+            data,
+            fieldName,
+            type,
+            page: params.page || 0,
+            insertBefore: false
+          }).then(() => {
+            if (callback) {
+              callback({
+                params,
+                data,
+                // <-- 'data' is now properly in scope
+                refresh: doRefresh
+              });
+            }
+            resolve();
+          });
+        };
+        if (needReset) {
+          setter({
+            key: fieldName,
+            type: enum_default.SETTER_TYPE.RESET,
+            value: generateDefaultField(),
+            callback: setData
+          });
+        } else {
+          setData();
+        }
+      }).catch(reject);
+    };
+    if (!dontFetch && !needReset) {
+      setter({
+        key: fieldName,
+        type: enum_default.SETTER_TYPE.RESET,
+        value: {
+          ...generateDefaultField(),
+          loading: true,
+          error: null
+        },
+        callback: getData
+      });
+    } else {
+      getData();
+    }
+  });
+  var loadMore = ({
+    getter,
+    setter,
+    query,
+    type,
+    func,
+    // string | function
+    api,
+    uniqueKey,
+    errorRetry,
+    callback
+  }) => new Promise((resolve, reject) => {
+    const fieldName = generateFieldName({ func, type, query });
+    const fieldData = getter(fieldName);
+    if (!fieldData) {
+      resolve();
+      return;
+    }
+    if (fieldData.loading) {
+      resolve();
+      return;
+    }
+    if (fieldData.nothing) {
+      resolve();
+      return;
+    }
+    if (fieldData.noMore && !errorRetry) {
+      resolve();
+      return;
+    }
+    if (type === enum_default.FETCH_TYPE.PAGINATION && query && query.page != null && +query.page === fieldData.page) {
+      resolve();
+      return;
+    }
+    let loadingState;
+    if (type === enum_default.FETCH_TYPE.PAGINATION) {
+      loadingState = {
+        loading: true,
+        error: null,
+        [enum_default.FIELD_DATA.RESULT_KEY]: [],
+        [enum_default.FIELD_DATA.EXTRA_KEY]: null
+      };
+    } else {
+      loadingState = {
+        loading: true,
+        error: null
+      };
+    }
+    const params = generateRequestParams({
+      field: fieldData,
+      uniqueKey,
+      query,
+      type
+    });
+    if ("extra" in fieldData) {
+      params[enum_default.FIELD_DATA.EXTRA_KEY] = fieldData.extra;
+    }
+    const getData = () => {
+      const funcCaller = typeof func === "string" ? api[func] : func;
+      funcCaller(params).then((data) => {
+        SET_DATA({
+          getter,
+          setter,
+          data,
+          fieldName,
+          type,
+          page: params.page || 0,
+          insertBefore: !!query?.is_up
+        }).then(() => {
+          if (callback) {
+            callback({
+              params,
+              data,
+              refresh: false
+            });
+          }
+          resolve();
+        });
+      }).catch((error) => {
+        SET_ERROR({ setter, fieldName, error });
+        reject(error);
+      });
+    };
+    setter({
+      key: fieldName,
+      type: enum_default.SETTER_TYPE.MERGE,
+      value: loadingState,
+      callback: getData
+    });
+  });
+  var updateState = ({
+    getter,
+    setter,
+    func,
+    // string only
+    type,
+    query,
+    method,
+    value,
+    id,
+    uniqueKey,
+    changeKey
+  }) => {
+    return new Promise((resolve, reject) => {
+      const fieldName = generateFieldName({ func, type, 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 = 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]
+      );
+      const newFieldData = { ...fieldData };
+      if (method === enum_default.CHANGE_TYPE.SEARCH_FIELD) {
+        if (_id == null) {
+          reject(new Error("ID is required for SEARCH_FIELD."));
+          return;
+        }
+        const result = searchValueByKey(
+          newFieldData[enum_default.FIELD_DATA.RESULT_KEY],
+          _id,
+          _uniqueKey
+        );
+        resolve(result);
+      } else if (method === enum_default.CHANGE_TYPE.RESULT_UPDATE_KV) {
+        if (_id == null) {
+          reject(new Error("ID is required for RESULT_UPDATE_KV."));
+          return;
+        }
+        const matchedIndex = computeMatchedItemIndex(
+          _id,
+          newFieldData[enum_default.FIELD_DATA.RESULT_KEY],
+          _uniqueKey
+        );
+        if (matchedIndex >= 0) {
+          updateObjectDeepValue(
+            newFieldData[enum_default.FIELD_DATA.RESULT_KEY][matchedIndex],
+            _changeKey,
+            value
+          );
+        }
+        resolve(null);
+      } else if (method === enum_default.CHANGE_TYPE.RESULT_ITEM_MERGE) {
+        if (_id == null) {
+          reject(new Error("ID is required for RESULT_ITEM_MERGE."));
+          return;
+        }
+        const matchedIndex = computeMatchedItemIndex(
+          _id,
+          newFieldData[enum_default.FIELD_DATA.RESULT_KEY],
+          _uniqueKey
+        );
+        if (matchedIndex >= 0) {
+          const currentItem = newFieldData[enum_default.FIELD_DATA.RESULT_KEY][matchedIndex];
+          newFieldData[enum_default.FIELD_DATA.RESULT_KEY][matchedIndex] = {
+            ...currentItem,
+            ...value
+          };
+        }
+        resolve(null);
+      } else if (method === enum_default.CHANGE_TYPE.RESET_FIELD) {
+        updateObjectDeepValue(
+          newFieldData,
+          _changeKey,
+          value
+        );
+        resolve(null);
+      } else {
+        let modifyValue = getObjectDeepValue(
+          newFieldData,
+          _changeKey
+        );
+        if (modifyValue == null) {
+          modifyValue = [];
+        }
+        const matchedIndex = _id != null ? computeMatchedItemIndex(
+          _id,
+          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 (isArray(modifyValue)) {
+              if (matchedIndex >= 0) {
+                modifyValue.splice(matchedIndex, 1);
+              } else if (isArray(_id)) {
+                const idSet = new Set(_id);
+                modifyValue = modifyValue.filter(
+                  (item) => !idSet.has(
+                    getObjectDeepValue(
+                      item,
+                      _uniqueKey
+                    )
+                  )
+                );
+              }
+            }
+            break;
+          case enum_default.CHANGE_TYPE.RESULT_INSERT_TO_BEFORE:
+            if (isArray(modifyValue) && matchedIndex >= 0) {
+              modifyValue.splice(matchedIndex, 0, value);
+            }
+            break;
+          case enum_default.CHANGE_TYPE.RESULT_INSERT_TO_AFTER:
+            if (isArray(modifyValue) && matchedIndex >= 0) {
+              modifyValue.splice(matchedIndex + 1, 0, value);
+            }
+            break;
+          case enum_default.CHANGE_TYPE.RESULT_LIST_MERGE:
+            if (isArray(modifyValue)) {
+              combineArrayData(modifyValue, value, _uniqueKey);
+            }
+            break;
+          default:
+            resolve(null);
+            return;
+        }
+        newFieldData[_changeKey] = 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);
+        }
+      });
+    });
+  };
+
+  exports.ENUM = enum_default;
+  exports.initData = initData;
+  exports.initState = initState;
+  exports.loadMore = loadMore;
+  exports.updateState = updateState;
+  exports.utils = utils_exports;
+
+  return exports;
+
+})({});
+//# sourceMappingURL=index.global.js.map
+//# sourceMappingURL=index.global.js.map