@chaomingd/design 0.0.68

package/dist/esm/UploadFile/utils/validateFileTypes.js

@@ -0,0 +1,83 @@
+import fileTypeChecker from 'file-type-checker';
+import { getExt } from "./getExt";
+function trimDot(str) {
+  if (str[0] === '.') {
+    return str.slice(1);
+  }
+  return str;
+}
+export function validateFileTypes(file, types) {
+  return new Promise(function (resolve, reject) {
+    var reader = new FileReader();
+    reader.onload = function () {
+      var ext = getExt(file.name);
+      if (reader.result) {
+        try {
+          var isValid = fileTypeChecker.validateFileType(reader.result, types.map(function (type) {
+            return trimDot(type);
+          }));
+          var fileInfo = fileTypeChecker.detectFile(reader.result) || {
+            extension: ext,
+            mimeType: file.type,
+            description: file.type
+          };
+          resolve({
+            isValid: isValid,
+            fileInfo: fileInfo
+          });
+        } catch (e) {
+          resolve({
+            isValid: types.map(function (type) {
+              return trimDot(type);
+            }).includes(ext),
+            fileInfo: {
+              extension: ext,
+              mimeType: file.type,
+              description: file.type
+            }
+          });
+        }
+        return;
+      }
+      reject(new Error('reader arraybuffer empty'));
+    };
+    reader.onerror = function (e) {
+      reject(e);
+    };
+    reader.readAsArrayBuffer(file);
+  });
+}
+export function getFileInfo(file) {
+  return new Promise(function (resolve, reject) {
+    var reader = new FileReader();
+    reader.onload = function () {
+      if (reader.result) {
+        try {
+          var fileInfo = fileTypeChecker.detectFile(reader.result);
+          if (fileInfo) {
+            resolve(fileInfo);
+            return;
+          }
+          resolve({
+            extension: getExt(file.name),
+            mimeType: file.type,
+            description: file.type
+          });
+        } catch (e) {
+          console.warn('file-type-checker error', e);
+          resolve({
+            extension: getExt(file.name),
+            mimeType: file.type,
+            description: file.type
+          });
+        }
+        return;
+      }
+      reject(new Error('reader arraybuffer empty'));
+    };
+    reader.onerror = function (e) {
+      reject(e);
+    };
+    reader.readAsArrayBuffer(file);
+  });
+}

package/dist/esm/UploadFile/utils/validateRule.d.ts

@@ -0,0 +1,3 @@
+export declare function getValidateRule(): {
+    validator: (_: any, val: any[]) => Promise<void>;
+};

package/dist/esm/UploadFile/utils/validateRule.js

@@ -0,0 +1,22 @@
+export function getValidateRule() {
+  return {
+    validator: function validator(_, val) {
+      if (Array.isArray(val)) {
+        var valid = true;
+        var message = '';
+        for (var i = 0; i < val.length; i++) {
+          var item = val[i];
+          if (item.status === 'error') {
+            valid = false;
+            message = '文件上传失败';
+            break;
+          }
+        }
+        if (!valid) {
+          return Promise.reject(new Error(message));
+        }
+      }
+      return Promise.resolve();
+    }
+  };
+}

package/dist/esm/UploadFile/utils/validateUpload.d.ts

@@ -0,0 +1,5 @@
+import { FileListItemProps } from '../type';
+export declare function validateUpload(fileItems: FileListItemProps[]): {
+    isValid: boolean;
+    message: string;
+};

package/dist/esm/UploadFile/utils/validateUpload.js

