@douyinfe/semi-foundation 2.28.0-beta.0 → 2.28.0

package/lib/cjs/carousel/foundation.js

@@ -0,0 +1,215 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _get2 = _interopRequireDefault(require("lodash/get"));
+
+var _isObject2 = _interopRequireDefault(require("lodash/isObject"));
+
+var _foundation = _interopRequireDefault(require("../base/foundation"));
+
+var _constants = require("./constants");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class CarouselFoundation extends _foundation.default {
+  constructor(adapter) {
+    super(Object.assign({}, adapter));
+    this._interval = null;
+  }
+
+  play(interval) {
+    if (this._interval) {
+      clearInterval(this._interval);
+    }
+
+    this._interval = setInterval(() => {
+      this.next();
+    }, interval);
+  }
+
+  stop() {
+    if (this._interval) {
+      clearInterval(this._interval);
+    }
+  }
+
+  goTo(activeIndex) {
+    const {
+      activeIndex: stateActiveIndex
+    } = this.getStates();
+    const targetIndex = this.getValidIndex(activeIndex);
+
+    this._adapter.setIsReverse(stateActiveIndex > targetIndex);
+
+    if (this.getIsControlledComponent()) {
+      this._notifyChange(targetIndex);
+    } else {
+      this._notifyChange(targetIndex);
+
+      this.handleNewActiveIndex(targetIndex);
+    }
+  }
+
+  next() {
+    this.stop();
+    const {
+      activeIndex: stateActiveIndex
+    } = this.getStates();
+    const targetIndex = this.getValidIndex(stateActiveIndex + 1);
+
+    this._adapter.setIsReverse(false);
+
+    if (this.getIsControlledComponent()) {
+      this._notifyChange(targetIndex);
+    } else {
+      this._notifyChange(targetIndex);
+
+      this.handleNewActiveIndex(targetIndex);
+    }
+
+    this.handleAutoPlay();
+  }
+
+  prev() {
+    this.stop();
+    const {
+      activeIndex: stateActiveIndex
+    } = this.getStates();
+    const targetIndex = this.getValidIndex(stateActiveIndex - 1);
+
+    this._adapter.setIsReverse(true);
+
+    if (this.getIsControlledComponent()) {
+      this._notifyChange(targetIndex);
+    } else {
+      this._notifyChange(targetIndex);
+
+      this.handleNewActiveIndex(targetIndex);
+    }
+
+    this.handleAutoPlay();
+  }
+
+  destroy() {
+    this._unregisterInterval();
+  }
+
+  _unregisterInterval() {
+    if (this._interval) {
+      clearInterval(this._interval);
+      this._interval = null;
+    }
+  }
+
+  _notifyChange(activeIndex) {
+    const {
+      activeIndex: stateActiveIndex,
+      isInit
+    } = this.getStates();
+
+    if (isInit) {
+      this._adapter.setIsInit(false);
+    }
+
+    if (stateActiveIndex !== activeIndex) {
+      this._adapter.setPreActiveIndex(stateActiveIndex);
+
+      this._adapter.notifyChange(activeIndex, stateActiveIndex);
+    }
+  }
+
+  getValidIndex(index) {
+    const {
+      children
+    } = this.getStates();
+    return (index + children.length) % children.length;
+  }
+
+  getSwitchingTime() {
+    const {
+      autoPlay,
+      speed
+    } = this.getProps();
+    const autoPlayType = typeof autoPlay;
+
+    if (autoPlayType === 'boolean' && autoPlay) {
+      return _constants.numbers.DEFAULT_INTERVAL + speed;
+    }
+
+    if ((0, _isObject2.default)(autoPlay)) {
+      return (0, _get2.default)(autoPlay, 'interval', _constants.numbers.DEFAULT_INTERVAL) + speed;
+    }
+
+    return speed;
+  }
+
+  getIsControlledComponent() {
+    return this._isInProps('activeIndex');
+  }
+
+  handleAutoPlay() {
+    const {
+      autoPlay
+    } = this.getProps();
+    const autoPlayType = typeof autoPlay;
+
+    if (autoPlayType === 'boolean' && autoPlay || (0, _isObject2.default)(autoPlay)) {
+      this.play(this.getSwitchingTime());
+    }
+  }
+
+  handleKeyDown(event) {
+    if (event.key === 'ArrowLeft') {
+      this.prev();
+    }
+
+    if (event.key === 'ArrowRight') {
+      this.next();
+    }
+  }
+
+  onIndicatorChange(activeIndex) {
+    const {
+      activeIndex: stateActiveIndex
+    } = this.getStates();
+
+    this._adapter.setIsReverse(stateActiveIndex > activeIndex);
+
+    this._notifyChange(activeIndex);
+
+    if (!this.getIsControlledComponent()) {
+      this.handleNewActiveIndex(activeIndex);
+    }
+  }
+
+  handleNewActiveIndex(activeIndex) {
+    const {
+      activeIndex: stateActiveIndex
+    } = this.getStates();
+
+    if (stateActiveIndex !== activeIndex) {
+      this._adapter.setNewActiveIndex(activeIndex);
+    }
+  }
+
+  getDefaultActiveIndex() {
+    let activeIndex;
+    const props = this.getProps();
+
+    if ('activeIndex' in props) {
+      activeIndex = props.activeIndex;
+    } else if ('defaultActiveIndex' in props) {
+      activeIndex = props.defaultActiveIndex;
+    }
+
+    return activeIndex;
+  }
+
+}
+
+var _default = CarouselFoundation;
+exports.default = _default;

