amis-core 6.11.0-beta.0 → 6.11.0-beta.2

package/esm/components/Animations.js

@@ -0,0 +1,158 @@
+/**
+ * amis-core v6.11.0-beta.2
+ * Copyright 2018-2024 fex
+ */
+
+import { __read } from 'tslib';
+import React, { useState, useMemo, useEffect, useCallback } from 'react';
+import { CSSTransition } from 'react-transition-group';
+import '../utils/api.js';
+import '../utils/browser.js';
+import '../utils/ColorScale.js';
+import 'lodash/chunk';
+import 'lodash/isPlainObject';
+import 'amis-formula';
+import '../utils/memoryParse.js';
+import '../utils/DataSchema.js';
+import '../utils/DataScope.js';
+import 'moment';
+import '../utils/debug.js';
+import 'react-dom';
+import { formateId } from '../utils/helper.js';
+import '../utils/errors.js';
+import '../utils/tpl.js';
+import '../utils/filter.js';
+import 'lodash/isObject';
+import 'lodash/isString';
+import 'lodash/isBoolean';
+import '@rc-component/mini-decimal';
+import '../utils/image.js';
+import 'lodash/isEqual';
+import '../actions/Action.js';
+import 'lodash/debounce';
+import '../utils/resize-sensor.js';
+import 'react-overlays/useRootClose';
+import '../utils/SimpleMap.js';
+import 'lodash/mapValues';
+import 'lodash/camelCase';
+import 'lodash/cloneDeep';
+import 'lodash/map';
+import 'lodash/isEmpty';
+import 'lodash/kebabCase';
+import 'uncontrollable';
+import 'hoist-non-react-statics';
+import '../utils/validations.js';
+import '../utils/resolveCondition.js';
+import 'mobx';
+import '../utils/Animation.js';
+import { createAnimationStyle } from '../utils/animations.js';
+import styleManager from '../StyleManager.js';
+
+function Animations(_a) {
+    var schema = _a.schema, component = _a.component, show = _a.show;
+    var enter = (schema.animations || {}).enter;
+    var _b = __read(useState(!(enter === null || enter === void 0 ? void 0 : enter.inView)), 2), animationShow = _b[0], setAnimationShow = _b[1];
+    var _c = __read(useState(!!(enter === null || enter === void 0 ? void 0 : enter.inView)), 2), placeholderShow = _c[0], setPlaceholderShow = _c[1];
+    var id = useMemo(function () { return formateId(schema.id); }, []);
+    var observer = useMemo(newObserver, []);
+    var animationClassNames = useMemo(initAnimationClassNames, []);
+    var animationTimeout = useMemo(initAnimationTimeout, []);
+    useEffect(function () {
+        createAnimationStyle(id, schema.animations);
+        return function () {
+            if (schema.animations) {
+                styleManager.removeStyles(id);
+            }
+            observer.disconnect();
+        };
+    }, []);
+    function newObserver() {
+        return new IntersectionObserver(function (entries, observer) {
+            entries.forEach(function (entry) {
+                if (entry.target.getAttribute('data-role') === 'animation-placeholder') {
+                    if (entry.isIntersecting) {
+                        setAnimationShow(true);
+                        setPlaceholderShow(false);
+                        observer.unobserve(entry.target);
+                    }
+                }
+                else {
+                    if (!entry.isIntersecting) {
+                        setAnimationShow(false);
+                        observer.unobserve(entry.target);
+                    }
+                }
+            });
+        }, {
+            root: null,
+            rootMargin: '0px',
+            threshold: 0.1
+        });
+    }
+    function initAnimationClassNames() {
+        var animations = schema === null || schema === void 0 ? void 0 : schema.animations;
+        var animationClassNames = {
+            appear: '',
+            enter: '',
+            exit: ''
+        };
+        if (animations) {
+            if (animations.enter) {
+                animationClassNames.enter = "".concat(animations.enter.type, "-").concat(id, "-enter");
+                animationClassNames.appear = animationClassNames.enter;
+            }
+            if (animations.exit) {
+                animationClassNames.exit = "".concat(animations.exit.type, "-").concat(id, "-exit");
+            }
+        }
+        return animationClassNames;
+    }
+    function initAnimationTimeout() {
+        var animations = schema === null || schema === void 0 ? void 0 : schema.animations;
+        var animationTimeout = {
+            enter: 0,
+            exit: 0
+        };
+        if (animations) {
+            if (animations.enter) {
+                animationTimeout.enter =
+                    ((animations.enter.duration || 1) + (animations.enter.delay || 0)) *
+                        1000;
+            }
+            if (animations.exit) {
+                animationTimeout.exit =
+                    ((animations.exit.duration || 1) + (animations.exit.delay || 0)) *
+                        1000;
+            }
+        }
+        return animationTimeout;
+    }
+    function refFn(ref) {
+        if (ref) {
+            observer.observe(ref);
+        }
+    }
+    var handleEntered = useCallback(function (node) {
+        var _a = schema.animations || {}, attention = _a.attention, exit = _a.exit, enter = _a.enter;
+        if (attention) {
+            node.classList.add("".concat(attention.type, "-").concat(id, "-attention"));
+        }
+        if ((exit === null || exit === void 0 ? void 0 : exit.outView) || (enter === null || enter === void 0 ? void 0 : enter.repeat)) {
+            observer.observe(node);
+        }
+    }, []);
+    var handleExit = useCallback(function (node) {
+        var attention = (schema.animations || {}).attention;
+        if (attention) {
+            node.classList.remove("".concat(attention.type, "-").concat(id, "-attention"));
+        }
+    }, []);
+    var handleExited = useCallback(function () {
+        setPlaceholderShow(true);
+    }, []);
+    return (React.createElement(React.Fragment, null,
+        !animationShow && show && placeholderShow && (React.createElement("div", { ref: refFn, className: "amis-animation-placeholder", "data-role": "animation-placeholder" }, component)),
+        React.createElement(CSSTransition, { in: animationShow && show, timeout: animationTimeout, classNames: animationClassNames, onEntered: handleEntered, onExit: handleExit, onExited: handleExited, appear: true, unmountOnExit: true }, component)));
+}
+
+export { Animations as default };

