amis-rev-ui 6.13.0

package/esm/components/WithRemoteConfig.js

@@ -0,0 +1,301 @@
+/**
+ * amis-rev-ui v6.13.0
+ * Copyright 2018-2026 fex
+ */
+
+import { __generator, __extends, __awaiter, __rest, __assign } from 'tslib';
+import React__default from 'react';
+import hoistNonReactStatic from 'hoist-non-react-statics';
+import debounce from 'lodash/debounce';
+import { types, flow, isAlive } from 'mobx-state-tree';
+import { normalizeApiResponseData, isPureVariable, resolveVariableAndFilter, isEffectiveApi, normalizeApi, tokenize, buildApi, createObject, isObject, findTreeIndex, EnvContext } from 'amis-rev-core';
+import { reaction, comparer } from 'mobx';
+import { withStore } from './WithStore.js';
+
+var Store = types
+    .model('RemoteConfigStore')
+    .props({
+    fetching: false,
+    errorMsg: '',
+    config: types.frozen(),
+    data: types.frozen({})
+})
+    .actions(function (self) {
+    var component = undefined;
+    var fetchCancel = null;
+    var load = flow(function (env, api, ctx, config) {
+        var ret, data, options, e_1;
+        var _a;
+        if (config === void 0) { config = {}; }
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 2, 3, 4]);
+                    if (fetchCancel) {
+                        fetchCancel === null || fetchCancel === void 0 ? void 0 : fetchCancel('remote load request cancelled.');
+                        fetchCancel = null;
+                        self.fetching = false;
+                    }
+                    if (self.fetching) {
+                        return [2 /*return*/];
+                    }
+                    self.fetching = true;
+                    return [4 /*yield*/, env.fetcher(api, ctx, {
+                            cancelExecutor: function (executor) { return (fetchCancel = executor); }
+                        })];
+                case 1:
+                    ret = _b.sent();
+                    fetchCancel = null;
+                    if (!isAlive(self)) {
+                        return [2 /*return*/];
+                    }
+                    if (ret.ok) {
+                        data = normalizeApiResponseData(ret.data);
+                        options = config.adaptor
+                            ? config.adaptor(data, component.props)
+                            : data;
+                        self.setConfig(options, config, 'remote');
+                        (_a = config.afterLoad) === null || _a === void 0 ? void 0 : _a.call(config, data, self.config, component.props);
+                        return [2 /*return*/, ret];
+                    }
+                    else {
+                        throw new Error(ret.msg || 'fetch error');
+                    }
+                case 2:
+                    e_1 = _b.sent();
+                    isAlive(self) && (self.errorMsg = e_1.message);
+                    return [3 /*break*/, 4];
+                case 3:
+                    isAlive(self) && (self.fetching = false);
+                    return [7 /*endfinally*/];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+    return {
+        setComponent: function (c) {
+            component = c;
+        },
+        load: load,
+        setData: function (data) {
+            self.data = data || {};
+        },
+        setConfig: function (options, config, motivation) {
+            if (config.normalizeConfig) {
+                options =
+                    config.normalizeConfig(options, self.config, component.props, motivation) || options;
+            }
+            self.config = options;
+        }
+    };
+});
+function withRemoteConfig(config) {
+    if (config === void 0) { config = {}; }
+    return function (ComposedComponent) {
+        var _a;
+        var result = hoistNonReactStatic(withStore(function () { return Store.create(); })((_a = /** @class */ (function (_super) {
+                __extends(class_1, _super);
+                function class_1(props) {
+                    var _b;
+                    var _this = _super.call(this, props) || this;
+                    _this.toDispose = [];
+                    _this.loadOptions = debounce(_this.loadAutoComplete.bind(_this), 250, {
+                        trailing: true,
+                        leading: false
+                    });
+                    _this.setConfig = _this.setConfig.bind(_this);
+                    _this.childRef = _this.childRef.bind(_this);
+                    props.store.setComponent(_this);
+                    _this.deferLoadConfig = _this.deferLoadConfig.bind(_this);
+                    (_b = props.remoteConfigRef) === null || _b === void 0 ? void 0 : _b.call(props, _this);
+                    props.store.setData(props.data);
+                    _this.syncConfig();
+                    return _this;
+                }
+                class_1.prototype.componentDidMount = function () {
+                    var _this = this;
+                    var env = this.props.env || this.context;
+                    var _b = this.props, store = _b.store, data = _b.data;
+                    var source = this.props[config.sourceField || 'source'];
+                    if (isPureVariable(source)) {
+                        this.toDispose.push(reaction(function () {
+                            return resolveVariableAndFilter(source, store.data, '| raw');
+                        }, function () { return _this.syncConfig(); }, 
+                        // 当nav配置source: "${amisStore.app.portalNavs}"时，切换页面就会触发source更新
+                        // 因此这里增加这个配置 数据源完全不相等情况下再执行loadConfig
+                        // 否则数据源重置 保存不了展开状态 就会始终是手风琴模式了
+                        { equals: comparer.structural }));
+                    }
+                    else if (env && isEffectiveApi(source, data)) {
+                        this.loadConfig();
+                        source.autoRefresh !== false &&
+                            this.toDispose.push(reaction(function () {
+                                var api = normalizeApi(source);
+                                return api.trackExpression
+                                    ? tokenize(api.trackExpression, store.data)
+                                    : buildApi(api, store.data, {
+                                        ignoreData: true
+                                    }).url;
+                            }, function () { return _this.loadConfig(); }));
+                    }
+                };
+                class_1.prototype.componentDidUpdate = function (prevProps) {
+                    var props = this.props;
+                    if (props.data !== prevProps.data) {
+                        props.store.setData(props.data);
+                    }
+                };
+                class_1.prototype.componentWillUnmount = function () {
+                    var _b, _c;
+                    this.toDispose.forEach(function (fn) { return fn(); });
+                    this.toDispose = [];
+                    (_c = (_b = this.props).remoteConfigRef) === null || _c === void 0 ? void 0 : _c.call(_b, undefined);
+                    this.loadOptions.cancel();
+                };
+                class_1.prototype.loadConfig = function () {
+                    return __awaiter(this, arguments, void 0, function (ctx) {
+                        var env, _b, store, data, source;
+                        if (ctx === void 0) { ctx = this.props.data; }
+                        return __generator(this, function (_c) {
+                            switch (_c.label) {
+                                case 0:
+                                    env = this.props.env || this.context;
+                                    _b = this.props, store = _b.store, data = _b.data;
+                                    source = this.props[config.sourceField || 'source'];
+                                    // source: ${nav}、source: ${online ? '/api/v1' : '/api/v2'}
+                                    // 如果是配置source: ${nav} isEffectiveApi也会认为是api 发出一个无效请求
+                                    if (isPureVariable(source)) {
+                                        source = resolveVariableAndFilter(source, data, '| raw');
+                                    }
+                                    if (!(env && isEffectiveApi(source, ctx))) return [3 /*break*/, 2];
+                                    return [4 /*yield*/, store.load(env, source, ctx, config)];
+                                case 1:
+                                    _c.sent();
+                                    _c.label = 2;
+                                case 2: return [2 /*return*/];
+                            }
+                        });
+                    });
+                };
+                class_1.prototype.loadAutoComplete = function (input) {
+                    var env = this.props.env || this.context;
+                    var _b = this.props, autoComplete = _b.autoComplete, data = _b.data, store = _b.store;
+                    if (!env || !env.fetcher) {
+                        throw new Error('fetcher is required');
+                    }
+                    var ctx = createObject(data, {
+                        term: input,
+                        value: input
+                    });
+                    if (!isEffectiveApi(autoComplete, ctx)) {
+                        return Promise.resolve({
+                            options: []
+                        });
+                    }
+                    return store.load(env, autoComplete, ctx, config);
+                };
+                class_1.prototype.setConfig = function (value, ctx) {
+                    var store = this.props.store;
+                    store.setConfig(value, config, ctx);
+                };
+                class_1.prototype.syncConfig = function () {
+                    var _b = this.props, store = _b.store, data = _b.data;
+                    var source = this.props[config.sourceField || 'source'];
+                    if (isPureVariable(source)) {
+                        source =
+                            resolveVariableAndFilter(source, data, '| raw') || [];
+                        if (isEffectiveApi(source, data)) {
+                            this.loadConfig();
+                        }
+                        else {
+                            store.setConfig(source, config, 'syncConfig');
+                        }
+                    }
+                    else if (isObject(source) && !source.method) {
+                        store.setConfig(source, config, 'syncConfig');
+                    }
+                };
+                class_1.prototype.deferLoadConfig = function (item) {
+                    return __awaiter(this, void 0, void 0, function () {
+                        var _b, store, data, deferApi, source, env, indexes, ret, response, e_2, ret2;
+                        var _c, _d;
+                        return __generator(this, function (_e) {
+                            switch (_e.label) {
+                                case 0:
+                                    _b = this.props, store = _b.store, data = _b.data, deferApi = _b.deferApi;
+                                    source = this.props[config.sourceField || 'source'];
+                                    env = this.props.env || this.context;
+                                    indexes = findTreeIndex(store.config, function (a) { return a === item; });
+                                    ret = (_c = config.beforeDeferLoad) === null || _c === void 0 ? void 0 : _c.call(config, item, indexes, store.config, this.props);
+                                    ret && store.setConfig(ret, config, 'before-defer-load');
+                                    _e.label = 1;
+                                case 1:
+                                    _e.trys.push([1, 3, , 4]);
+                                    if (!isEffectiveApi(item.deferApi || deferApi || source)) {
+                                        throw new Error('deferApi is required');
+                                    }
+                                    return [4 /*yield*/, env.fetcher(item.deferApi || deferApi || source, createObject(data, item))];
+                                case 2:
+                                    response = _e.sent();
+                                    return [3 /*break*/, 4];
+                                case 3:
+                                    e_2 = _e.sent();
+                                    response = {
+                                        ok: false,
+                                        msg: e_2.message,
+                                        status: 500,
+                                        data: undefined
+                                    };
+                                    return [3 /*break*/, 4];
+                                case 4: return [4 /*yield*/, ((_d = config.afterDeferLoad) === null || _d === void 0 ? void 0 : _d.call(config, item, indexes, // 只能假定还是那个 index 了
+                                    response, store.config, this.props))];
+                                case 5:
+                                    ret2 = _e.sent();
+                                    ret2 && store.setConfig(ret2, config, 'after-defer-load');
+                                    return [2 /*return*/];
+                            }
+                        });
+                    });
+                };
+                class_1.prototype.childRef = function (ref) {
+                    while (ref && ref.getWrappedInstance) {
+                        ref = ref.getWrappedInstance();
+                    }
+                    this.ref = ref;
+                };
+                class_1.prototype.getWrappedInstance = function () {
+                    return this.ref;
+                };
+                class_1.prototype.render = function () {
+                    var _b;
+                    var store = this.props.store;
+                    var env = this.props.env || this.context;
+                    var injectedProps = {
+                        config: store.config,
+                        loading: store.fetching,
+                        deferLoad: this.deferLoadConfig,
+                        updateConfig: this.setConfig
+                    };
+                    var _c = this.props; _c.remoteConfigRef; var autoComplete = _c.autoComplete, rest = __rest(_c, ["remoteConfigRef", "autoComplete"]);
+                    var refConfig = ((_b = ComposedComponent.prototype) === null || _b === void 0 ? void 0 : _b.isReactComponent) ||
+                        ComposedComponent.$$typeof ===
+                            Symbol.for('react.forward_ref')
+                        ? { ref: this.childRef }
+                        : { forwardedRef: this.childRef };
+                    return (React__default.createElement(ComposedComponent, __assign({}, rest, (env && isEffectiveApi(autoComplete) && this.loadOptions
+                        ? { loadOptions: this.loadOptions }
+                        : {}), (config.injectedPropsFilter
+                        ? config.injectedPropsFilter(injectedProps, this.props)
+                        : injectedProps), refConfig)));
+                };
+                return class_1;
+            }(React__default.Component)),
+            _a.displayName = "WithRemoteConfig(".concat(ComposedComponent.displayName || ComposedComponent.name, ")"),
+            _a.ComposedComponent = ComposedComponent,
+            _a.contextType = EnvContext,
+            _a)), ComposedComponent);
+        return result;
+    };
+}
+
+export { Store, withRemoteConfig };

