antd-mobile 5.17.0 → 5.17.1

package/2x/es/components/infinite-scroll/infinite-scroll.js

@@ -0,0 +1,118 @@
+import { __awaiter } from "tslib";
+import { mergeProps } from '../../utils/with-default-props';
+import React, { useEffect, useRef, useState } from 'react';
+import { useLockFn, useThrottleFn } from 'ahooks';
+import { withNativeProps } from '../../utils/native-props';
+import { getScrollParent } from '../../utils/get-scroll-parent';
+import { useConfig } from '../config-provider';
+import DotLoading from '../dot-loading';
+
+function isWindow(element) {
+  return element === window;
+}
+
+const classPrefix = `adm-infinite-scroll`;
+const defaultProps = {
+  threshold: 250,
+  children: (hasMore, failed, retry) => React.createElement(InfiniteScrollContent, {
+    hasMore: hasMore,
+    failed: failed,
+    retry: retry
+  })
+};
+export const InfiniteScroll = p => {
+  const props = mergeProps(defaultProps, p);
+  const [failed, setFailed] = useState(false);
+  const doLoadMore = useLockFn(isRetry => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+      yield props.loadMore(isRetry);
+    } catch (e) {
+      setFailed(true);
+      throw e;
+    }
+  }));
+  const elementRef = useRef(null); // Prevent duplicated trigger of `check` function
+
+  const [flag, setFlag] = useState({});
+  const nextFlagRef = useRef(flag);
+  const [scrollParent, setScrollParent] = useState();
+  const {
+    run: check
+  } = useThrottleFn(() => __awaiter(void 0, void 0, void 0, function* () {
+    if (nextFlagRef.current !== flag) return;
+    if (!props.hasMore) return;
+    const element = elementRef.current;
+    if (!element) return;
+    if (!element.offsetParent) return;
+    const parent = getScrollParent(element);
+    setScrollParent(parent);
+    if (!parent) return;
+    const rect = element.getBoundingClientRect();
+    const elementTop = rect.top;
+    const current = isWindow(parent) ? window.innerHeight : parent.getBoundingClientRect().bottom;
+
+    if (current >= elementTop - props.threshold) {
+      const nextFlag = {};
+      nextFlagRef.current = nextFlag;
+      yield doLoadMore(false);
+      setFlag(nextFlag);
+    }
+  }), {
+    wait: 100,
+    leading: true,
+    trailing: true
+  }); // Make sure to trigger `loadMore` when content changes
+
+  useEffect(() => {
+    check();
+  });
+  useEffect(() => {
+    const element = elementRef.current;
+    if (!element) return;
+    if (!scrollParent) return;
+
+    function onScroll() {
+      check();
+    }
+
+    scrollParent.addEventListener('scroll', onScroll);
+    return () => {
+      scrollParent.removeEventListener('scroll', onScroll);
+    };
+  }, [scrollParent]);
+
+  function retry() {
+    return __awaiter(this, void 0, void 0, function* () {
+      setFailed(false);
+      yield doLoadMore(true);
+      setFlag(nextFlagRef.current);
+    });
+  }
+
+  return withNativeProps(props, React.createElement("div", {
+    className: classPrefix,
+    ref: elementRef
+  }, typeof props.children === 'function' ? props.children(props.hasMore, failed, retry) : props.children));
+};
+
+const InfiniteScrollContent = props => {
+  const {
+    locale
+  } = useConfig();
+
+  if (!props.hasMore) {
+    return React.createElement("span", null, locale.InfiniteScroll.noMore);
+  }
+
+  if (props.failed) {
+    return React.createElement("span", null, React.createElement("span", {
+      className: `${classPrefix}-failed-text`
+    }, locale.InfiniteScroll.failedToLoad), React.createElement("a", {
+      onClick: () => {
+        props.retry();
+      }
+    }, locale.InfiniteScroll.retry));
+  }
+
+  return React.createElement(React.Fragment, null, React.createElement("span", null, locale.common.loading), React.createElement(DotLoading, null));
+};

package/2x/es/components/input/index.d.ts

