@nickeylin/antd-mobile-pro 2.0.0

package/dist/es/components/tree/utils/type.js

@@ -0,0 +1,20 @@
+// https://stackoverflow.com/questions/46176165/ways-to-get-string-literal-type-of-array-values-without-enum-overhead
+export var tuple = function tuple() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+  return args;
+};
+export var tupleNum = function tupleNum() {
+  for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    args[_key2] = arguments[_key2];
+  }
+  return args;
+};
+
+/**
+ * https://stackoverflow.com/a/59187769 Extract the type of an element of an array/tuple without
+ * performing indexing
+ */
+
+/** https://github.com/Microsoft/TypeScript/issues/29729 */

package/dist/es/components/tree-picker/index.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+import prompt from './prompt';
+import './tree-picker.less';
+declare const TreePicker: (<T extends import("..").TreeDataNode<object> = import("..").TreeDataNode<object>>(props: Omit<import("..").PopupPickerMixinProps<T | T[]>, "fieldNames"> & Pick<import("..").TreeProps<T>, "search" | "params" | "request" | "rowKey" | "dataSource" | "fieldNames"> & {
+    treeProps?: Omit<import("..").TreeProps<T>, "rowKey"> | undefined;
+    multiple?: boolean | undefined;
+} & {
+    className?: string | undefined;
+    style?: (import("react").CSSProperties & Partial<Record<never, string>>) | undefined;
+    tabIndex?: number | undefined;
+} & import("react").AriaAttributes & import("react").RefAttributes<import("..").PopupPickerActions>) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | null) & {
+    prompt: typeof prompt;
+};
+export default TreePicker;
+export type { TreePickerProps } from './tree-picker';

package/dist/es/components/tree-picker/index.js

@@ -0,0 +1,7 @@
+import prompt from "./prompt";
+import _TreePicker from "./tree-picker";
+import "./tree-picker.less";
+var TreePicker = Object.assign(_TreePicker, {
+  prompt: prompt
+});
+export default TreePicker;

package/dist/es/components/tree-picker/prompt.d.ts

@@ -0,0 +1,3 @@
+import { TreeDataNode } from '../tree';
+import { TreePickerProps } from './tree-picker';
+export default function prompt<T extends TreeDataNode = TreeDataNode>(props: TreePickerProps<T>): Promise<T>;

package/dist/es/components/tree-picker/prompt.js

@@ -0,0 +1,5 @@
+import { createPopupPickerPrompt } from "../popup-picker-base";
+import TreePicker from "./tree-picker";
+export default function prompt(props) {
+  return createPopupPickerPrompt(TreePicker)(props);
+}

package/dist/es/components/tree-picker/tree-picker.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="react" />
+import { NativeProps } from 'antd-mobile/es/utils/native-props';
+import { PopupPickerActions, PopupPickerMixinProps } from '../popup-picker-base';
+import { TreeDataNode, TreeProps } from '../tree';
+export type TreePickerProps<T extends TreeDataNode<object> = TreeDataNode<object>> = Omit<PopupPickerMixinProps<T | T[]>, 'fieldNames'> & Pick<TreeProps<T>, 'search' | 'params' | 'request' | 'dataSource' | 'rowKey' | 'fieldNames'> & {
+    treeProps?: Omit<TreeProps<T>, 'rowKey'>;
+    /**
+     * 启用多选时，将启用复选框禁用选择，即点击整行会选中复选框
+     */
+    multiple?: boolean;
+} & NativeProps;
+declare const TreePicker: <T extends TreeDataNode<object> = TreeDataNode<object>>(props: Omit<PopupPickerMixinProps<T | T[]>, "fieldNames"> & Pick<TreeProps<T>, "search" | "params" | "request" | "rowKey" | "dataSource" | "fieldNames"> & {
+    treeProps?: Omit<TreeProps<T>, "rowKey"> | undefined;
+    /**
+     * 启用多选时，将启用复选框禁用选择，即点击整行会选中复选框
+     */
+    multiple?: boolean | undefined;
+} & {
+    className?: string | undefined;
+    style?: (import("react").CSSProperties & Partial<Record<never, string>>) | undefined;
+    tabIndex?: number | undefined;
+} & import("react").AriaAttributes & import("react").RefAttributes<PopupPickerActions>) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | null;
+export default TreePicker;