package/esm/components/WithStore.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 接管 store 的生命周期，这个比较轻量，适合在组件中使用。
+ * 相比渲染器中的 withStore，这里面的 store 不会在一个大树中。
+ * 而且不会知道父级和子级中还有哪些 store。
+ */
+import React from 'react';
+import { IAnyStateTreeNode } from 'mobx-state-tree';
+export declare function withStore<K extends IAnyStateTreeNode>(storeFactory: (props: any) => K): <T extends React.ComponentType<React.ComponentProps<T> & {
+    store: K;
+}>>(ComposedComponent: T) => any & {
+    ComposedComponent: T;
+};
+export default withStore;

package/esm/components/WithStore.js

@@ -0,0 +1,48 @@
+/**
+ * amis-rev-ui v6.13.0
+ * Copyright 2018-2026 fex
+ */
+
+import { __extends, __spreadArray, __read, __assign } from 'tslib';
+import React__default from 'react';
+import hoistNonReactStatic from 'hoist-non-react-statics';
+import { destroy } from 'mobx-state-tree';
+import { observer } from 'mobx-react';
+
+function withStore(storeFactory) {
+    return function (ComposedComponent) {
+        var _a;
+        ComposedComponent = observer(ComposedComponent);
+        var result = hoistNonReactStatic((_a = /** @class */ (function (_super) {
+                __extends(class_1, _super);
+                function class_1() {
+                    var _this = _super.apply(this, __spreadArray([], __read(arguments), false)) || this;
+                    _this.store = storeFactory(_this.props);
+                    _this.refFn = function (ref) {
+                        _this.ref = ref;
+                    };
+                    return _this;
+                }
+                class_1.prototype.componentWillUnmount = function () {
+                    this.store && destroy(this.store);
+                    delete this.store;
+                };
+                class_1.prototype.getWrappedInstance = function () {
+                    return this.ref;
+                };
+                class_1.prototype.render = function () {
+                    var injectedProps = {
+                        store: this.store
+                    };
+                    return (React__default.createElement(ComposedComponent, __assign({}, this.props, injectedProps, { ref: this.refFn })));
+                };
+                return class_1;
+            }(React__default.Component)),
+            _a.displayName = "WithStore(".concat(ComposedComponent.displayName || 'Unkown', ")"),
+            _a.ComposedComponent = ComposedComponent,
+            _a), ComposedComponent);
+        return result;
+    };
+}
+
+export { withStore as default, withStore };