@@ -0,0 +1,4 @@
+import './input.less';
+import { Input } from './input';
+export type { InputProps, InputRef } from './input';
+export default Input;

package/2x/es/components/input/index.js

@@ -0,0 +1,3 @@
+import "./input.css";
+import { Input } from './input';
+export default Input;

package/2x/es/components/input/input.css

@@ -0,0 +1,114 @@
+.adm-input {
+  --font-size: var(--adm-font-size-9);
+  --color: var(--adm-color-text);
+  --placeholder-color: var(--adm-color-light);
+  --text-align: left;
+  --background-color: transparent;
+  display: flex;
+  justify-content: flex-start;
+  align-items: center;
+  width: 100%;
+  max-width: 100%;
+  max-height: 100%;
+  min-height: 48px;
+  background-color: var(--background-color);
+}
+
+.adm-input-disabled {
+  opacity: 0.4;
+  cursor: not-allowed;
+}
+
+.adm-input-element {
+  flex: auto;
+  display: inline-block;
+  box-sizing: border-box;
+  width: 100%;
+  max-width: 100%;
+  max-height: 100%;
+  padding: 0;
+  margin: 0;
+  color: var(--color);
+  font-size: var(--font-size);
+  line-height: 1.5;
+  background: transparent;
+  border: 0;
+  outline: none;
+  -webkit-appearance: none;
+  appearance: none;
+  min-height: 1.5em;
+  text-align: var(--text-align);
+}
+
+.adm-input-element::-webkit-input-placeholder {
+  color: var(--placeholder-color);
+  font-family: inherit;
+}
+
+.adm-input-element::placeholder {
+  color: var(--placeholder-color);
+  font-family: inherit;
+}
+
+.adm-input-element:-webkit-autofill {
+  background-color: transparent;
+}
+
+.adm-input-element:read-only {
+  cursor: default;
+}
+
+.adm-input-element:invalid {
+  box-shadow: none;
+}
+
+.adm-input-element::-ms-clear {
+  display: none;
+}
+
+.adm-input-element::-ms-reveal {
+  display: none;
+}
+
+.adm-input-element::-webkit-search-cancel-button {
+  display: none;
+}
+
+.adm-input-element::-webkit-search-decoration {
+  display: none;
+}
+
+.adm-input-element:disabled {
+  opacity: 1;
+}
+
+.adm-input-element[type='date'],
+.adm-input-element[type='time'],
+.adm-input-element[type='datetime-local'] {
+  min-height: 1.5em;
+}
+
+.adm-input-element[type='search'] {
+  -webkit-appearance: none;
+}
+
+.adm-input-element[readonly] {
+  pointer-events: none;
+}
+
+.adm-input-clear {
+  flex: none;
+  margin-left: 16px;
+  color: var(--adm-color-light);
+  padding: 8px;
+  cursor: pointer;
+}
+
+.adm-input-clear:active {
+  color: var(--adm-color-weak);
+}
+
+.adm-input-clear .antd-mobile-icon {
+  display: block;
+  font-size: var(--adm-font-size-7);
+}

package/2x/es/components/input/input.d.ts

