@flowlist/js-core 2.3.0 → 3.0.0

package/dist/index.js

@@ -0,0 +1,766 @@
+'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;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map