package/esm/components/calendar/Calendar.d.ts

@@ -0,0 +1,83 @@
+/**
+ * @file 基于 react-datetime 改造。
+ */
+import React from 'react';
+import moment from 'moment';
+import 'moment/locale/zh-cn';
+import 'moment/locale/de';
+import type { RendererEnv, TestIdBuilder } from 'amis-rev-core';
+import type { unitOfTime } from 'moment';
+/** 视图模式 */
+export type ViewMode = 'days' | 'months' | 'years' | 'time' | 'quarters';
+export type DateType = 'year' | 'month' | 'date' | 'hours' | 'minutes' | 'seconds';
+/** 底层View组件修改的值类型：time时间、days日期 */
+export type ChangeEventViewMode = Extract<ViewMode, 'time' | 'days'>;
+export type ChangeEventViewStatus = 'start' | 'end';
+/** 可改变的时间单位 */
+export type MutableUnitOfTime = Extract<unitOfTime.All, 'date' | 'hour' | 'minute' | 'second' | 'millisecond'>;
+export interface BoundaryObject {
+    max: number;
+    min: number;
+}
+export interface DateBoundary {
+    year: BoundaryObject;
+    month: BoundaryObject;
+    date: BoundaryObject;
+    hours: BoundaryObject;
+    minutes: BoundaryObject;
+    seconds: BoundaryObject;
+}
+interface BaseDatePickerProps {
+    className?: string;
+    value?: any;
+    defaultValue?: any;
+    viewMode?: ViewMode;
+    dateFormat?: boolean | string;
+    inputFormat?: boolean | string;
+    displayForamt?: boolean | string;
+    timeFormat?: any;
+    input?: boolean;
+    locale: string;
+    date?: any;
+    isValidDate?: (currentDate: moment.Moment, selected?: moment.Moment) => boolean;
+    onViewModeChange?: (type: string) => void;
+    requiredConfirm?: boolean;
+    onClick?: (date: moment.Moment) => any;
+    onMouseEnter?: (date: moment.Moment) => any;
+    onMouseLeave?: (date: moment.Moment) => any;
+    onClose?: () => void;
+    onChange?: (value: any, viewMode?: ChangeEventViewMode, status?: ChangeEventViewStatus) => void;
+    isEndDate?: boolean;
+    minDate?: moment.Moment;
+    maxDate?: moment.Moment;
+    viewDate?: moment.Moment;
+    renderDay?: (props: any, currentDate: moment.Moment, selectedDate: moment.Moment) => JSX.Element;
+    renderMonth?: (props: any, month: number, year: number, date: any) => JSX.Element;
+    renderQuarter?: (props: any, quartar: number, year?: number, date?: moment.Moment) => JSX.Element;
+    renderYear?: (props: any, year: number) => JSX.Element;
+    schedules?: Array<{
+        startTime: Date;
+        endTime: Date;
+        content: string | React.ReactElement;
+        color?: string;
+    }>;
+    env?: RendererEnv;
+    largeMode?: boolean;
+    todayActiveStyle?: React.CSSProperties;
+    onScheduleClick?: (scheduleData: any) => void;
+    hideHeader?: boolean;
+    updateOn?: string;
+    mobileUI?: boolean;
+    embed?: boolean;
+    closeOnSelect?: boolean;
+    showToolbar?: boolean;
+    open?: boolean;
+    utc?: boolean;
+    displayTimeZone?: string;
+    timeConstraints?: any;
+    timeRangeHeader?: string;
+    status?: ChangeEventViewStatus;
+    testIdBuilder?: TestIdBuilder;
+}
+declare const _default: React.ComponentType<BaseDatePickerProps>;
+export default _default;