package/dist/es/components/tree-picker/tree-picker.js

@@ -0,0 +1,110 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["title", "confirm", "rowKey", "dataSource", "search", "params", "request", "fieldNames", "multiple", "className", "style"],
+  _excluded2 = ["className"];
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import classNames from 'classnames';
+import { useCallback, useMemo } from 'react';
+import { cn } from "../../utils/bem";
+import forwardRefWithGenerics from "../../utils/forward-ref-with-generics";
+import { useConfig } from "../config-provider";
+import PopupPickerBase, { usePopupPickerMixin } from "../popup-picker-base";
+import { getRowKey } from "../pro-list/helper";
+import Tree from "../tree";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Fragment as _Fragment } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+var bem = cn('tree-picker');
+function TreePickerInner(p, ref) {
+  var _fieldNames$title, _ref, _props$treeProps, _props$treeProps2;
+  var _useConfig = useConfig(),
+    locale = _useConfig.locale;
+  var _p$title = p.title,
+    title = _p$title === void 0 ? locale.common.selectPlaceholder : _p$title,
+    confirm = p.confirm,
+    _p$rowKey = p.rowKey,
+    rowKey = _p$rowKey === void 0 ? 'key' : _p$rowKey,
+    dataSource = p.dataSource,
+    search = p.search,
+    params = p.params,
+    request = p.request,
+    fieldNames = p.fieldNames,
+    multiple = p.multiple,
+    className = p.className,
+    style = p.style,
+    props = _objectWithoutProperties(p, _excluded);
+  var _usePopupPickerMixin = usePopupPickerMixin(_objectSpread({
+      title: title,
+      fieldNames: {
+        label: (_fieldNames$title = fieldNames === null || fieldNames === void 0 ? void 0 : fieldNames.title) !== null && _fieldNames$title !== void 0 ? _fieldNames$title : 'title'
+      },
+      confirm: (_ref = confirm !== null && confirm !== void 0 ? confirm : multiple) !== null && _ref !== void 0 ? _ref : false
+    }, props), ref),
+    _usePopupPickerMixin2 = _slicedToArray(_usePopupPickerMixin, 3),
+    _usePopupPickerMixin3 = _usePopupPickerMixin2[0],
+    popupClassName = _usePopupPickerMixin3.className,
+    popupProps = _objectWithoutProperties(_usePopupPickerMixin3, _excluded2),
+    _usePopupPickerMixin4 = _usePopupPickerMixin2[1],
+    innerValue = _usePopupPickerMixin4.innerValue,
+    setInnerValue = _usePopupPickerMixin4.setInnerValue,
+    setValue = _usePopupPickerMixin4.setValue,
+    setVisible = _usePopupPickerMixin4.setVisible,
+    children = _usePopupPickerMixin2[2];
+  var treeCheckProps = useMemo(function () {
+    if (multiple) {
+      return {
+        checkable: true,
+        selectable: false
+      };
+    } else {
+      return {};
+    }
+  }, [multiple]);
+  var getRowkeys = useCallback(function (theValue) {
+    if (!theValue) return [];
+    if (Array.isArray(theValue)) {
+      return theValue.map(function (v) {
+        return getRowKey(rowKey, v);
+      });
+    }
+    return [getRowKey(rowKey, theValue)];
+  }, [rowKey]);
+  return /*#__PURE__*/_jsxs(_Fragment, {
+    children: [/*#__PURE__*/_jsx(PopupPickerBase, _objectSpread(_objectSpread({
+      className: classNames(bem('popup'), popupClassName)
+    }, popupProps), {}, {
+      children: /*#__PURE__*/_jsx(Tree, _objectSpread(_objectSpread(_objectSpread({
+        dataSource: dataSource,
+        blockNode: true,
+        rowKey: rowKey,
+        search: search,
+        params: params,
+        request: request,
+        fieldNames: fieldNames
+      }, props.treeProps), treeCheckProps), {}, {
+        className: classNames(bem(), className, (_props$treeProps = props.treeProps) === null || _props$treeProps === void 0 ? void 0 : _props$treeProps.className),
+        style: _objectSpread(_objectSpread({}, style), (_props$treeProps2 = props.treeProps) === null || _props$treeProps2 === void 0 ? void 0 : _props$treeProps2.style),
+        selectedKeys: getRowkeys(innerValue),
+        checkedKeys: getRowkeys(innerValue),
+        onSelect: function onSelect(selectedKeys, info) {
+          var _props$onSelect;
+          var selectedValue = info.selected ? info.node : null;
+          (_props$onSelect = props.onSelect) === null || _props$onSelect === void 0 || _props$onSelect.call(props, selectedValue);
+          if (popupProps.confirm === false) {
+            setValue(selectedValue);
+            setVisible(false);
+          } else {
+            setInnerValue(selectedValue);
+          }
+        },
+        onCheck: function onCheck(checked, info) {
+          setInnerValue(info.checkedNodes);
+        }
+      }))
+    })), children]
+  });
+}
+var TreePicker = forwardRefWithGenerics(TreePickerInner);
+export default TreePicker;