@@ -0,0 +1,35 @@
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+export function validateUpload(fileItems) {
+  var isValid = true;
+  var message = '';
+  var _iterator = _createForOfIteratorHelper(fileItems),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var fileItem = _step.value;
+      if (fileItem.status === 'uploading') {
+        isValid = false;
+        message = "\u6587\u4EF6".concat(fileItem.name, "\u672A\u4E0A\u4F20\u5B8C\u6210");
+        break;
+      }
+      if (fileItem.validationStatus === 'validating') {
+        isValid = false;
+        message = "\u6587\u4EF6".concat(fileItem.name, "\u672A\u6821\u9A8C\u5B8C\u6210");
+        break;
+      }
+      if (fileItem.validationStatus === 'error') {
+        isValid = false;
+        message = "\u6587\u4EF6".concat(fileItem.name, "\u6821\u9A8C\u5931\u8D25");
+        break;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return {
+    isValid: isValid,
+    message: message
+  };
+}

package/dist/esm/constant/index.d.ts

@@ -0,0 +1,7 @@
+export declare const OB_SITE_LINK = "https://www.xxx.com";
+export declare const LOCALE_LIST: {
+    value: string;
+    label: string;
+    shortLabel: string;
+    minLabel: string;
+}[];

package/dist/esm/constant/index.js

@@ -0,0 +1,18 @@
+// OB 官网链接
+export var OB_SITE_LINK = 'https://www.xxx.com';
+export var LOCALE_LIST = [{
+  value: 'en-US',
+  label: 'English',
+  shortLabel: 'English',
+  minLabel: 'EN'
+}, {
+  value: 'zh-CN',
+  label: '简体中文',
+  shortLabel: '中文',
+  minLabel: '中'
+}, {
+  value: 'zh-TW',
+  label: '繁体中文',
+  shortLabel: '繁体',
+  minLabel: '繁'
+}];

package/dist/esm/constants/cssPrefix.d.ts

@@ -0,0 +1 @@
+export declare const CSS_PREFIX = "cm";

package/dist/esm/constants/cssPrefix.js

@@ -0,0 +1 @@
+export var CSS_PREFIX = 'cm';

package/dist/esm/getAntApp/index.d.ts

@@ -0,0 +1,8 @@
+import { App } from 'antd';
+type TAntApp = ReturnType<typeof App.useApp>;
+export declare function setAntApp(antApp: TAntApp): void;
+export declare function clearAntApp(): void;
+export default function getAntApp(): import("antd/es/app/context").useAppProps;
+export declare function getAntMessage(): import("antd/es/message/interface").MessageInstance;
+export declare function getAntModal(): import("antd/es/modal/useModal").HookAPI;
+export {};

package/dist/esm/getAntApp/index.js

@@ -0,0 +1,17 @@
+import { Modal, message } from 'antd';
+var AntApp = {};
+export function setAntApp(antApp) {
+  AntApp = antApp;
+}
+export function clearAntApp() {
+  AntApp = {};
+}
+export default function getAntApp() {
+  return AntApp;
+}
+export function getAntMessage() {
+  return getAntApp().message || message;
+}
+export function getAntModal() {
+  return getAntApp().modal || Modal;
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,10 @@
+import SetupAntApp from './SetupAntApp';
+import getAntApp from './getAntApp';
+import UploadFile from './UploadFile';
+import KaTeXRenderer from './KaTeXRenderer';
+import Grid from './Grid';
+import Transition from './Transition';
+import { PixelPlayer } from './PixelPlayer';
+import CheckGroup from './CheckGroup';
+import Resizer from './Resizer';
+export { KaTeXRenderer, Grid, Transition, UploadFile, SetupAntApp, getAntApp, PixelPlayer, CheckGroup, Resizer, };

package/dist/esm/index.js

@@ -0,0 +1,10 @@
+import SetupAntApp from "./SetupAntApp";
+import getAntApp from "./getAntApp";
+import UploadFile from "./UploadFile";
+import KaTeXRenderer from "./KaTeXRenderer";
+import Grid from "./Grid";
+import Transition from "./Transition";
+import { PixelPlayer } from "./PixelPlayer";
+import CheckGroup from "./CheckGroup";
+import Resizer from "./Resizer";
+export { KaTeXRenderer, Grid, Transition, UploadFile, SetupAntApp, getAntApp, PixelPlayer, CheckGroup, Resizer };

package/dist/esm/interface.d.ts

@@ -0,0 +1 @@
+export type Locale = 'zh-TW' | 'zh-CN' | 'en-US';

package/dist/esm/interface.js

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

package/dist/esm/styles/cssVar.less

@@ -0,0 +1,28 @@
+@import "./var.less";
+
+// design-token.less
+// var(--sp-color-primary, #345678);
+.apply-design-token(@tokens) {
+  & {
+    each(@tokens, {
+         --@{prefix}-@{key}: @value;
+    })
+  }
+}
+
+// mixin.less
+.cssVar(@block, @rule, @type: '') {
+  & {
+    each(@rule, {
+      // 去除变量定义 @xx: val;
+      .css() when((replace(@key, '@', '') = @key)) {
+        @{key}: if(@type = '', ~"var(--@{prefix}-@{block}-@{key}, @{value})", ~"var(--@{prefix}-@{block}-@{key}-@{type}, @{value})");
+      }
+      .css();
+    })
+  }
+}
+
+.var(@name, @default: '') {
+  @val: if((@default = ''), ~"var(--@{prefix}-@{name})", ~"var(--@{prefix}-@{name}, @{default})");
+}

package/dist/esm/styles/reset.css

@@ -0,0 +1,3 @@
+html {
+  font-size: 192px;
+}

package/dist/esm/styles/var.d.ts

@@ -0,0 +1 @@
+export declare const CSS_PREFIX = "cm";

package/dist/esm/styles/var.js

@@ -0,0 +1 @@
+export var CSS_PREFIX = 'cm';

package/dist/esm/styles/var.less

@@ -0,0 +1,2 @@
+
+@prefix: cm;

package/dist/esm/variable.less

@@ -0,0 +1,52 @@
+// 限制最大宽度，避免页面被无限拉伸
+// 暂时去除最大宽度限制
+@maxWidth: 8192px;
+@prefixCls: ant;
+@iconPrefixCls: anticon;
+
+// 边框渐变
+.border-gradient
+  (
+    // 背景色，默认为透明色
+    @background-color: transparent,
+    // 边框色
+    @border-color,
+    // 边框宽度
+    @border-width: 1px,
+    // 边框样式
+    @border-style: solid,
+    // 边框圆角
+    @border-radius: 0px
+  ) {
+  background-image: @background-color, @border-color;
+  background-clip: padding-box, border-box;
+  background-origin: padding-box, border-box;
+  border: @border-width @border-style transparent;
+  border-radius: @border-radius;
+  transition: border-width 0.3s;
+}
+
+@keyframes activeGradientAnimation {
+  0% {
+    background-repeat: no-repeat;
+    background-size: 0% 100%;
+  }
+  100% {
+    background-repeat: no-repeat;
+    background-size: 100% 100%;
+  }
+}
+
+@keyframes selectedGradientAnimation {
+  0% {
+    background-repeat: no-repeat;
+    background-size: 0% 100%;
+    // 选中态有圆角渐变动画
+    border-radius: 0;
+  }
+  100% {
+    background-repeat: no-repeat;
+    background-size: 100% 100%;
+    border-radius: 8px;
+  }
+}

package/dist/lib/CheckGroup/context.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { CheckGroupModel } from './hooks/useCheckGroup';
+import { CheckGroupProps } from './type';
+type CheckGroupContextType = {
+    model: CheckGroupModel<any>;
+    props: CheckGroupProps<any>;
+};
+export declare const CheckGroupContext: import("react").Context<CheckGroupContextType>;
+export {};

package/dist/lib/CheckGroup/context.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CheckGroupContext = void 0;
+var _react = require("react");
+var _useCheckGroup = require("./hooks/useCheckGroup");
+const CheckGroupContext = exports.CheckGroupContext = /*#__PURE__*/(0, _react.createContext)({
+  model: new _useCheckGroup.CheckGroupModel(),
+  props: {}
+});

package/dist/lib/CheckGroup/hooks/useCheckGroup.d.ts

@@ -0,0 +1,21 @@
+import { Model } from '@chaomingd/store';
+import { CheckGroupProps, CheckGroupState, Key } from '../type';
+export declare class CheckGroupModel<K extends Key> extends Model<CheckGroupState<K>> {
+    keys: K[];
+    timer: any;
+    props: CheckGroupProps<K>;
+    useGroupKeys: boolean;
+    constructor();
+    getCheckAllInfo(checkMap?: Map<Key, boolean>): {
+        isCheckAll: boolean;
+        indeterminate: boolean;
+    };
+    handleToggleCheckAll: () => void;
+    handleToggleCheck: (key: K) => void;
+    handleCheckOne: (key: K) => void;
+    registerKey(key: K): void;
+    setKeys(keys: K[]): void;
+    unRegisterKey(key: K): void;
+    __updateKeys(): void;
+}
+export declare function useCheckGroup<K extends Key>(props: CheckGroupProps<K>): CheckGroupModel<K>;

package/dist/lib/CheckGroup/hooks/useCheckGroup.js

@@ -0,0 +1,164 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CheckGroupModel = void 0;
+exports.useCheckGroup = useCheckGroup;
+var _store = require("@chaomingd/store");
+var _ahooks = require("ahooks");
+var _react = require("react");
+class CheckGroupModel extends _store.Model {
+  keys = [];
+  timer;
+  props = {};
+  useGroupKeys = false;
+  constructor() {
+    super({
+      autoInit: false,
+      state: {
+        value: [],
+        valueMap: new Map(),
+        keys: [],
+        isCheckAll: false,
+        indeterminate: false
+      },
+      computed: [{
+        keys: ['value'],
+        hander: ({
+          value
+        }) => {
+          const m = new Map();
+          value.forEach(k => {
+            m.set(k, true);
+          });
+          return {
+            valueMap: m
+          };
+        }
+      }, {
+        keys: ['value', 'keys'],
+        hander: ({
+          valueMap
+        }) => {
+          return {
+            ...this.getCheckAllInfo(valueMap)
+          };
+        }
+      }]
+    });
+    this.init();
+  }
+  getCheckAllInfo(checkMap) {
+    const {
+      valueMap
+    } = this.getState();
+    const ckMap = checkMap || valueMap;
+    const {
+      keys
+    } = this;
+    let indeterminate = false;
+    let isCheckAll = true;
+    keys.forEach(k => {
+      const isCheck = ckMap.get(k);
+      if (isCheck) {
+        indeterminate = true;
+      } else {
+        isCheckAll = false;
+      }
+      return isCheck;
+    });
+    if (isCheckAll) {
+      indeterminate = false;
+    }
+    return {
+      isCheckAll,
+      indeterminate
+    };
+  }
+  handleToggleCheckAll = () => {
+    const {
+      isCheckAll
+    } = this.getState();
+    let newKeys;
+    if (isCheckAll) {
+      newKeys = [];
+    } else {
+      newKeys = [...this.keys];
+    }
+    if (!('value' in this.props)) {
+      this.setState({
+        value: newKeys
+      });
+    }
+    this.props.onChange?.(newKeys);
+  };
+  handleToggleCheck = key => {
+    const {
+      valueMap,
+      value
+    } = this.getState();
+    const isCheck = valueMap.get(key);
+    let newKeys = [...value];
+    if (isCheck) {
+      newKeys = newKeys.filter(k => k !== key);
+    } else {
+      newKeys.push(key);
+    }
+    if (!('value' in this.props)) {
+      this.setState({
+        value: newKeys
+      });
+    }
+    this.props.onChange?.(newKeys);
+  };
+  handleCheckOne = key => {
+    const newKeys = [key];
+    if (!('value' in this.props)) {
+      this.setState({
+        value: newKeys
+      });
+    }
+    this.props.onChange?.(newKeys);
+  };
+  registerKey(key) {
+    if (!this.keys.includes(key)) {
+      this.keys.push(key);
+    }
+    this.__updateKeys();
+  }
+  setKeys(keys) {
+    this.keys = keys;
+    this.__updateKeys();
+  }
+  unRegisterKey(key) {
+    this.keys = this.keys.filter(k => k !== key);
+    this.__updateKeys();
+  }
+  __updateKeys() {
+    clearTimeout(this.timer);
+    this.timer = setTimeout(() => {
+      this.setState({
+        keys: [...this.keys]
+      });
+    }, 10);
+  }
+}
+exports.CheckGroupModel = CheckGroupModel;
+function useCheckGroup(props) {
+  const hasValue = ('value' in props);
+  const model = (0, _ahooks.useCreation)(() => {
+    return new CheckGroupModel();
+  }, []);
+  model.props = props;
+  (0, _react.useMemo)(() => {
+    if (hasValue) {
+      model.setState({
+        value: props.value || []
+      }, {
+        silent: true
+      });
+    }
+  }, [props.value, model, hasValue]);
+  return model;
+}

package/dist/lib/CheckGroup/index.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { CheckGroupProps, CheckItemProps, Key } from './type';
+declare const CheckItem: <K extends Key>(props: CheckItemProps<K>) => import("react").ReactNode;
+declare const CheckAllItem: <K extends Key>(props: CheckItemProps<K>) => import("react").ReactNode;
+declare const CheckGroup: (<K extends Key>(props: CheckGroupProps<K>) => import("react/jsx-runtime").JSX.Element) & {
+    CheckItem: typeof CheckItem;
+    CheckAllItem: typeof CheckAllItem;
+};
+export default CheckGroup;

package/dist/lib/CheckGroup/index.js

@@ -0,0 +1,93 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = require("react");
+var _context = require("./context");
+var _useCheckGroup = require("./hooks/useCheckGroup");
+var _jsxRuntime = require("react/jsx-runtime");
+const _CheckGroup = props => {
+  const model = (0, _useCheckGroup.useCheckGroup)(props);
+  const hasKeys = ('keys' in props);
+  model.useGroupKeys = hasKeys;
+  // model.useUpdate();
+  (0, _react.useEffect)(() => {
+    if (hasKeys) {
+      model.setKeys(props.keys || []);
+    }
+  }, [props.keys, model, hasKeys]);
+  const contextValue = (0, _react.useMemo)(() => {
+    return {
+      model,
+      props
+    };
+  }, [model, props.value]);
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_context.CheckGroupContext.Provider, {
+    value: contextValue,
+    children: props.children
+  });
+};
+const CheckItem = props => {
+  const {
+    value,
+    children
+  } = props;
+  const {
+    model
+  } = (0, _react.useContext)(_context.CheckGroupContext);
+  const multiple = model.props.multiple;
+  const useGroupKeys = model.useGroupKeys;
+  const {
+    valueMap,
+    indeterminate
+  } = model.useGetState();
+  const isCheck = valueMap.get(value) || false;
+  (0, _react.useMemo)(() => {
+    if (!useGroupKeys) {
+      model.registerKey(value);
+    }
+    return () => {
+      if (!useGroupKeys) {
+        model.unRegisterKey(value);
+      }
+    };
+  }, [model, value, useGroupKeys]);
+  if (typeof children === 'function') {
+    const onChange = () => {
+      multiple ? model.handleToggleCheck(value) : model.handleCheckOne(value);
+    };
+    return children({
+      checked: isCheck,
+      indeterminate,
+      onChange
+    });
+  }
+  return children;
+};
+const CheckAllItem = props => {
+  const {
+    children
+  } = props;
+  const {
+    model
+  } = (0, _react.useContext)(_context.CheckGroupContext);
+  const {
+    isCheckAll,
+    indeterminate
+  } = model.useGetState();
+  if (typeof children === 'function') {
+    return children({
+      checked: isCheckAll,
+      indeterminate,
+      onChange: model.handleToggleCheckAll
+    });
+  }
+  return children;
+};
+const _component = _CheckGroup;
+const CheckGroup = _component;
+CheckGroup.CheckItem = CheckItem;
+CheckGroup.CheckAllItem = CheckAllItem;
+var _default = exports.default = CheckGroup;

package/dist/lib/CheckGroup/type.d.ts

@@ -0,0 +1,28 @@
+import { ReactNode } from 'react';
+export type Key = string | number | symbol;
+export interface CheckGroupProps<K extends Key> {
+    value?: K[];
+    onChange?: (val: K[]) => void;
+    children?: ReactNode | ReactNode[];
+    keys?: K[];
+    multiple?: boolean;
+}
+export interface CheckGroupState<K extends Key> {
+    value: K[];
+    valueMap: Map<K, boolean>;
+    keys: K[];
+    isCheckAll: boolean;
+    indeterminate: boolean;
+}
+type CheckItemChildren = ReactNode | ReactNode[] | ((props: {
+    checked: boolean;
+    indeterminate: boolean;
+    onChange: () => void;
+}) => ReactNode | ReactNode[]);
+export interface CheckItemProps<K extends Key> {
+    value: K;
+    children?: CheckItemChildren;
+    disabled?: boolean;
+    onChange?: (val: K) => void;
+}
+export {};