package/esm/components/CustomStyle.js

@@ -1,5 +1,5 @@
 /**
- * amis-core v6.11.0-beta.0
+ * amis-core v6.11.0-beta.2
  * Copyright 2018-2024 fex
  */
 

package/esm/components/ErrorBoundary.js

@@ -1,5 +1,5 @@
 /**
- * amis-core v6.11.0-beta.0
+ * amis-core v6.11.0-beta.2
  * Copyright 2018-2024 fex
  */
 

package/esm/components/LazyComponent.d.ts

@@ -60,7 +60,7 @@ declare const themedLazyComponent: {
         componentWillUpdate?(nextProps: Readonly<Omit<LazyComponentProps, keyof ThemeProps> & import("../theme").ThemeOuterProps>, nextState: Readonly<{}>, nextContext: any): void;
         UNSAFE_componentWillUpdate?(nextProps: Readonly<Omit<LazyComponentProps, keyof ThemeProps> & import("../theme").ThemeOuterProps>, nextState: Readonly<{}>, nextContext: any): void;
     };
-    displayName: any;
+    displayName: string;
     contextType: React.Context<string>;
     ComposedComponent: React.ComponentType<typeof LazyComponent>;
 } & import("hoist-non-react-statics").NonReactStatics<typeof LazyComponent, {}> & {

package/esm/components/LazyComponent.js

@@ -1,5 +1,5 @@
 /**
- * amis-core v6.11.0-beta.0
+ * amis-core v6.11.0-beta.2
  * Copyright 2018-2024 fex
  */
 

package/esm/components/Overlay.js

@@ -1,5 +1,5 @@
 /**
- * amis-core v6.11.0-beta.0
+ * amis-core v6.11.0-beta.2
  * Copyright 2018-2024 fex
  */
 

package/esm/components/PopOver.d.ts

@@ -85,7 +85,7 @@ declare const _default: {
         componentWillUpdate?(nextProps: Readonly<Omit<PopOverProps, keyof import("../theme").ThemeProps> & import("../theme").ThemeOuterProps>, nextState: Readonly<{}>, nextContext: any): void;
         UNSAFE_componentWillUpdate?(nextProps: Readonly<Omit<PopOverProps, keyof import("../theme").ThemeProps> & import("../theme").ThemeOuterProps>, nextState: Readonly<{}>, nextContext: any): void;
     };
-    displayName: any;
+    displayName: string;
     contextType: React.Context<string>;
     ComposedComponent: React.ComponentType<typeof PopOver>;
 } & import("hoist-non-react-statics").NonReactStatics<typeof PopOver, {}> & {

package/esm/components/PopOver.js

@@ -1,5 +1,5 @@
 /**
- * amis-core v6.11.0-beta.0
+ * amis-core v6.11.0-beta.2
  * Copyright 2018-2024 fex
  */
 

package/esm/env.d.ts

@@ -202,7 +202,7 @@ export declare function withRendererEnv<T extends React.ComponentType<React.Comp
             env?: RendererEnv | undefined;
         }>, nextState: Readonly<{}>, nextContext: any): void;
     };