@@ -0,0 +1,49 @@
+import React from 'react';
+import { NativeProps } from '../../utils/native-props';
+declare type NativeInputProps = React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
+declare type AriaProps = {
+    role?: string;
+};
+export declare type InputProps = Pick<NativeInputProps, 'maxLength' | 'minLength' | 'autoComplete' | 'autoFocus' | 'pattern' | 'inputMode' | 'type' | 'name' | 'onFocus' | 'onBlur' | 'autoCapitalize' | 'autoCorrect' | 'onKeyDown' | 'onKeyUp' | 'onCompositionStart' | 'onCompositionEnd' | 'onClick' | 'step'> & {
+    value?: string;
+    defaultValue?: string;
+    onChange?: (val: string) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    clearable?: boolean;
+    onlyShowClearWhenFocus?: boolean;
+    onClear?: () => void;
+    id?: string;
+    onEnterPress?: (e: React.KeyboardEvent<HTMLInputElement>) => void;
+    enterKeyHint?: 'enter' | 'done' | 'go' | 'next' | 'previous' | 'search' | 'send';
+    min?: number;
+    max?: number;
+} & NativeProps<'--font-size' | '--color' | '--placeholder-color' | '--text-align'> & AriaProps;
+export declare type InputRef = {
+    clear: () => void;
+    focus: () => void;
+    blur: () => void;
+    nativeElement: HTMLInputElement | null;
+};
+export declare const Input: React.ForwardRefExoticComponent<Pick<NativeInputProps, "pattern" | "onClick" | "name" | "type" | "onCompositionEnd" | "onCompositionStart" | "onFocus" | "onBlur" | "onKeyDown" | "onKeyUp" | "autoCapitalize" | "autoCorrect" | "inputMode" | "autoComplete" | "autoFocus" | "maxLength" | "minLength" | "step"> & {
+    value?: string | undefined;
+    defaultValue?: string | undefined;
+    onChange?: ((val: string) => void) | undefined;
+    placeholder?: string | undefined;
+    disabled?: boolean | undefined;
+    readOnly?: boolean | undefined;
+    clearable?: boolean | undefined;
+    onlyShowClearWhenFocus?: boolean | undefined;
+    onClear?: (() => void) | undefined;
+    id?: string | undefined;
+    onEnterPress?: ((e: React.KeyboardEvent<HTMLInputElement>) => void) | undefined;
+    enterKeyHint?: "search" | "enter" | "done" | "go" | "next" | "previous" | "send" | undefined;
+    min?: number | undefined;
+    max?: number | undefined;
+} & {
+    className?: string | undefined;
+    style?: (React.CSSProperties & Partial<Record<"--color" | "--font-size" | "--placeholder-color" | "--text-align", string>>) | undefined;
+    tabIndex?: number | undefined;
+} & React.AriaAttributes & AriaProps & React.RefAttributes<InputRef>>;
+export {};

package/2x/es/components/input/input.js