package/lib/cjs/cascader/constants.d.ts

@@ -0,0 +1,17 @@
+declare const cssClasses: {
+    PREFIX: string;
+    PREFIX_OPTION: string;
+};
+declare const strings: {
+    readonly SIZE_SET: readonly ["small", "large", "default"];
+    readonly VALIDATE_STATUS: readonly ["success", "default", "error", "warning"];
+    readonly IS_KEY: "isKey";
+    readonly IS_VALUE: "isValue";
+    readonly SHOW_NEXT_BY_CLICK: "click";
+    readonly SHOW_NEXT_BY_HOVER: "hover";
+    readonly LEAF_ONLY_MERGE_TYPE: "leafOnly";
+    readonly AUTO_MERGE_VALUE_MERGE_TYPE: "autoMergeValue";
+    readonly NONE_MERGE_TYPE: "none";
+};
+declare const numbers: {};
+export { cssClasses, strings, numbers };

package/lib/cjs/cascader/constants.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.strings = exports.numbers = exports.cssClasses = void 0;
+
+var _constants = require("../base/constants");
+
+const cssClasses = {
+  PREFIX: `${_constants.BASE_CLASS_PREFIX}-cascader`,
+  PREFIX_OPTION: `${_constants.BASE_CLASS_PREFIX}-cascader-option`
+};
+exports.cssClasses = cssClasses;
+const strings = {
+  SIZE_SET: ['small', 'large', 'default'],
+  VALIDATE_STATUS: ['success', 'default', 'error', 'warning'],
+  IS_KEY: 'isKey',
+  IS_VALUE: 'isValue',
+  SHOW_NEXT_BY_CLICK: 'click',
+  SHOW_NEXT_BY_HOVER: 'hover',
+
+  /* Merge Type */
+  LEAF_ONLY_MERGE_TYPE: 'leafOnly',
+  AUTO_MERGE_VALUE_MERGE_TYPE: 'autoMergeValue',
+  NONE_MERGE_TYPE: 'none'
+};
+exports.strings = strings;
+const numbers = {};
+exports.numbers = numbers;

package/lib/cjs/cascader/foundation.d.ts