package/dist/es/components/tree-picker/tree-picker.less

@@ -0,0 +1,14 @@
+@import '../styles/variable.less';
+
+@class-prefix-picker: ~'@{suid-prefix}-tree-picker';
+@class-prefix-tree: ~'@{suid-prefix}-tree';
+
+.@{class-prefix-picker} {
+  width: 100%;
+  overflow: hidden;
+  position: relative;
+
+  &.@{class-prefix-tree}__wrap {
+    --body-height: 420px;
+  }
+}

package/dist/es/components/utils/format-url.d.ts

@@ -0,0 +1,2 @@
+declare function formatUrl(originBaseUrl: string, originUrl: string): string;
+export default formatUrl;

package/dist/es/components/utils/format-url.js

@@ -0,0 +1,10 @@
+import { endsWith, startsWith } from 'lodash';
+function formatUrl(originBaseUrl, originUrl) {
+  var url = startsWith(originUrl, '/') ? originUrl.substr(1) : originUrl;
+  var baseUrl = endsWith(originBaseUrl, '/') ? originBaseUrl.substr(0, originBaseUrl.length - 1) : originBaseUrl;
+  if (startsWith(baseUrl, 'http') || startsWith(baseUrl, '/')) {
+    return "".concat(baseUrl, "/").concat(url);
+  }
+  return "/".concat(baseUrl, "/").concat(url);
+}
+export default formatUrl;

package/dist/es/components/utils/object-assign-append.d.ts

@@ -0,0 +1 @@
+export declare function objectAssignAppend<T extends Record<string, any>, U extends Record<string, any>>(o: T, c: U): T & U;

package/dist/es/components/utils/object-assign-append.js

@@ -0,0 +1,12 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import { has } from 'lodash';
+export function objectAssignAppend(o, c) {
+  if (o && c && _typeof(c) === 'object') {
+    for (var p in c) {
+      if (!has(o, p)) {
+        o[p] = c[p]; // 修改: 明确指定类型
+      }
+    }
+  }
+  return o;
+}

package/dist/es/hooks/index.d.ts

@@ -0,0 +1 @@
+export { default as useRenderImperatively } from './use-render-imperatively';

package/dist/es/hooks/index.js

@@ -0,0 +1 @@
+export { default as useRenderImperatively } from "./use-render-imperatively";

package/dist/es/hooks/use-render-imperatively/index.d.ts

@@ -0,0 +1,4 @@
+import { ImperativeHandler } from 'antd-mobile/es/utils/render-imperatively';
+import { ComponentClass, FC } from 'react';
+declare function useRenderImperatively<P extends object>(comp: FC<P> | ComponentClass<P>): (props?: P) => ImperativeHandler;
+export default useRenderImperatively;