@@ -0,0 +1,160 @@
+import React, { useState, forwardRef, useImperativeHandle, useRef } from 'react';
+import { usePropsValue } from '../../utils/use-props-value';
+import { CloseCircleFill } from 'antd-mobile-icons';
+import { withNativeProps } from '../../utils/native-props';
+import { mergeProps } from '../../utils/with-default-props';
+import classNames from 'classnames';
+import { useIsomorphicLayoutEffect } from 'ahooks';
+import { bound } from '../../utils/bound';
+import { isIOS } from '../../utils/validate';
+const classPrefix = `adm-input`;
+const defaultProps = {
+  defaultValue: '',
+  onlyShowClearWhenFocus: true
+};
+export const Input = forwardRef((p, ref) => {
+  const props = mergeProps(defaultProps, p);
+  const [value, setValue] = usePropsValue(props);
+  const [hasFocus, setHasFocus] = useState(false);
+  const compositionStartRef = useRef(false);
+  const nativeInputRef = useRef(null);
+  useImperativeHandle(ref, () => ({
+    clear: () => {
+      setValue('');
+    },
+    focus: () => {
+      var _a;
+
+      (_a = nativeInputRef.current) === null || _a === void 0 ? void 0 : _a.focus();
+    },
+    blur: () => {
+      var _a;
+
+      (_a = nativeInputRef.current) === null || _a === void 0 ? void 0 : _a.blur();
+    },
+
+    get nativeElement() {
+      return nativeInputRef.current;
+    }
+
+  }));
+
+  const handleKeydown = e => {
+    var _a;
+
+    if (props.onEnterPress && (e.code === 'Enter' || e.keyCode === 13)) {
+      props.onEnterPress(e);
+    }
+
+    (_a = props.onKeyDown) === null || _a === void 0 ? void 0 : _a.call(props, e);
+  };
+
+  useIsomorphicLayoutEffect(() => {
+    var _a;
+
+    if (!props.enterKeyHint) return;
+    (_a = nativeInputRef.current) === null || _a === void 0 ? void 0 : _a.setAttribute('enterkeyhint', props.enterKeyHint);
+    return () => {
+      var _a;
+
+      (_a = nativeInputRef.current) === null || _a === void 0 ? void 0 : _a.removeAttribute('enterkeyhint');
+    };
+  }, [props.enterKeyHint]);
+
+  function checkValue() {
+    let nextValue = value;
+
+    if (props.type === 'number') {
+      nextValue = nextValue && bound(parseFloat(nextValue), props.min, props.max).toString();
+    }
+
+    if (nextValue !== value) {
+      setValue(nextValue);
+    }
+  }
+
+  const shouldShowClear = (() => {
+    if (!props.clearable || !value || props.readOnly) return false;
+
+    if (props.onlyShowClearWhenFocus) {
+      return hasFocus;
+    } else {
+      return true;
+    }
+  })();
+
+  return withNativeProps(props, React.createElement("div", {
+    className: classNames(`${classPrefix}`, props.disabled && `${classPrefix}-disabled`)
+  }, React.createElement("input", {
+    ref: nativeInputRef,
+    className: `${classPrefix}-element`,
+    value: value,
+    onChange: e => {
+      setValue(e.target.value);
+    },
+    onFocus: e => {
+      var _a;
+
+      setHasFocus(true);
+      (_a = props.onFocus) === null || _a === void 0 ? void 0 : _a.call(props, e);
+    },
+    onBlur: e => {
+      var _a;
+
+      setHasFocus(false);
+      checkValue();
+      (_a = props.onBlur) === null || _a === void 0 ? void 0 : _a.call(props, e);
+    },
+    id: props.id,
+    placeholder: props.placeholder,
+    disabled: props.disabled,
+    readOnly: props.readOnly,
+    maxLength: props.maxLength,
+    minLength: props.minLength,
+    max: props.max,
+    min: props.min,
+    autoComplete: props.autoComplete,
+    autoFocus: props.autoFocus,
+    pattern: props.pattern,
+    inputMode: props.inputMode,
+    type: props.type,
+    name: props.name,
+    autoCapitalize: props.autoCapitalize,
+    autoCorrect: props.autoCorrect,
+    onKeyDown: handleKeydown,
+    onKeyUp: props.onKeyUp,
+    onCompositionStart: e => {
+      var _a;
+
+      compositionStartRef.current = true;
+      (_a = props.onCompositionStart) === null || _a === void 0 ? void 0 : _a.call(props, e);
+    },
+    onCompositionEnd: e => {
+      var _a;
+
+      compositionStartRef.current = false;
+      (_a = props.onCompositionEnd) === null || _a === void 0 ? void 0 : _a.call(props, e);
+    },
+    onClick: props.onClick,
+    role: props.role,
+    "aria-valuenow": props['aria-valuenow'],
+    "aria-valuemax": props['aria-valuemax'],
+    "aria-valuemin": props['aria-valuemin']
+  }), shouldShowClear && React.createElement("div", {
+    className: `${classPrefix}-clear`,
+    onMouseDown: e => {
+      e.preventDefault();
+    },
+    onClick: () => {
+      var _a, _b;
+
+      setValue('');
+      (_a = props.onClear) === null || _a === void 0 ? void 0 : _a.call(props); // https://github.com/ant-design/ant-design-mobile/issues/5212
+
+      if (isIOS() && compositionStartRef.current) {
+        compositionStartRef.current = false;
+        (_b = nativeInputRef.current) === null || _b === void 0 ? void 0 : _b.blur();
+      }
+    }
+  }, React.createElement(CloseCircleFill, null))));
+});

package/2x/es/components/jumbo-tabs/index.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import './jumbo-tabs.less';
+export type { JumboTabsProps, JumboTabProps } from './jumbo-tabs';
+declare const _default: import("react").FC<import("./jumbo-tabs").JumboTabsProps> & {
+    Tab: import("react").FC<import("./jumbo-tabs").JumboTabProps>;
+};
+export default _default;

package/2x/es/components/jumbo-tabs/index.js

@@ -0,0 +1,6 @@
+import "./jumbo-tabs.css";
+import { JumboTab, JumboTabs } from './jumbo-tabs';
+import { attachPropertiesToComponent } from '../../utils/attach-properties-to-component';
+export default attachPropertiesToComponent(JumboTabs, {
+  Tab: JumboTab
+});

