@rklink/components 0.1.0

package/dist/index.js

@@ -0,0 +1,705 @@
+// src/RKConfirmAction/index.tsx
+import { useRequest } from "ahooks";
+import { Button, message, Modal } from "antd";
+import { useCallback, useMemo, useRef, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+var DEFAULT_FETCH_KEY = "RK_CONFIRM_DEFAULT";
+function isResponseSuccess(result, successCode) {
+  if (result && typeof result === "object" && "code" in result) {
+    return result.code === successCode;
+  }
+  return true;
+}
+function resolveConfirmConfig(confirm, params) {
+  if (typeof confirm === "function") {
+    return confirm(...params);
+  }
+  return confirm;
+}
+function resolveMessage(nextMessage, result, params) {
+  if (typeof nextMessage === "function") {
+    return nextMessage(result, ...params);
+  }
+  return nextMessage;
+}
+function resolveErrorMessage(errorMessage, error, params) {
+  if (typeof errorMessage === "function") {
+    return errorMessage(error, ...params);
+  }
+  return errorMessage;
+}
+function useRKConfirmRequest(options) {
+  const {
+    request,
+    confirm,
+    successMessage,
+    failureMessage,
+    errorMessage,
+    successCode = 200,
+    isSuccess,
+    getLoadingKey,
+    debounceInterval,
+    throttleInterval,
+    onSuccess,
+    onFailure,
+    onError,
+    onCancel
+  } = options;
+  const confirmOpenRef = useRef(false);
+  const [loadingKeys, setLoadingKeys] = useState({});
+  const { runAsync: requestRun, loading } = useRequest(request, {
+    manual: true,
+    debounceWait: debounceInterval,
+    throttleWait: throttleInterval
+  });
+  const setKeyLoading = useCallback((params, nextLoading) => {
+    const key = getLoadingKey == null ? void 0 : getLoadingKey(...params);
+    const loadingKey = key === void 0 ? DEFAULT_FETCH_KEY : String(key);
+    setLoadingKeys((prev) => ({
+      ...prev,
+      [loadingKey]: nextLoading
+    }));
+  }, [getLoadingKey]);
+  const executeRequest = useCallback(
+    async (...params) => {
+      setKeyLoading(params, true);
+      try {
+        const result = await requestRun(...params);
+        const success = isSuccess ? isSuccess(result) : isResponseSuccess(result, successCode);
+        if (success) {
+          const nextSuccessMessage = resolveMessage(successMessage, result, params);
+          if (nextSuccessMessage) {
+            message.success(nextSuccessMessage);
+          }
+          await (onSuccess == null ? void 0 : onSuccess(result, ...params));
+        } else {
+          const nextFailureMessage = resolveMessage(failureMessage, result, params);
+          if (nextFailureMessage) {
+            message.error(nextFailureMessage);
+          }
+          await (onFailure == null ? void 0 : onFailure(result, ...params));
+        }
+        return result;
+      } catch (error) {
+        const nextErrorMessage = resolveErrorMessage(errorMessage, error, params);
+        if (nextErrorMessage) {
+          message.error(nextErrorMessage);
+        }
+        await (onError == null ? void 0 : onError(error, ...params));
+        throw error;
+      } finally {
+        setKeyLoading(params, false);
+      }
+    },
+    [
+      errorMessage,
+      failureMessage,
+      isSuccess,
+      onError,
+      onFailure,
+      onSuccess,
+      requestRun,
+      setKeyLoading,
+      successCode,
+      successMessage
+    ]
+  );
+  const run = useCallback(
+    (...params) => {
+      const confirmConfig = resolveConfirmConfig(confirm, params);
+      if (!confirmConfig) {
+        void executeRequest(...params);
+        return;
+      }
+      if (confirmOpenRef.current) return;
+      confirmOpenRef.current = true;
+      const { onOk, onCancel: onModalCancel, afterClose, ...restConfirmConfig } = confirmConfig;
+      Modal.confirm({
+        okText: "\u786E\u8BA4",
+        cancelText: "\u53D6\u6D88",
+        ...restConfirmConfig,
+        onOk: async (...args) => {
+          const shouldContinue = await (onOk == null ? void 0 : onOk(...args));
+          if (shouldContinue === false) return false;
+          return executeRequest(...params);
+        },
+        onCancel: async (...args) => {
+          const shouldCancel = await (onModalCancel == null ? void 0 : onModalCancel(...args));
+          await (onCancel == null ? void 0 : onCancel(...params));
+          return shouldCancel;
+        },
+        afterClose: () => {
+          confirmOpenRef.current = false;
+          afterClose == null ? void 0 : afterClose();
+        }
+      });
+    },
+    [confirm, executeRequest, onCancel]
+  );
+  const isLoading = useCallback(
+    (key) => {
+      if (key === void 0) return loading || !!loadingKeys[DEFAULT_FETCH_KEY];
+      return !!loadingKeys[String(key)];
+    },
+    [loading, loadingKeys]
+  );
+  return useMemo(
+    () => ({
+      run,
+      runRequest: executeRequest,
+      loading,
+      loadingKeys,
+      isLoading
+    }),
+    [executeRequest, isLoading, loading, loadingKeys, run]
+  );
+}
+var RKConfirmAction = ({
+  request,
+  confirm,
+  successMessage,
+  failureMessage,
+  errorMessage,
+  successCode,
+  isSuccess,
+  debounceInterval,
+  throttleInterval,
+  onSuccess,
+  onFailure,
+  onError,
+  onCancel,
+  stopPropagation = true,
+  children,
+  ...buttonProps
+}) => {
+  const { run, loading } = useRKConfirmRequest({
+    request,
+    confirm,
+    successMessage,
+    failureMessage,
+    errorMessage,
+    successCode,
+    isSuccess,
+    debounceInterval,
+    throttleInterval,
+    onSuccess,
+    onFailure,
+    onError,
+    onCancel
+  });
+  return /* @__PURE__ */ jsx(
+    Button,
+    {
+      type: "link",
+      ...buttonProps,
+      loading,
+      onClick: (event) => {
+        if (stopPropagation) {
+          event.stopPropagation();
+        }
+        run();
+      },
+      children
+    }
+  );
+};
+var RKConfirmAction_default = RKConfirmAction;
+
+// src/RKRemoteSelect/index.tsx
+import { ProFormSelect } from "@ant-design/pro-components";
+import { useMemo as useMemo2 } from "react";
+
+// src/RKRemoteSelect/optionSourceRegistry.ts
+var enumOptionSourceRegistry = {};
+var remoteOptionSourceRegistry = {};
+var enumOptionSourceOptions = [];
+var remoteOptionSourceOptions = [];
+function upsertOptionSourceDescriptor(list, descriptor) {
+  const index = list.findIndex((item) => item.value === descriptor.value);
+  if (index === -1) {
+    list.push(descriptor);
+    return;
+  }
+  list[index] = descriptor;
+}
+function registerRKRemoteSelectEnumOptionSource(key, options, descriptor) {
+  enumOptionSourceRegistry[key] = options;
+  upsertOptionSourceDescriptor(enumOptionSourceOptions, {
+    label: (descriptor == null ? void 0 : descriptor.label) || key,
+    value: key,
+    description: (descriptor == null ? void 0 : descriptor.description) || "",
+    sourceType: "enum"
+  });
+}
+function registerRKRemoteSelectRemoteOptionSource(key, loader, descriptor) {
+  remoteOptionSourceRegistry[key] = loader;
+  upsertOptionSourceDescriptor(remoteOptionSourceOptions, {
+    label: (descriptor == null ? void 0 : descriptor.label) || key,
+    value: key,
+    description: (descriptor == null ? void 0 : descriptor.description) || "",
+    sourceType: "remote"
+  });
+}
+function normalizeOptionLabel(value) {
+  if (typeof value === "string" || typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "boolean") {
+    return String(value);
+  }
+  return void 0;
+}
+function isOptionValue(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function normalizeOptionItems(items, defaults, source) {
+  const labelField = (source == null ? void 0 : source.labelField) || (defaults == null ? void 0 : defaults.labelField) || "label";
+  const valueField = (source == null ? void 0 : source.valueField) || (defaults == null ? void 0 : defaults.valueField) || "value";
+  const childrenField = (source == null ? void 0 : source.childrenField) || (defaults == null ? void 0 : defaults.childrenField) || "children";
+  return items.map((item) => {
+    const label = normalizeOptionLabel(item[labelField]);
+    const value = item[valueField];
+    const children = item[childrenField];
+    if (label === void 0 || !isOptionValue(value)) {
+      return void 0;
+    }
+    return {
+      label,
+      value,
+      disabled: typeof item.disabled === "boolean" ? item.disabled : void 0,
+      children: Array.isArray(children) ? normalizeOptionItems(
+        children.filter(
+          (child) => typeof child === "object" && child !== null
+        ),
+        defaults,
+        source
+      ) : void 0
+    };
+  }).filter((item) => item !== void 0);
+}
+async function resolveRKRemoteSelectOptions(source) {
+  if (!(source == null ? void 0 : source.type) || !source.key) {
+    return [];
+  }
+  if (source.type === "enum") {
+    return enumOptionSourceRegistry[source.key] || [];
+  }
+  if (source.type === "remote") {
+    const loader = remoteOptionSourceRegistry[source.key];
+    if (!loader) return [];
+    const result = await loader();
+    return normalizeOptionItems(result.items, result.defaults, source);
+  }
+  return [];
+}
+
+// src/RKRemoteSelect/index.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+function isDynamicOptionSource(optionSource) {
+  return (optionSource == null ? void 0 : optionSource.type) === "enum" || (optionSource == null ? void 0 : optionSource.type) === "remote";
+}
+function resolveParams(optionSource, params) {
+  if (!isDynamicOptionSource(optionSource)) return params;
+  if (typeof params === "function") return params;
+  return {
+    ...params,
+    ...optionSource
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isOptionValue2(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function normalizeOptionLabel2(value) {
+  if (typeof value === "string" || typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "boolean") {
+    return String(value);
+  }
+  return void 0;
+}
+function resolveRequestApiItems(result) {
+  if (Array.isArray(result)) return result;
+  if (Array.isArray(result.data)) return result.data;
+  if (isRecord(result.data)) {
+    if (Array.isArray(result.data.records)) return result.data.records;
+    if (Array.isArray(result.data.list)) return result.data.list;
+  }
+  if (Array.isArray(result.records)) return result.records;
+  if (Array.isArray(result.list)) return result.list;
+  return [];
+}
+function normalizeSearchParams(params, searchKey = "keyWords") {
+  if (searchKey === "keyWords") return params;
+  const { keyWords, ...restParams } = params;
+  return {
+    ...restParams,
+    ...keyWords === void 0 ? {} : { [searchKey]: keyWords }
+  };
+}
+function normalizeOptions(items, config) {
+  const labelField = config.labelField || "label";
+  const valueField = config.valueField || "value";
+  const childrenField = config.childrenField || "children";
+  return items.map((item) => {
+    const label = normalizeOptionLabel2(item[labelField]);
+    const value = item[valueField];
+    const children = item[childrenField];
+    if (label === void 0 || !isOptionValue2(value)) return void 0;
+    const optionDisabled = typeof config.disabled === "function" ? config.disabled(item) : typeof item.disabled === "boolean" ? item.disabled : void 0;
+    return {
+      ...item,
+      label,
+      value,
+      disabled: optionDisabled,
+      children: Array.isArray(children) ? normalizeOptions(
+        children.filter(isRecord),
+        config
+      ) : void 0
+    };
+  }).filter((item) => item !== void 0);
+}
+function shouldNormalizeOptions(options, config) {
+  return Array.isArray(options) && options.every(isRecord) && (!!config.labelField || !!config.valueField || !!config.childrenField || typeof config.disabled === "function");
+}
+function RKRemoteSelect({
+  optionSource,
+  options,
+  requestApi,
+  request,
+  params,
+  fieldProps,
+  showSearch = true,
+  labelField,
+  valueField,
+  childrenField,
+  disabled,
+  searchKey = "keyWords",
+  ...restProps
+}) {
+  const selectDisabled = typeof disabled === "boolean" ? disabled : void 0;
+  const optionConfig = useMemo2(
+    () => ({
+      labelField,
+      valueField,
+      childrenField,
+      disabled
+    }),
+    [childrenField, disabled, labelField, valueField]
+  );
+  const selectOptions = useMemo2(() => {
+    if (!shouldNormalizeOptions(options, optionConfig)) {
+      return options;
+    }
+    return normalizeOptions(
+      options,
+      optionConfig
+    );
+  }, [optionConfig, options]);
+  const selectRequest = useMemo2(() => {
+    if (isDynamicOptionSource(optionSource)) {
+      return async () => resolveRKRemoteSelectOptions(optionSource);
+    }
+    if (requestApi) {
+      return async (requestParams2) => {
+        const result = await requestApi(normalizeSearchParams(requestParams2, searchKey));
+        return normalizeOptions(resolveRequestApiItems(result), optionConfig);
+      };
+    }
+    return request;
+  }, [optionConfig, optionSource, request, requestApi, searchKey]);
+  const requestParams = useMemo2(() => resolveParams(optionSource, params), [optionSource, params]);
+  return /* @__PURE__ */ jsx2(
+    ProFormSelect,
+    {
+      ...restProps,
+      disabled: selectDisabled,
+      showSearch,
+      options: selectOptions,
+      request: selectRequest,
+      params: requestParams,
+      fieldProps: {
+        optionFilterProp: "label",
+        filterOption: true,
+        ...fieldProps
+      }
+    }
+  );
+}
+
+// src/RKSchemaForm/index.tsx
+import { ProForm } from "@ant-design/pro-components";
+
+// src/RKSchemaForm/fieldRegistry.tsx
+import {
+  ProFormCascader,
+  ProFormCheckbox,
+  ProFormColorPicker,
+  ProFormDateMonthRangePicker,
+  ProFormDatePicker,
+  ProFormDateQuarterRangePicker,
+  ProFormDateRangePicker,
+  ProFormDateTimePicker,
+  ProFormDateTimeRangePicker,
+  ProFormDateWeekRangePicker,
+  ProFormDateYearRangePicker,
+  ProFormDigit,
+  ProFormDigitRange,
+  ProFormMoney,
+  ProFormRadio,
+  ProFormRate,
+  ProFormSegmented,
+  ProFormSelect as ProFormSelect2,
+  ProFormSlider,
+  ProFormSwitch,
+  ProFormText,
+  ProFormTextArea,
+  ProFormTimePicker,
+  ProFormTreeSelect,
+  ProFormUploadButton,
+  ProFormUploadDragger
+} from "@ant-design/pro-components";
+import { jsx as jsx3 } from "react/jsx-runtime";
+function isFieldComponentProps(value) {
+  return typeof value === "object" && value !== null;
+}
+function isDynamicOptionSource2(source) {
+  return ["enum", "remote"].includes((source == null ? void 0 : source.type) || "");
+}
+function getStaticOptions(fieldProps, optionFieldName) {
+  if (optionFieldName === "treeData") {
+    return fieldProps.treeData || fieldProps.options;
+  }
+  return fieldProps.options;
+}
+function asField(component) {
+  return component;
+}
+function createOptionField(Component, options = {}) {
+  const { optionFieldName = "options" } = options;
+  return function RKSchemaOptionsField(props) {
+    const fieldProps = isFieldComponentProps(props.fieldProps) ? props.fieldProps : {};
+    const { options: staticOptions, treeData, optionSource, ...restFieldProps } = fieldProps;
+    const shouldLoadDynamic = isDynamicOptionSource2(optionSource);
+    const resolvedStaticOptions = getStaticOptions({ ...fieldProps, options: staticOptions, treeData }, optionFieldName) || [];
+    const request = shouldLoadDynamic ? async () => resolveRKRemoteSelectOptions(optionSource) : void 0;
+    return /* @__PURE__ */ jsx3(
+      Component,
+      {
+        ...props,
+        request: request || props.request,
+        params: shouldLoadDynamic ? optionSource : props.params,
+        fieldProps: {
+          ...restFieldProps,
+          [optionFieldName]: shouldLoadDynamic ? void 0 : resolvedStaticOptions
+        }
+      }
+    );
+  };
+}
+var RKSchemaFieldRegistry = {
+  text: asField(ProFormText),
+  password: asField(ProFormText.Password),
+  textarea: asField(ProFormTextArea),
+  digit: asField(ProFormDigit),
+  digitRange: asField(ProFormDigitRange),
+  select: createOptionField(asField(ProFormSelect2)),
+  treeSelect: createOptionField(asField(ProFormTreeSelect), { optionFieldName: "treeData" }),
+  cascader: createOptionField(asField(ProFormCascader)),
+  radio: createOptionField(asField(ProFormRadio.Group)),
+  checkbox: asField(ProFormCheckbox),
+  checkboxGroup: createOptionField(asField(ProFormCheckbox.Group)),
+  switch: asField(ProFormSwitch),
+  slider: asField(ProFormSlider),
+  rate: asField(ProFormRate),
+  segmented: createOptionField(asField(ProFormSegmented)),
+  color: asField(ProFormColorPicker),
+  date: asField(ProFormDatePicker),
+  dateRange: asField(ProFormDateRangePicker),
+  dateTime: asField(ProFormDateTimePicker),
+  dateTimeRange: asField(ProFormDateTimeRangePicker),
+  dateWeekRange: asField(ProFormDateWeekRangePicker),
+  dateMonthRange: asField(ProFormDateMonthRangePicker),
+  dateQuarterRange: asField(ProFormDateQuarterRangePicker),
+  dateYearRange: asField(ProFormDateYearRangePicker),
+  time: asField(ProFormTimePicker),
+  timeRange: asField(ProFormTimePicker.RangePicker),
+  money: asField(ProFormMoney),
+  uploadButton: asField(ProFormUploadButton),
+  uploadDragger: asField(ProFormUploadDragger)
+};
+function registerRKSchemaField(valueType, renderer) {
+  RKSchemaFieldRegistry[valueType] = renderer;
+}
+
+// src/RKSchemaForm/index.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+var requiredRule = {
+  required: true,
+  message: "\u6B64\u9879\u4E3A\u5FC5\u586B\u9879"
+};
+function getColProps(columns) {
+  switch (columns) {
+    case 1:
+      return { span: 24 };
+    case 2:
+      return { lg: 12, md: 12, sm: 24 };
+    case 3:
+      return { lg: 8, md: 12, sm: 24 };
+    case 6:
+      return { lg: 4, md: 6, sm: 12 };
+    case 4:
+    default:
+      return { lg: 6, md: 8, sm: 12 };
+  }
+}
+function RKSchemaForm(props) {
+  const { columns, columnCount, fieldColProps, rowProps, ...formProps } = props;
+  const defaultColProps = fieldColProps || getColProps(columnCount);
+  return /* @__PURE__ */ jsx4(ProForm, { grid: true, rowProps: { gutter: 24, ...rowProps }, ...formProps, children: columns.map((column, index) => {
+    if (column.hidden === true) return null;
+    const {
+      key,
+      title,
+      dataIndex,
+      valueType = "text",
+      required,
+      disabled,
+      readonly,
+      initialValue,
+      rules,
+      tooltip,
+      extra,
+      colProps,
+      fieldProps
+    } = column;
+    const Component = RKSchemaFieldRegistry[valueType];
+    if (!Component) return null;
+    return /* @__PURE__ */ jsx4(
+      Component,
+      {
+        label: title,
+        name: dataIndex,
+        disabled,
+        readonly,
+        initialValue,
+        rules: [...required === true ? [requiredRule] : [], ...rules || []],
+        tooltip,
+        extra,
+        colProps: colProps || defaultColProps,
+        fieldProps
+      },
+      key || `${String(dataIndex)}-${index}`
+    );
+  }) });
+}
+
+// src/RKTable/index.tsx
+import { ProTable } from "@ant-design/pro-components";
+import { jsx as jsx5 } from "react/jsx-runtime";
+function resolveRecords(response) {
+  if (Array.isArray(response.data)) return response.data;
+  if (response.data && typeof response.data === "object") {
+    if (Array.isArray(response.data.records)) return response.data.records;
+    if (Array.isArray(response.data.list)) return response.data.list;
+  }
+  if (Array.isArray(response.records)) return response.records;
+  if (Array.isArray(response.list)) return response.list;
+  return [];
+}
+function resolveTotal(response) {
+  if (typeof response.total === "number") return response.total;
+  if (response.data && !Array.isArray(response.data) && typeof response.data.total === "number") {
+    return response.data.total;
+  }
+  return resolveRecords(response).length;
+}
+function defaultRequestAdapter(response) {
+  const success = typeof response.success === "boolean" ? response.success : response.code === void 0 || response.code === 200;
+  return {
+    data: resolveRecords(response),
+    success,
+    total: resolveTotal(response)
+  };
+}
+var RKTable = ({
+  request,
+  requestApi,
+  requestAdapter = defaultRequestAdapter,
+  requestParamsFormatter,
+  search,
+  options,
+  pagination,
+  scroll,
+  form,
+  rowKey,
+  tableAlertRender,
+  ...restProps
+}) => {
+  const tableSearch = search === false ? false : {
+    filterType: "query",
+    defaultCollapsed: false,
+    ...typeof search === "object" ? search : {}
+  };
+  const tableOptions = options === false ? false : {
+    reload: true,
+    density: false,
+    setting: false,
+    ...typeof options === "object" ? options : {}
+  };
+  const tablePagination = pagination === false ? false : {
+    defaultPageSize: 20,
+    showSizeChanger: true,
+    disabled: false,
+    ...typeof pagination === "object" ? pagination : {}
+  };
+  const tableForm = {
+    syncToUrl: true,
+    syncToInitialValues: false,
+    ...typeof form === "object" ? form : {}
+  };
+  const tableScroll = {
+    x: "max-content",
+    ...typeof scroll === "object" ? scroll : {}
+  };
+  const tableRequest = requestApi ? async (params, sort, filter) => {
+    const nextParams = requestParamsFormatter ? requestParamsFormatter(params, sort, filter) : params;
+    const response = await requestApi(nextParams);
+    return requestAdapter(response);
+  } : request;
+  return /* @__PURE__ */ jsx5(
+    ProTable,
+    {
+      rowKey: rowKey || "id",
+      tableAlertRender: tableAlertRender != null ? tableAlertRender : false,
+      options: tableOptions,
+      pagination: tablePagination,
+      scroll: tableScroll,
+      form: tableForm,
+      ...restProps,
+      search: tableSearch,
+      request: tableRequest
+    }
+  );
+};
+var RKTable_default = RKTable;
+export {
+  RKConfirmAction_default as RKConfirmAction,
+  RKRemoteSelect,
+  RKSchemaForm,
+  RKTable_default as RKTable,
+  enumOptionSourceOptions,
+  registerRKRemoteSelectEnumOptionSource,
+  registerRKRemoteSelectRemoteOptionSource,
+  registerRKRemoteSelectEnumOptionSource as registerRKSchemaEnumOptionSource,
+  registerRKSchemaField,
+  registerRKRemoteSelectRemoteOptionSource as registerRKSchemaRemoteOptionSource,
+  remoteOptionSourceOptions,
+  resolveRKRemoteSelectOptions,
+  resolveRKRemoteSelectOptions as resolveRKSchemaOptions,
+  useRKConfirmRequest
+};
+//# sourceMappingURL=index.js.map