package/dist/es/hooks/use-render-imperatively/index.js

@@ -0,0 +1,21 @@
+import { renderImperatively } from 'antd-mobile/es/utils/render-imperatively';
+import { useMemoizedFn, useUnmount } from 'ahooks';
+import { createElement, useCallback, useRef } from 'react';
+function useRenderImperatively(comp) {
+  var show = useMemoizedFn(function (props) {
+    return renderImperatively( /*#__PURE__*/createElement(comp, props));
+  });
+  var handlerRef = useRef();
+  useUnmount(function () {
+    var _handlerRef$current;
+    (_handlerRef$current = handlerRef.current) === null || _handlerRef$current === void 0 || _handlerRef$current.close();
+  });
+  return useCallback(function (props) {
+    if (handlerRef.current) {
+      handlerRef.current.close();
+    }
+    handlerRef.current = show(props);
+    return handlerRef.current;
+  }, [show]);
+}
+export default useRenderImperatively;

package/dist/es/index.d.ts

@@ -0,0 +1,5 @@
+import 'antd-mobile/es/global';
+export * from './components';
+export * from './hooks';
+export { type Locale } from './locales/base';
+export * from './utils/attachment-utils';

package/dist/es/index.js

@@ -0,0 +1,6 @@
+import 'antd-mobile/es/global';
+export * from "./components";
+export * from "./hooks";
+export * from "./utils/attachment-utils";
+
+/// <reference path="types/index.d.ts" />

package/dist/es/locales/base.d.ts