package/2x/es/components/jumbo-tabs/jumbo-tabs.css

@@ -0,0 +1,78 @@
+.adm-jumbo-tabs {
+  --gap: 16px;
+  position: relative;
+  min-width: 0;
+}
+
+.adm-jumbo-tabs-header {
+  position: relative;
+  border-bottom: solid 2px var(--adm-color-border);
+}
+
+.adm-jumbo-tabs-tab-list {
+  display: flex;
+  flex-wrap: nowrap;
+  justify-content: flex-start;
+  align-items: center;
+  position: relative;
+  overflow-x: scroll;
+  padding: 0 var(--gap);
+  scrollbar-width: none;
+}
+
+.adm-jumbo-tabs-tab-list::-webkit-scrollbar {
+  display: none;
+}
+
+.adm-jumbo-tabs-tab-wrapper {
+  flex: auto;
+  padding: 0 calc(var(--gap) / 2);
+  text-align: center;
+}
+
+.adm-jumbo-tabs-tab {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  position: relative;
+  width: -webkit-min-content;
+  width: min-content;
+  margin: 0 auto;
+  padding: 24px 0;
+  cursor: pointer;
+  font-size: var(--adm-font-size-9);
+  white-space: nowrap;
+}
+
+.adm-jumbo-tabs-tab-title {
+  line-height: 48px;
+  padding: 0 8px;
+}
+
+.adm-jumbo-tabs-tab-description {
+  width: -webkit-min-content;
+  width: min-content;
+  padding: 0 16px;
+  border-radius: 20px;
+  color: var(--adm-color-weak);
+  font-size: var(--adm-font-size-main);
+  background-color: var(--adm-color-box);
+}
+
+.adm-jumbo-tabs-tab-active {
+  color: var(--adm-color-primary);
+}
+
+.adm-jumbo-tabs-tab-active .adm-jumbo-tabs-tab-description {
+  color: var(--adm-color-white);
+  background-color: var(--adm-color-primary);
+}
+
+.adm-jumbo-tabs-tab-disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+.adm-jumbo-tabs-content {
+  padding: 24px;
+}

package/2x/es/components/jumbo-tabs/jumbo-tabs.d.ts

@@ -0,0 +1,18 @@
+import React, { FC, ReactNode } from 'react';
+import { NativeProps } from '../../utils/native-props';
+export declare type JumboTabProps = {
+    title: ReactNode;
+    description: ReactNode;
+    disabled?: boolean;
+    forceRender?: boolean;
+    destroyOnClose?: boolean;
+    children?: React.ReactNode;
+} & NativeProps;
+export declare const JumboTab: FC<JumboTabProps>;
+export declare type JumboTabsProps = {
+    activeKey?: string | null;
+    defaultActiveKey?: string | null;
+    onChange?: (key: string) => void;
+    children?: React.ReactNode;
+} & NativeProps;
+export declare const JumboTabs: FC<JumboTabsProps>;

package/2x/es/components/jumbo-tabs/jumbo-tabs.js