-    displayName: any;
+    displayName: string;
     contextType: React.Context<void | RendererEnv>;
     ComposedComponent: React.ComponentType<T>;
 } & hoistNonReactStatic.NonReactStatics<T, {}> & {

package/esm/env.js

@@ -1,5 +1,5 @@
 /**
- * amis-core v6.11.0-beta.0
+ * amis-core v6.11.0-beta.2
  * Copyright 2018-2024 fex
  */
 

package/esm/envOverwrite.js

@@ -1,5 +1,5 @@
 /**
- * amis-core v6.11.0-beta.0
+ * amis-core v6.11.0-beta.2
  * Copyright 2018-2024 fex
  */
 

package/esm/factory.d.ts

@@ -20,6 +20,7 @@ export interface RendererBasicConfig {
     defaultProps?: (type: string, schema: any) => any;
     shouldSyncSuperStore?: (store: any, props: any, prevProps: any) => boolean | undefined;
     storeExtendsData?: boolean | ((props: any) => boolean);
+    onGlobalVarChanged?: (instance: React.Component, schema: any, data: any) => void | boolean;
     weight?: number;
     isolateScope?: boolean;
     isFormItem?: boolean;

package/esm/factory.js

@@ -1,5 +1,5 @@
 /**
- * amis-core v6.11.0-beta.0
+ * amis-core v6.11.0-beta.2
  * Copyright 2018-2024 fex
  */
 

package/esm/globalVar.d.ts

@@ -0,0 +1,173 @@
+/**
+ * 全局变量
+ *
+ * 用于实现跨组件、跨页面的数据共享，支持持久化。
+ */
+import { JSONSchema } from './types';
+import { IRootStore } from './store/root';
+/**
+ * 全局变量的定义
+ */
+export interface GlobalVariableItem {
+    id?: string;
+    /**
+     * 设计态属性。
+     * 全局变量类型，不是数据体类型，而是用于区分不同的配置方式。
+     * 这个字段运行时无含义，主要用于编辑器中的分类。
+     *
+     * 比如平台可能扩充：应用级别、页面级别、用户级别、数据字典关联、数据模型关联等。
+     * amis 中内置了：builtin 为简单的客户端存储，服务端存储需要外部扩充。
+     *
+     * @default builtin
+     */
+    type?: string | 'builtin';
+    /**
+     * 变量名
+     */
+    key: string;
+    /**
+     * 变量标题
+     */
+    label?: string;
+    /**
+     * 变量描述
+     */
+    description?: string;
+    /**
+     * 默认值
+     */
+    defaultValue?: string;
+    /**
+     * 值的数据类型定义
+     */
+    valueSchema?: JSONSchema;
+    /**
+     * 数据作用域
+     */
+    scope?: 'page' | 'app';
+    /**
+     * 数据存储方式
+     */
+    storageOn?: 'client' | 'server' | 'session';
+    /**
+     * 是否只读，不允许修改，运行态属性。
+     */
+    readonly?: boolean;
+    /**
+     * @default true
+     * 是否自动保存，如果不特殊配置，会自动保存
+     */
+    autoSave?: boolean;
+    validationErrors?: any;
+    validations?: any;
+    [propName: string]: any;
+}
+export type GlobalVarGetter = (variable: GlobalVariableItem, context: GlobalVarContext) => Promise<any>;
+export type GlobalVarBulkGetter = (context: GlobalVarContext) => Promise<Record<string, any>> | Record<string, any>;
+export type GlobalVarSetter = (variable: GlobalVariableItem, value: Record<string, any>, context: GlobalVarContext) => Promise<any>;
+export type GlobalVarBulkSetter = (values: Record<string, any>, context: GlobalVarContext) => Promise<any> | any;
+export interface GlobalVariableItemFull extends GlobalVariableItem {
+    /**
+     * 校验数值是否合法
+     * @param value
+     * @returns
+     */
+    validate?: (value: any, values: Record<string, any>) => string | void;
+    /**
+     * 权重，用于排序
+     */
+    order?: number;
+    /**
+     * 单个数据初始化获取
+     * @returns
+     */
+    getter?: GlobalVarGetter;
+    /**
+     * 批量数据初始化获取
+     * @returns
+     */
+    bulkGetter?: GlobalVarBulkGetter;
+    /**
+     * 当个数据修改保存
+     * @param value
+     * @returns
+     */
+    setter?: GlobalVarSetter;
+    /**
+     * 批量全局变量数据保存，多个变量一起保存
+     * @param values
+     * @returns
+     */
+    bulkSetter?: GlobalVarBulkSetter;
+}
+/**
+ * 全局变量的状态
+ */
+export interface GlobalVariableState {
+    /**
+     * 当前值
+     */
+    value: any;
+    /**
+     * 原始值
+     */
+    pristine: any;
+    /**
+     * 是否正在加载, 或者说正在获取
+     */
+    busy?: boolean;
+    /**
+     * 是否已经初始化
+     */
+    initialized: boolean;
+    /**
+     * 数据是否合法
+     */
+    valid: boolean;
+    /**
+     * 错误馨馨
+     */
+    errorMessages: string[];
+    /**
+     * 是否有变更
+     */
+    touched: boolean;
+    /**
+     * 是否有保存
+     */
+    saved: boolean;
+}
+export interface GlobalVarContext {
+    variables: Array<GlobalVariableItem>;
+    [propName: string]: any;
+}
+/**
+ * 全局变量处理器, 可以处理全变量的初始化、校验、存储等操作
+ */
+export type GlobalVariableHandler = (variable: GlobalVariableItem | GlobalVariableItemFull, context: GlobalVarContext) => GlobalVariableItemFull | void | ((variable: GlobalVariableItem | GlobalVariableItemFull, context: GlobalVarContext) => GlobalVariableItemFull | void);
+/**
+ * 注册全局变量处理器
+ * @param handler
+ */
+export declare function registerGlobalVariableHandler(handler: GlobalVariableHandler): void;
+/**
+ * 通过处理器构建全局变量细节对象，用于后续的初始化、校验、存储等操作
+ * @param variable
+ * @param context
+ * @returns
+ */
+export declare function buildGlobalVariable(variable: GlobalVariableItem | GlobalVariableItemFull, context: GlobalVarContext): GlobalVariableItemFull;
+/**
+ * 构建变量初始状态
+ * @returns
+ */
+export declare function createGlobalVarState(): GlobalVariableState;
+export declare function isGlobalVarExpression(value: string): boolean;
+/**
+ * 监控组件的全局变量
+ * @param schema
+ * @param topStore
+ * @param callback
+ * @returns
+ */
+export declare function observeGlobalVars(schema: any, topStore: IRootStore, callback: () => void): () => void;

package/esm/globalVar.js

@@ -0,0 +1,122 @@
+/**
+ * amis-core v6.11.0-beta.2
+ * Copyright 2018-2024 fex
+ */
+
+import { isExpression } from './utils/formula.js';
+import { reaction } from 'mobx';
+import { resolveVariableAndFilter } from './utils/resolveVariableAndFilter.js';
+
+/**
+ * 全局变量
+ *
+ * 用于实现跨组件、跨页面的数据共享，支持持久化。
+ */
+var handlers = [];
+/**
+ * 注册全局变量处理器
+ * @param handler
+ */
+function registerGlobalVariableHandler(handler) {
+    handlers.push(handler);
+}
+/**
+ * 通过处理器构建全局变量细节对象，用于后续的初始化、校验、存储等操作
+ * @param variable
+ * @param context
+ * @returns
+ */
+function buildGlobalVariable(variable, context) {
+    var postHandlers = [];
+    var result = handlers.reduce(function (item, handler) {
+        var result = handler(item, context);
+        if (typeof result === 'function') {
+            postHandlers.push(result);
+        }
+        return (result !== null && result !== void 0 ? result : item);
+    }, variable);
+    result = postHandlers.reduce(function (item, handler) { var _a; return (_a = handler(item, context)) !== null && _a !== void 0 ? _a : item; }, result);
+    return result;
+}
+/**
+ * 构建变量初始状态
+ * @returns
+ */
+function createGlobalVarState() {
+    return {
+        value: undefined,
+        pristine: undefined,
+        initialized: false,
+        valid: true,
+        errorMessages: [],
+        touched: false,
+        saved: false
+    };
+}
+// 前两个是历史遗留，后两个是新的
+var globalVarFields = ['__page.', 'appVariables.', 'global.', 'globalState.'];
+function isGlobalVarExpression(value) {
+    return (typeof value === 'string' &&
+        isExpression(value) &&
+        globalVarFields.some(function (k) { return value.includes(k); }));
+}
+/**
+ * 监控组件的全局变量
+ * @param schema
+ * @param topStore
+ * @param callback
+ * @returns
+ */
+function observeGlobalVars(schema, topStore, callback) {
+    var expressions = [];
+    Object.keys(schema).forEach(function (key) {
+        var value = schema[key];
+        if (isGlobalVarExpression(value)) {
+            expressions.push({
+                key: key,
+                value: value
+            });
+        }
+        else if ([
+            'items',
+            'body',
+            'buttons',
+            'header',
+            'columns',
+            'tabs',
+            'footer',
+            'actions',
+            'toolbar'
+        ].includes(key)) {
+            var items = Array.isArray(value) ? value : [value];
+            items.forEach(function (item) {
+                if (isGlobalVarExpression(item === null || item === void 0 ? void 0 : item.visibleOn)) {
+                    expressions.push({
+                        key: "".concat(key, ".x.visibleOn"),
+                        value: item.visibleOn
+                    });
+                }
+                else if (isGlobalVarExpression(item === null || item === void 0 ? void 0 : item.hiddenOn)) {
+                    expressions.push({
+                        key: "".concat(key, ".x.hiddenOn"),
+                        value: item.hiddenOn
+                    });
+                }
+            });
+        }
+    });
+    if (!expressions.length) {
+        return function () { };
+    }
+    var unReaction = reaction(function () {
+        return expressions
+            .map(function (exp) {
+            return "".concat(exp.key, ":").concat(resolveVariableAndFilter(exp.value, topStore.downStream, '| json' // 如果用了复杂对象，要靠这个来比较
+            ));
+        })
+            .join(',');
+    }, callback);
+    return unReaction;
+}
+
+export { buildGlobalVariable, createGlobalVarState, isGlobalVarExpression, observeGlobalVars, registerGlobalVariableHandler };

package/esm/globalVarClientHandler.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/globalVarClientHandler.js

@@ -0,0 +1,65 @@
+/**
+ * amis-core v6.11.0-beta.2
+ * Copyright 2018-2024 fex
+ */
+
+import { __assign } from 'tslib';
+import { registerGlobalVariableHandler } from './globalVar.js';
+
+function loadClientData(key, variables) {
+    var str = localStorage.getItem(key);
+    var data = {};
+    try {
+        data = JSON.parse(str || '{}');
+    }
+    catch (e) {
+        console.error("parse localstorage \"".concat(key, " error\""), e);
+    }
+    var filterData = {};
+    variables.forEach(function (item) {
+        if (data.hasOwnProperty(item.key)) {
+            filterData[item.key] = data[item.key];
+        }
+    });
+    return filterData;
+}
+function saveClientData(key, values, variables) {
+    var str = localStorage.getItem(key);
+    var data = {};
+    try {
+        data = JSON.parse(str || '{}');
+    }
+    catch (e) {
+        console.error("parse localstorage \"".concat(key, " error\""), e);
+    }
+    Object.assign(data, values);
+    localStorage.setItem(key, JSON.stringify(data));
+}
+function bulkClientGetter(_a) {
+    var variables = _a.variables;
+    return loadClientData('amis-client-vars', variables);
+}
+function bulkClientSetter(values, context) {
+    return saveClientData('amis-client-vars', values, context.variables);
+}
+function pageBulkClientGetter(context) {
+    var variables = context.variables;
+    var key = "amis-client-vars-".concat(context.pageId || location.pathname);
+    return loadClientData(key, variables);
+}
+function pageBulkClientSetter(values, context) {
+    var key = "amis-client-vars-".concat(context.pageId || location.pathname);
+    return saveClientData(key, values, context.variables);
+}
+/**
+ * 注册全局变量处理器，用来处理 storageOn 为 client 的变量
+ *
+ * 并且根据变量的 scope 来决定是 page 还是全局的
+ *
+ * 将数据存入 localStorage
+ */
+registerGlobalVariableHandler(function (variable, context) {
+    if (variable.storageOn === 'client') {
+        return __assign(__assign({}, variable), { bulkGetter: variable.scope === 'page' ? pageBulkClientGetter : bulkClientGetter, bulkSetter: variable.scope === 'page' ? pageBulkClientSetter : bulkClientSetter });
+    }
+});

package/esm/globalVarDefaultValueHandler.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/globalVarDefaultValueHandler.js

@@ -0,0 +1,28 @@
+/**
+ * amis-core v6.11.0-beta.2
+ * Copyright 2018-2024 fex
+ */
+
+import { __assign } from 'tslib';
+import { registerGlobalVariableHandler } from './globalVar.js';
+
+/**
+ * 格式化默认值
+ */
+registerGlobalVariableHandler(function (variable, context) {
+    var _a;
+    if (variable.defaultValue && typeof variable.defaultValue === 'string') {
+        var defaultValue = variable.defaultValue;
+        try {
+            var value = defaultValue;
+            var valueType = (_a = variable.valueSchema) === null || _a === void 0 ? void 0 : _a.type;
+            if (valueType && ['number', 'array', 'object'].includes(valueType)) {
+                value = JSON.parse(defaultValue);
+            }
+            return __assign(__assign({}, variable), { defaultValue: value });
+        }
+        catch (e) {
+            // do nothing
+        }
+    }
+});

package/esm/index.d.ts

@@ -15,7 +15,10 @@ export * from './utils/index';
 export * from './utils/animations';
 export * from './types';
 export * from './store';
+export * from './globalVar';
 import * as utils from './utils/helper';
+import './globalVarClientHandler';
+import './globalVarDefaultValueHandler';
 import { RegisterStore, registerStore } from './store';
 import type { IColumn, IColumn2, IRow, IRow2 } from './store';
 import { setDefaultLocale, getDefaultLocale, makeTranslator, register as registerLocale, extendLocale, removeLocaleData, localeable } from './locale';