@@ -0,0 +1,281 @@
+import { mergeLocale } from 'antd-mobile/cjs/utils/merge-locale';
+declare const base: {
+    locale: string;
+    common: {
+        confirm: string;
+        cancel: string;
+        loading: string;
+        close: string;
+    };
+    Calendar: {
+        title: string;
+        confirm: string;
+        start: string;
+        end: string;
+        today: string;
+        markItems: string[];
+        yearAndMonth: string;
+    };
+    Cascader: {
+        placeholder: string;
+    };
+    Dialog: {
+        ok: string;
+    };
+    DatePicker: {
+        tillNow: string;
+    };
+    ErrorBlock: {
+        default: {
+            title: string;
+            description: string;
+        };
+        busy: {
+            title: string;
+            description: string;
+        };
+        disconnected: {
+            title: string;
+            description: string;
+        };
+        empty: {
+            title: string;
+            description: string;
+        };
+    };
+    Form: {
+        required: string;
+        optional: string;
+        defaultValidateMessages: {
+            default: string;
+            required: string;
+            enum: string;
+            whitespace: string;
+            date: {
+                format: string;
+                parse: string;
+                invalid: string;
+            };
+            types: {
+                string: string;
+                method: string;
+                array: string;
+                object: string;
+                number: string;
+                date: string;
+                boolean: string;
+                integer: string;
+                float: string;
+                regexp: string;
+                email: string;
+                url: string;
+                hex: string;
+            };
+            string: {
+                len: string;
+                min: string;
+                max: string;
+                range: string;
+            };
+            number: {
+                len: string;
+                min: string;
+                max: string;
+                range: string;
+            };
+            array: {
+                len: string;
+                min: string;
+                max: string;
+                range: string;
+            };
+            pattern: {
+                mismatch: string;
+            };
+        };
+    };
+    ImageUploader: {
+        uploading: string;
+        upload: string;
+    };
+    InfiniteScroll: {
+        noMore: string;
+        failedToLoad: string;
+        retry: string;
+    };
+    Input: {
+        clear: string;
+    };
+    Mask: {
+        name: string;
+    };
+    Modal: {
+        ok: string;
+    };
+    PasscodeInput: {
+        name: string;
+    };
+    PullToRefresh: {
+        pulling: string;
+        canRelease: string;
+        complete: string;
+    };
+    SearchBar: {
+        name: string;
+    };
+    Slider: {
+        name: string;
+    };
+    Stepper: {
+        decrease: string;
+        increase: string;
+    };
+    Switch: {
+        name: string;
+    };
+    Selector: {
+        name: string;
+    };
+} & {
+    common: {
+        userCancel: string;
+        noDataSourceSet: string;
+        add: string;
+        edit: string;
+        more: string;
+        noData: string;
+        refresh: string;
+        retry: string;
+        failedFetchDataTips: string;
+        failedToSubmit: string;
+        successedToSubmit: string;
+        remark: string;
+        details: string;
+        inputPlaceholder: string;
+        selectPlaceholder: string;
+        notSelect: string;
+        clear: string;
+        tips: string;
+        warmTips: string;
+    };
+    Attachment: {
+        add: string;
+    };
+    DatePicker: {
+        year: string;
+        month: string;
+        day: string;
+        hour: string;
+        minute: string;
+        second: string;
+        week: string;
+        monday: string;
+        tuesday: string;
+        wednesday: string;
+        thursday: string;
+        friday: string;
+        saturday: string;
+        sunday: string;
+    };
+    EdmFilePreview: {
+        title: string;
+    };
+    BPMFlowStart: {
+        flowTypeNotSelected: string;
+    };
+    BPMFlowApprove: {
+        title: string;
+        fetchOrganizationsFail: string;
+        fetchApproversFail: string;
+        selectApproverTitle: string;
+        personelSearchPlaceholder: string;
+        selectNextApproverTitle: string;
+        addApprover: string;
+        nextNodeInfo: string;
+        noApproverRequiredTips: string;
+        approvalOpinion: string;
+        commonOpinion: string;
+        opinionPlaceholder: string;
+        selectAnApproverLabel: string;
+        selectApproversLabel: string;
+        returnableNode: string;
+        ifReturnedToMeAfterProcessingTitle: string;
+        emptyNodeTips: string;
+        review: string;
+        reject: string;
+        terminate: string;
+        agree: string;
+        disagree: string;
+        noApproverSelectedForNodeTips: string;
+        currentProcessIsAboutToEnd: string;
+        processTerminates: string;
+        submitingTitle: string;
+        wookPoolDoseNotRequireApprover: string;
+        fixedTaskDoseNotRequireApprover: string;
+        decisions: string;
+        processType: string;
+        processName: string;
+        processNode: string;
+        fixedTaskNotSupport: string;
+        nodeName: string;
+        currentNodeDoesNotRequireApprover: string;
+        code: string;
+        opinion: string;
+        rank: string;
+        noOpinions: string;
+        deleteOpinionAskMessage: string;
+        handleOpinion: string;
+        invoiceDetailTitle: string;
+    };
+    HistoryList: {
+        moreActionTitle: string;
+        foldActionTitle: string;
+        startProcess: string;
+        startTime: string;
+        leaderApproval: string;
+        histories: string;
+        processing: string;
+        waitingForApprover: string;
+        taskArrivedAt: string;
+        executor: string;
+        executors: string;
+        approvalTime: string;
+        processingSummary: string;
+        showNotifications: string;
+        businessSummary: string;
+        end: string;
+        endTime: string;
+        orderChangeRecords: string;
+        timeConsuming: string;
+        forecastFlow: string;
+        forecastFlowErrTips: string;
+    };
+    InputCaptcha: {
+        getCaptcha: string;
+    };
+    InputPassword: {
+        defaultPlaceholder: string;
+    };
+    ProList: {
+        prevPage: string;
+        nextPage: string;
+        retry: string;
+        invalidRenderParamTitle: string;
+        invalidRenderParamMessage: string;
+        keywordsPlaceholder: string;
+        totalSelectedCount: string;
+        selectedPopupTitle: string;
+        clearAllTipsMessage: string;
+    };
+    RegionPicker: {
+        title: string;
+    };
+    Form: {
+        submitter: {
+            reset: string;
+            submit: string;
+        };
+    };
+};
+type Locale = typeof base;
+export { base, mergeLocale, type Locale };