@@ -0,0 +1,105 @@
+import React, { useRef } from 'react';
+import classNames from 'classnames';
+import { animated } from '@react-spring/web';
+import { withNativeProps } from '../../utils/native-props';
+import { usePropsValue } from '../../utils/use-props-value';
+import { useResizeEffect } from '../../utils/use-resize-effect';
+import { useTabListScroll } from '../../utils/use-tab-list-scroll';
+import ScrollMask from '../scroll-mask';
+import { ShouldRender } from '../../utils/should-render';
+import { traverseReactNode } from '../../utils/traverse-react-node';
+const classPrefix = `adm-jumbo-tabs`;
+export const JumboTab = () => {
+  return null;
+};
+export const JumboTabs = props => {
+  var _a;
+
+  const tabListContainerRef = useRef(null);
+  const rootRef = useRef(null);
+  const keyToIndexRecord = {};
+  let firstActiveKey = null;
+  const panes = [];
+  traverseReactNode(props.children, (child, index) => {
+    if (!React.isValidElement(child)) return;
+    const key = child.key;
+    if (typeof key !== 'string') return;
+
+    if (index === 0) {
+      firstActiveKey = key;
+    }
+
+    const length = panes.push(child);
+    keyToIndexRecord[key] = length - 1;
+  });
+  const [activeKey, setActiveKey] = usePropsValue({
+    value: props.activeKey,
+    defaultValue: (_a = props.defaultActiveKey) !== null && _a !== void 0 ? _a : firstActiveKey,
+    onChange: v => {
+      var _a;
+
+      if (v === null) return;
+      (_a = props.onChange) === null || _a === void 0 ? void 0 : _a.call(props, v);
+    }
+  });
+  const {
+    scrollLeft,
+    animate
+  } = useTabListScroll(tabListContainerRef, keyToIndexRecord[activeKey]);
+  useResizeEffect(() => {
+    animate(true);
+  }, rootRef);
+  return withNativeProps(props, React.createElement("div", {
+    className: classPrefix,
+    ref: rootRef
+  }, React.createElement("div", {
+    className: `${classPrefix}-header`
+  }, React.createElement(ScrollMask, {
+    scrollTrackRef: tabListContainerRef
+  }), React.createElement(animated.div, {
+    className: `${classPrefix}-tab-list`,
+    ref: tabListContainerRef,
+    scrollLeft: scrollLeft
+  }, panes.map(pane => withNativeProps(pane.props, React.createElement("div", {
+    key: pane.key,
+    className: `${classPrefix}-tab-wrapper`
+  }, React.createElement("div", {
+    onClick: () => {
+      const {
+        key
+      } = pane;
+      if (pane.props.disabled) return;
+
+      if (key === undefined || key === null) {
+        return;
+      }
+
+      setActiveKey(key.toString());
+    },
+    className: classNames(`${classPrefix}-tab`, {
+      [`${classPrefix}-tab-active`]: pane.key === activeKey,
+      [`${classPrefix}-tab-disabled`]: pane.props.disabled
+    })
+  }, React.createElement("div", {
+    className: `${classPrefix}-tab-title`
+  }, pane.props.title), React.createElement("div", {
+    className: `${classPrefix}-tab-description`
+  }, pane.props.description))))))), panes.map(pane => {
+    if (pane.props.children === undefined) {
+      return null;
+    }
+
+    const active = pane.key === activeKey;
+    return React.createElement(ShouldRender, {
+      key: pane.key,
+      active: active,
+      forceRender: pane.props.forceRender,
+      destroyOnClose: pane.props.destroyOnClose
+    }, React.createElement("div", {
+      className: `${classPrefix}-content`,
+      style: {
+        display: active ? 'block' : 'none'
+      }
+    }, pane.props.children));
+  })));
+};

package/2x/es/components/list/index.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="react" />
+import './list.less';
+export type { ListProps, ListRef } from './list';
+export type { ListItemProps } from './list-item';
+declare const _default: import("react").ForwardRefExoticComponent<{
+    header?: import("react").ReactNode;
+    mode?: "default" | "card" | undefined;
+    children?: import("react").ReactNode;
+} & {
+    className?: string | undefined;
+    style?: (import("react").CSSProperties & Partial<Record<"--active-background-color" | "--align-items" | "--border-bottom" | "--border-inner" | "--border-top" | "--extra-max-width" | "--font-size" | "--header-font-size" | "--padding-left" | "--padding-right" | "--prefix-padding-right" | "--prefix-width", string>>) | undefined;
+    tabIndex?: number | undefined;
+} & import("react").AriaAttributes & import("react").RefAttributes<import("./list").ListRef>> & {
+    Item: import("react").FC<import("./list-item").ListItemProps>;
+};
+export default _default;

package/2x/es/components/list/index.js

@@ -0,0 +1,7 @@
+import "./list.css";
+import { attachPropertiesToComponent } from '../../utils/attach-properties-to-component';
+import { List } from './list';
+import { ListItem } from './list-item';
+export default attachPropertiesToComponent(List, {
+  Item: ListItem
+});