@@ -0,0 +1,240 @@
+import BaseFoundation, { DefaultAdapter } from '../base/foundation';
+export interface BasicData {
+    data: BasicCascaderData;
+    disabled: boolean;
+    key: string;
+    searchText: any[];
+    pathData?: BasicCascaderData[];
+}
+export interface BasicEntities {
+    [idx: string]: BasicEntity;
+}
+export interface BasicEntity {
+    _notExist?: boolean;
+    children?: Array<BasicEntity>;
+    data: BasicCascaderData;
+    ind: number;
+    key: string;
+    level: number;
+    parent?: BasicEntity;
+    parentKey?: string;
+    path: Array<string>;
+    valuePath: Array<string>;
+}
+export interface BasicCascaderData {
+    [x: string]: any;
+    value: string | number;
+    label: any;
+    disabled?: boolean;
+    isLeaf?: boolean;
+    loading?: boolean;
+    children?: BasicCascaderData[];
+}
+export declare type CascaderType = 'large' | 'small' | 'default';
+export declare type BasicSimpleValueType = string | number | BasicCascaderData;
+export declare type BasicValue = BasicSimpleValueType | Array<BasicSimpleValueType> | Array<Array<BasicSimpleValueType>>;
+export declare type ShowNextType = 'click' | 'hover';
+export interface BasicTriggerRenderProps {
+    componentProps: BasicCascaderProps;
+    disabled: boolean;
+    /** The hierarchical position of the selected node in treeData,
+     * as in the following example, when Zhejiang-Hangzhou-Xiaoshan
+     * District is selected, the value here is 0-0-1 */
+    value?: string | Set<string>;
+    inputValue: string;
+    placeholder?: string;
+    /** The function used to update the value of the input box. You
+     * should call this function when the value of the Input component
+     * customized by triggerRender is updated to synchronize the state
+     * with Cascader. */
+    onChange: (inputValue: string) => void;
+    onClear: (e: any) => void;
+}
+export interface BasicScrollPanelProps {
+    panelIndex: number;
+    activeNode: BasicCascaderData;
+}
+export interface BasicCascaderProps {
+    mouseEnterDelay?: number;
+    mouseLeaveDelay?: number;
+    separator?: string;
+    arrowIcon?: any;
+    changeOnSelect?: boolean;
+    multiple?: boolean;
+    autoMergeValue?: boolean;
+    defaultValue?: BasicValue;
+    disabled?: boolean;
+    dropdownClassName?: string;
+    dropdownStyle?: any;
+    emptyContent?: any;
+    filterLeafOnly?: boolean;
+    motion?: boolean;
+    filterTreeNode?: ((inputValue: string, treeNodeString: string, data?: BasicCascaderData) => boolean) | boolean;
+    filterSorter?: (first: BasicCascaderData, second: BasicCascaderData, inputValue: string) => number;
+    filterRender?: (props: any) => any;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    size?: CascaderType;
+    className?: string;
+    treeData?: Array<BasicCascaderData>;
+    treeNodeFilterProp?: string;
+    displayProp?: string;
+    maxTagCount?: number;
+    max?: number;
+    showRestTagsPopover?: boolean;
+    restTagsPopoverProps?: any;
+    children?: any;
+    zIndex?: number;
+    value?: BasicValue;
+    prefix?: any;
+    suffix?: any;
+    insetLabel?: any;
+    style?: any;
+    stopPropagation?: boolean | string;
+    showClear?: boolean;
+    autoAdjustOverflow?: boolean;
+    defaultOpen?: boolean;
+    onChangeWithObject?: boolean;
+    bottomSlot?: any;
+    topSlot?: any;
+    showNext?: ShowNextType;
+    disableStrictly?: boolean;
+    leafOnly?: boolean;
+    enableLeafClick?: boolean;
+    preventScroll?: boolean;
+    onClear?: () => void;
+    triggerRender?: (props: BasicTriggerRenderProps) => any;
+    onListScroll?: (e: any, panel: BasicScrollPanelProps) => void;
+    loadData?: (selectOptions: BasicCascaderData[]) => Promise<void>;
+    onLoad?: (newLoadedKeys: Set<string>, data: BasicCascaderData) => void;
+    onDropdownVisibleChange?: (visible: boolean) => void;
+    getPopupContainer?: () => HTMLElement;
+    onChange?: (value: BasicValue) => void;
+    onSearch?: (value: string) => void;
+    onSelect?: (value: string | number | Array<string | number>) => void;
+    onExceed?: (checkedItem: BasicEntity[]) => void;
+    displayRender?: (selected: Array<string> | BasicEntity, idx?: number) => any;
+    onBlur?: (e: any) => void;
+    onFocus?: (e: any) => void;
+}
+export interface BasicCascaderInnerData {
+    isOpen: boolean;
+    rePosKey: number;
+    keyEntities: BasicEntities;
+    selectedKeys: Set<string>;
+    activeKeys: Set<string>;
+    filteredKeys: Set<string>;
+    inputValue: string;
+    isSearching: boolean;
+    inputPlaceHolder: string;
+    prevProps: BasicCascaderProps;
+    isHovering: boolean;
+    checkedKeys: Set<string>;
+    halfCheckedKeys: Set<string>;
+    resolvedCheckedKeys: Set<string>;
+    loadedKeys: Set<string>;
+    loadingKeys: Set<string>;
+    loading: boolean;
+    treeData?: Array<BasicCascaderData>;
+    isFocus?: boolean;
+    isInput?: boolean;
+    disabledKeys?: Set<string>;
+    showInput?: boolean;
+}
+export interface CascaderAdapter extends DefaultAdapter<BasicCascaderProps, BasicCascaderInnerData> {
+    notifyClear?: () => void;
+    updateInputValue: (value: string) => void;
+    updateInputPlaceHolder: (value: string) => void;
+    focusInput: () => void;
+    registerClickOutsideHandler: (cb: (e: any) => void) => void;
+    unregisterClickOutsideHandler: () => void;
+    rePositionDropdown: () => void;
+    updateStates: (states: Partial<BasicCascaderInnerData>) => void;
+    openMenu: () => void;
+    closeMenu: (cb?: () => void) => void;
+    updateSelection: (selectedKeys: Set<string>) => void;
+    notifyChange: (value: BasicValue) => void;
+    notifySelect: (selected: string | number | Array<string | number>) => void;
+    notifyOnSearch: (input: string) => void;
+    notifyFocus: (e: any) => void;
+    notifyBlur: (e: any) => void;
+    notifyDropdownVisibleChange: (visible: boolean) => void;
+    toggleHovering: (bool: boolean) => void;
+    notifyLoadData: (selectedOpt: BasicCascaderData[], callback: (data?: BasicEntities) => void) => void;
+    notifyOnLoad: (newLoadedKeys: Set<string>, data: BasicCascaderData) => void;
+    notifyListScroll: (e: any, panel: BasicScrollPanelProps) => void;
+    notifyOnExceed: (data: BasicEntity[]) => void;
+    toggleInputShow: (show: boolean, cb: () => void) => void;
+    updateFocusState: (focus: boolean) => void;
+}
+export default class CascaderFoundation extends BaseFoundation<CascaderAdapter, BasicCascaderProps, BasicCascaderInnerData> {
+    constructor(adapter: CascaderAdapter);
+    init(): void;
+    destroy(): void;
+    _isDisabled(): any;
+    _isFilterable(): boolean;
+    _notifyChange(item: BasicEntity | BasicData | Set<string>): void;
+    _isLeaf(item: BasicCascaderData): boolean;
+    _clearInput(): void;
+    _notifyBlur(e: any): void;
+    _notifyFocus(e: any): void;
+    _isOptionDisabled(key: string, keyEntities: BasicEntities): boolean;
+    getCopyFromState(items: string | string[]): Partial<BasicCascaderInnerData>;
+    getItemPropPath(selectedKey: string, prop: string | any[], keyEntities?: BasicEntities): any[];
+    _getCacheValue(keyEntities: BasicEntities): any;
+    collectOptions(init?: boolean): void;
+    handleValueChange(value: BasicValue): void;
+    /**
+     * When single selection, the clear objects of
+     * selectedKeys, activeKeys, filteredKeys, input, etc.
+     */
+    _getClearSelectedKey(filterable: boolean): Partial<BasicCascaderInnerData>;
+    updateSelectedKey(value: BasicValue, keyEntities: BasicEntities): void;
+    open(): void;
+    reCalcActiveKeys(): void;
+    close(e: any, key?: string): void;
+    toggle2SearchInput(isShow: boolean): void;
+    focusInput(): void;
+    updateSearching: (isSearching: boolean) => void;
+    handleItemClick(e: any, item: BasicEntity | BasicData): void;
+    handleItemHover(e: any, item: BasicEntity): void;
+    handleShowNextByHover(item: BasicEntity): void;
+    onItemCheckboxClick(item: BasicEntity | BasicData): void;
+    handleClick(e: any): void;
+    /**
+     * A11y: simulate selection click
+     */
+    handleSelectionEnterPress(keyboardEvent: any): void;
+    toggleHoverState(bool: boolean): void;
+    _defaultRenderText(path: any[], displayRender?: BasicCascaderProps['displayRender']): any;
+    renderDisplayText(targetKey: string, keyEntities?: BasicEntities): any;
+    handleNodeLoad(item: BasicEntity | BasicData): void;
+    notifyIfLoadData(item: BasicEntity | BasicData): void;
+    handleSingleSelect(e: any, item: BasicEntity | BasicData): void;
+    _handleMultipleSelect(item: BasicEntity | BasicData): void;
+    calcNonDisabledCheckedKeys(eventKey: string, targetStatus: boolean): {
+        checkedKeys: Set<string>;
+        halfCheckedKeys: Set<any>;
+    };
+    calcCheckedStatus(targetStatus: boolean, eventKey: string): boolean;
+    _notifySelect(keys: Set<string>): void;
+    /**
+     * calculate all key of nodes that are checked or half checked
+     * @param {string} key key of node
+     * @param {boolean} curCheckedStatus checked status of node
+     */
+    calcCheckedKeys(key: string, curCheckedStatus: boolean): {
+        checkedKeys: Set<string>;
+        halfCheckedKeys: Set<string>;
+    };
+    handleInputChange(sugInput: string): void;
+    handleClear(): void;
+    /**
+     * A11y: simulate clear button click
+     */
+    handleClearEnterPress(keyboardEvent: any): void;
+    getRenderData(): BasicEntity[] | BasicData[];
+    getFilteredData(): BasicData[];
+    handleListScroll(e: any, ind: number): void;
+    handleTagRemove(e: any, tagValuePath: string[]): void;
+}