tntd 3.0.0-beta → 3.0.0-beta.1

package/es/icon/components/Icon.js

@@ -1,106 +1,88 @@
-var __rest = this && this.__rest || function (s, e) {
-  var t = {};
-  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
-  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
-  }
-  return t;
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
 };
 import * as React from 'react';
 import { generate, getSecondaryColor, isIconDefinition, log, MiniMap, withSuffix } from './utils';
 const twoToneColorPalette = {
-  primaryColor: '#333',
-  secondaryColor: '#E6E6E6'
+    primaryColor: '#333',
+    secondaryColor: '#E6E6E6',
 };
 class Icon extends React.Component {
-  static add(...icons) {
-    icons.forEach(icon => {
-      this.definitions.set(withSuffix(icon.name, icon.theme), icon);
-    });
-  }
-  static clear() {
-    this.definitions.clear();
-  }
-  static get(key, colors = twoToneColorPalette) {
-    if (key) {
-      let target = this.definitions.get(key);
-      if (target && typeof target.icon === 'function') {
-        target = Object.assign(Object.assign({}, target), {
-          icon: target.icon(colors.primaryColor, colors.secondaryColor)
+    static add(...icons) {
+        icons.forEach((icon) => {
+            this.definitions.set(withSuffix(icon.name, icon.theme), icon);
         });
-      }
-      return target;
     }
-  }
-  static setTwoToneColors({
-    primaryColor,
-    secondaryColor
-  }) {
-    twoToneColorPalette.primaryColor = primaryColor;
-    twoToneColorPalette.secondaryColor = secondaryColor || getSecondaryColor(primaryColor);
-  }
-  static getTwoToneColors() {
-    return Object.assign({}, twoToneColorPalette);
-  }
-  render() {
-    const _a = this.props,
-      {
-        type,
-        className,
-        onClick,
-        style,
-        primaryColor,
-        secondaryColor
-      } = _a,
-      rest = __rest(_a, ["type", "className", "onClick", "style", "primaryColor", "secondaryColor"]);
-    let target;
-    let colors = twoToneColorPalette;
-    if (primaryColor) {
-      colors = {
-        primaryColor,
-        secondaryColor: secondaryColor || getSecondaryColor(primaryColor)
-      };
+    static clear() {
+        this.definitions.clear();
     }
-    if (isIconDefinition(type)) {
-      target = type;
-    } else if (typeof type === 'string') {
-      target = Icon.get(type, colors);
-      if (!target) {
-        // log(`Could not find icon: ${type}`);
-        return null;
-      }
+    static get(key, colors = twoToneColorPalette) {
+        if (key) {
+            let target = this.definitions.get(key);
+            if (target && typeof target.icon === 'function') {
+                target = Object.assign(Object.assign({}, target), { icon: target.icon(colors.primaryColor, colors.secondaryColor) });
+            }
+            return target;
+        }
     }
-    if (!target) {
-      log(`type should be string or icon definiton, but got ${type}`);
-      return null;
+    static setTwoToneColors({ primaryColor, secondaryColor }) {
+        twoToneColorPalette.primaryColor = primaryColor;
+        twoToneColorPalette.secondaryColor = secondaryColor || getSecondaryColor(primaryColor);
     }
-    if (target && typeof target.icon === 'function') {
-      target = Object.assign(Object.assign({}, target), {
-        icon: target.icon(colors.primaryColor, colors.secondaryColor)
-      });
+    static getTwoToneColors() {
+        return Object.assign({}, twoToneColorPalette);
+    }
+    render() {
+        const _a = this.props, { type, className, onClick, style, primaryColor, secondaryColor } = _a, rest = __rest(_a, ["type", "className", "onClick", "style", "primaryColor", "secondaryColor"]);
+        let target;
+        let colors = twoToneColorPalette;
+        if (primaryColor) {
+            colors = {
+                primaryColor,
+                secondaryColor: secondaryColor || getSecondaryColor(primaryColor),
+            };
+        }
+        if (isIconDefinition(type)) {
+            target = type;
+        }
+        else if (typeof type === 'string') {
+            target = Icon.get(type, colors);
+            if (!target) {
+                // log(`Could not find icon: ${type}`);
+                return null;
+            }
+        }
+        if (!target) {
+            log(`type should be string or icon definiton, but got ${type}`);
+            return null;
+        }
+        if (target && typeof target.icon === 'function') {
+            target = Object.assign(Object.assign({}, target), { icon: target.icon(colors.primaryColor, colors.secondaryColor) });
+        }
+        return generate(target.icon, `svg-${target.name}`, Object.assign({ className,
+            onClick,
+            style, ['data-icon']: target.name, width: '1em', height: '1em', fill: 'currentColor', ['aria-hidden']: 'true' }, rest));
     }
-    return generate(target.icon, `svg-${target.name}`, Object.assign({
-      className,
-      onClick,
-      style,
-      ['data-icon']: target.name,
-      width: '1em',
-      height: '1em',
-      fill: 'currentColor',
-      ['aria-hidden']: 'true'
-    }, rest));
-  }
 }
 Object.defineProperty(Icon, "displayName", {
-  enumerable: true,
-  configurable: true,
-  writable: true,
-  value: 'IconReact'
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: 'IconReact'
 });
 Object.defineProperty(Icon, "definitions", {
-  enumerable: true,
-  configurable: true,
-  writable: true,
-  value: new MiniMap()
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: new MiniMap()
 });
-export default Icon;
+export default Icon;
+//# sourceMappingURL=Icon.js.map

package/es/icon/components/index.js

@@ -1 +1,2 @@
-export { default } from './Icon';
+export { default } from './Icon';
+//# sourceMappingURL=index.js.map

package/es/icon/components/utils.js

@@ -1,79 +1,79 @@
 import { generate as generateColor } from '@ant-design/colors';
 import * as React from 'react';
 export function log(message) {
-  if (!(process && process.env && process.env.NODE_ENV === 'production')) {
-    console.error(`[@ant-design/icons-react]: ${message}.`);
-  }
+    if (!(process && process.env && process.env.NODE_ENV === 'production')) {
+        console.error(`[@ant-design/icons-react]: ${message}.`);
+    }
 }
 export function isIconDefinition(target) {
-  return typeof target === 'object' && typeof target.name === 'string' && typeof target.theme === 'string' && (typeof target.icon === 'object' || typeof target.icon === 'function');
+    return (typeof target === 'object' &&
+        typeof target.name === 'string' &&
+        typeof target.theme === 'string' &&
+        (typeof target.icon === 'object' || typeof target.icon === 'function'));
 }
 export function normalizeAttrs(attrs = {}) {
-  return Object.keys(attrs).reduce((acc, key) => {
-    const val = attrs[key];
-    switch (key) {
-      case 'class':
-        acc.className = val;
-        delete acc.class;
-        break;
-      default:
-        acc[key] = val;
-    }
-    return acc;
-  }, {});
+    return Object.keys(attrs).reduce((acc, key) => {
+        const val = attrs[key];
+        switch (key) {
+            case 'class':
+                acc.className = val;
+                delete acc.class;
+                break;
+            default:
+                acc[key] = val;
+        }
+        return acc;
+    }, {});
 }
 export class MiniMap {
-  constructor() {
-    Object.defineProperty(this, "collection", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: {}
-    });
-  }
-  get size() {
-    return Object.keys(this.collection).length;
-  }
-  clear() {
-    this.collection = {};
-  }
-  delete(key) {
-    return delete this.collection[key];
-  }
-  get(key) {
-    return this.collection[key];
-  }
-  has(key) {
-    return Boolean(this.collection[key]);
-  }
-  set(key, value) {
-    this.collection[key] = value;
-    return this;
-  }
+    constructor() {
+        Object.defineProperty(this, "collection", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+    }
+    get size() {
+        return Object.keys(this.collection).length;
+    }
+    clear() {
+        this.collection = {};
+    }
+    delete(key) {
+        return delete this.collection[key];
+    }
+    get(key) {
+        return this.collection[key];
+    }
+    has(key) {
+        return Boolean(this.collection[key]);
+    }
+    set(key, value) {
+        this.collection[key] = value;
+        return this;
+    }
 }
 export function generate(node, key, rootProps) {
-  if (!rootProps) {
-    return React.createElement(node.tag, Object.assign({
-      key
-    }, normalizeAttrs(node.attrs)), (node.children || []).map((child, index) => generate(child, `${key}-${node.tag}-${index}`)));
-  }
-  return React.createElement(node.tag, Object.assign(Object.assign({
-    key
-  }, normalizeAttrs(node.attrs)), rootProps), (node.children || []).map((child, index) => generate(child, `${key}-${node.tag}-${index}`)));
+    if (!rootProps) {
+        return React.createElement(node.tag, Object.assign({ key }, normalizeAttrs(node.attrs)), (node.children || []).map((child, index) => generate(child, `${key}-${node.tag}-${index}`)));
+    }
+    return React.createElement(node.tag, Object.assign(Object.assign({ key }, normalizeAttrs(node.attrs)), rootProps), (node.children || []).map((child, index) => generate(child, `${key}-${node.tag}-${index}`)));
 }
 export function getSecondaryColor(primaryColor) {
-  // choose the second color
-  return generateColor(primaryColor)[0];
+    // choose the second color
+    return generateColor(primaryColor)[0];
 }
 export function withSuffix(name, theme) {
-  switch (theme) {
-    case 'fill':
-      return `${name}-fill`;
-    case 'outline':
-      return `${name}-o`;
-    case 'twotone':
-      return `${name}-twotone`;
-    default:
-      throw new TypeError(`Unknown theme type: ${theme}, name: ${name}`);
-  }
-}
+    switch (theme) {
+        case 'fill':
+            return `${name}-fill`;
+        case 'outline':
+            return `${name}-o`;
+        case 'twotone':
+            return `${name}-twotone`;
+        default:
+            throw new TypeError(`Unknown theme type: ${theme}, name: ${name}`);
+    }
+}
+//# sourceMappingURL=utils.js.map

package/es/icon/index.js

@@ -1,10 +1,13 @@
-var __rest = this && this.__rest || function (s, e) {
-  var t = {};
-  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
-  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
-  }
-  return t;
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
 };
 /* eslint-disable camelcase */
 import * as React from 'react';
@@ -12,106 +15,88 @@ import classNames from 'classnames';
 import * as allIcons from '@tntd/icons/lib/dist';
 import ReactIcon from './components';
 import createFromIconfontCN from './IconFont';
-import { svgBaseProps, withThemeSuffix, removeTypeTheme, getThemeFromTypeName, alias } from './utils';
+import { svgBaseProps, withThemeSuffix, removeTypeTheme, getThemeFromTypeName, alias, } from './utils';
 import warning from '../_util/warning';
 import LocaleReceiver from 'antd/es/locale-provider/LocaleReceiver';
 import { getTwoToneColor, setTwoToneColor } from './twoTonePrimaryColor';
 import './style/style.less';
 // Initial setting
-ReactIcon.add(...Object.keys(allIcons).map(key => allIcons[key]));
+ReactIcon.add(...Object.keys(allIcons).map((key) => allIcons[key]));
 setTwoToneColor('#1890ff');
 let defaultTheme = 'outlined';
 let dangerousTheme;
 function unstable_ChangeThemeOfIconsDangerously(theme) {
-  warning(false, 'Icon', `You are using the unstable method 'Icon.unstable_ChangeThemeOfAllIconsDangerously', ` + `make sure that all the icons with theme '${theme}' display correctly.`);
-  dangerousTheme = theme;
+    warning(false, 'Icon', `You are using the unstable method 'Icon.unstable_ChangeThemeOfAllIconsDangerously', ` +
+        `make sure that all the icons with theme '${theme}' display correctly.`);
+    dangerousTheme = theme;
 }
 function unstable_ChangeDefaultThemeOfIcons(theme) {
-  warning(false, 'Icon', `You are using the unstable method 'Icon.unstable_ChangeDefaultThemeOfIcons', ` + `make sure that all the icons with theme '${theme}' display correctly.`);
-  defaultTheme = theme;
+    warning(false, 'Icon', `You are using the unstable method 'Icon.unstable_ChangeDefaultThemeOfIcons', ` +
+        `make sure that all the icons with theme '${theme}' display correctly.`);
+    defaultTheme = theme;
 }
-const Icon = props => {
-  const {
-      // affect outter <i>...</i>
-      className,
-      // affect inner <svg>...</svg>
-      type,
-      component: Component,
-      viewBox,
-      spin,
-      rotate,
-      tabIndex,
-      onClick,
-      // children
-      children,
-      // other
-      theme,
-      // default to outlined
-      twoToneColor
-    } = props,
-    restProps = __rest(props, ["className", "type", "component", "viewBox", "spin", "rotate", "tabIndex", "onClick", "children", "theme", "twoToneColor"]);
-  warning(Boolean(type || Component || children), 'Icon', 'Should have `type` prop or `component` prop or `children`.');
-  const classString = classNames({
-    [`tntd-anticon`]: true,
-    [`anticon`]: true,
-    [`anticon-${type}`]: Boolean(type)
-  }, className);
-  const svgClassString = classNames({
-    [`anticon-spin`]: !!spin || type === 'loading'
-  });
-  const svgStyle = rotate ? {
-    msTransform: `rotate(${rotate}deg)`,
-    transform: `rotate(${rotate}deg)`
-  } : undefined;
-  const innerSvgProps = Object.assign(Object.assign({}, svgBaseProps), {
-    className: svgClassString,
-    style: svgStyle,
-    viewBox
-  });
-  if (!viewBox) {
-    delete innerSvgProps.viewBox;
-  }
-  const renderInnerNode = () => {
-    // component > children > type
-    if (Component) {
-      return React.createElement(Component, Object.assign({}, innerSvgProps), children);
+const Icon = (props) => {
+    const { 
+    // affect outter <i>...</i>
+    className, 
+    // affect inner <svg>...</svg>
+    type, component: Component, viewBox, spin, rotate, tabIndex, onClick, 
+    // children
+    children, 
+    // other
+    theme, // default to outlined
+    twoToneColor } = props, restProps = __rest(props, ["className", "type", "component", "viewBox", "spin", "rotate", "tabIndex", "onClick", "children", "theme", "twoToneColor"]);
+    warning(Boolean(type || Component || children), 'Icon', 'Should have `type` prop or `component` prop or `children`.');
+    const classString = classNames({
+        [`tntd-anticon`]: true,
+        [`anticon`]: true,
+        [`anticon-${type}`]: Boolean(type),
+    }, className);
+    const svgClassString = classNames({
+        [`anticon-spin`]: !!spin || type === 'loading',
+    });
+    const svgStyle = rotate
+        ? {
+            msTransform: `rotate(${rotate}deg)`,
+            transform: `rotate(${rotate}deg)`,
+        }
+        : undefined;
+    const innerSvgProps = Object.assign(Object.assign({}, svgBaseProps), { className: svgClassString, style: svgStyle, viewBox });
+    if (!viewBox) {
+        delete innerSvgProps.viewBox;
     }
-    if (children) {
-      warning(Boolean(viewBox) || React.Children.count(children) === 1 && React.isValidElement(children) && React.Children.only(children).type === 'use', 'Icon', 'Make sure that you provide correct `viewBox`' + ' prop (default `0 0 1024 1024`) to the icon.');
-      return React.createElement("svg", Object.assign({}, innerSvgProps, {
-        viewBox: viewBox
-      }), children);
+    const renderInnerNode = () => {
+        // component > children > type
+        if (Component) {
+            return React.createElement(Component, Object.assign({}, innerSvgProps), children);
+        }
+        if (children) {
+            warning(Boolean(viewBox) ||
+                (React.Children.count(children) === 1 &&
+                    React.isValidElement(children) &&
+                    React.Children.only(children).type === 'use'), 'Icon', 'Make sure that you provide correct `viewBox`' +
+                ' prop (default `0 0 1024 1024`) to the icon.');
+            return (React.createElement("svg", Object.assign({}, innerSvgProps, { viewBox: viewBox }), children));
+        }
+        if (typeof type === 'string') {
+            let computedType = type;
+            if (theme) {
+                const themeInName = getThemeFromTypeName(type);
+                warning(!themeInName || theme === themeInName, 'Icon', `The icon name '${type}' already specify a theme '${themeInName}',` +
+                    ` the 'theme' prop '${theme}' will be ignored.`);
+            }
+            computedType = withThemeSuffix(removeTypeTheme(alias(computedType)), dangerousTheme || theme || defaultTheme);
+            return (React.createElement(ReactIcon, { className: svgClassString, type: computedType, primaryColor: twoToneColor, style: svgStyle }));
+        }
+    };
+    let iconTabIndex = tabIndex;
+    if (iconTabIndex === undefined && onClick) {
+        iconTabIndex = -1;
     }
-    if (typeof type === 'string') {
-      let computedType = type;
-      if (theme) {
-        const themeInName = getThemeFromTypeName(type);
-        warning(!themeInName || theme === themeInName, 'Icon', `The icon name '${type}' already specify a theme '${themeInName}',` + ` the 'theme' prop '${theme}' will be ignored.`);
-      }
-      computedType = withThemeSuffix(removeTypeTheme(alias(computedType)), dangerousTheme || theme || defaultTheme);
-      return React.createElement(ReactIcon, {
-        className: svgClassString,
-        type: computedType,
-        primaryColor: twoToneColor,
-        style: svgStyle
-      });
-    }
-  };
-  let iconTabIndex = tabIndex;
-  if (iconTabIndex === undefined && onClick) {
-    iconTabIndex = -1;
-  }
-  return React.createElement(LocaleReceiver, {
-    componentName: "Icon"
-  }, locale => React.createElement("i", Object.assign({
-    "aria-label": type && `${locale.icon}: ${type}`
-  }, restProps, {
-    tabIndex: iconTabIndex,
-    onClick: onClick,
-    className: classString
-  }), renderInnerNode()));
+    return (React.createElement(LocaleReceiver, { componentName: "Icon" }, (locale) => (React.createElement("i", Object.assign({ "aria-label": type && `${locale.icon}: ${type}` }, restProps, { tabIndex: iconTabIndex, onClick: onClick, className: classString }), renderInnerNode()))));
 };
 Icon.createFromIconfontCN = createFromIconfontCN;
 Icon.getTwoToneColor = getTwoToneColor;
 Icon.setTwoToneColor = setTwoToneColor;
-export default Icon;
+export default Icon;
+//# sourceMappingURL=index.js.map

package/es/icon/style/index.js

@@ -1,2 +1,3 @@
 import '../../style/index.less';
-import './index.less';
+import './index.less';
+//# sourceMappingURL=index.js.map

package/es/icon/twoTonePrimaryColor.js

@@ -1,10 +1,11 @@
 import ReactIcon from './components';
 export function setTwoToneColor(primaryColor) {
-  return ReactIcon.setTwoToneColors({
-    primaryColor
-  });
+    return ReactIcon.setTwoToneColors({
+        primaryColor,
+    });
 }
 export function getTwoToneColor() {
-  const colors = ReactIcon.getTwoToneColors();
-  return colors.primaryColor;
-}
+    const colors = ReactIcon.getTwoToneColors();
+    return colors.primaryColor;
+}
+//# sourceMappingURL=twoTonePrimaryColor.js.map