@plasmicpkgs/antd 2.0.5 → 2.0.7

package/dist/antd.cjs.development.js

@@ -0,0 +1,2242 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
+
+var registerComponent = _interopDefault(require('@plasmicapp/host/registerComponent'));
+var Button = _interopDefault(require('antd/lib/button'));
+var Carousel = _interopDefault(require('antd/lib/carousel'));
+var Checkbox = _interopDefault(require('antd/lib/checkbox/Checkbox'));
+var CheckboxGroup = _interopDefault(require('antd/lib/checkbox/Group'));
+var React = _interopDefault(require('react'));
+var AntdCollapse = _interopDefault(require('antd/lib/collapse/Collapse'));
+var CollapsePanel = _interopDefault(require('antd/lib/collapse/CollapsePanel'));
+var AntdDropdown = _interopDefault(require('antd/lib/dropdown'));
+var DropdownButton = _interopDefault(require('antd/lib/dropdown/dropdown-button'));
+var Input = _interopDefault(require('antd/lib/input'));
+var InputGroup = _interopDefault(require('antd/lib/input/Group'));
+var Password = _interopDefault(require('antd/lib/input/Password'));
+var Search = _interopDefault(require('antd/lib/input/Search'));
+var TextArea = _interopDefault(require('antd/lib/input/TextArea'));
+var Menu = _interopDefault(require('antd/lib/menu/index'));
+var MenuDivider = _interopDefault(require('antd/lib/menu/MenuDivider'));
+var MenuItem = _interopDefault(require('antd/lib/menu/MenuItem'));
+var SubMenu = _interopDefault(require('antd/lib/menu/SubMenu'));
+var rcMenu = require('rc-menu');
+var rcSelect = require('rc-select');
+var Rate = _interopDefault(require('antd/lib/rate'));
+var Select = _interopDefault(require('antd/lib/select'));
+var AntdSlider = _interopDefault(require('antd/lib/slider'));
+var Switch = _interopDefault(require('antd/lib/switch'));
+var host = require('@plasmicapp/host');
+var Table = _interopDefault(require('antd/lib/table/Table'));
+var antd = require('antd');
+var AntdTabs = _interopDefault(require('antd/lib/tabs'));
+var rcTabs = require('rc-tabs');
+
+var buttonMeta = {
+  name: "AntdButton",
+  displayName: "Antd Button",
+  props: {
+    type: {
+      type: "choice",
+      options: ["default", "primary", "ghost", "dashed", "link", "text"],
+      description: "Can be set to primary, ghost, dashed, link, text, default",
+      defaultValueHint: "default"
+    },
+    size: {
+      type: "choice",
+      options: ["small", "medium", "large"],
+      description: "Set the size of button",
+      defaultValueHint: "medium"
+    },
+    shape: {
+      type: "choice",
+      options: ["default", "circle", "round"],
+      description: "Can be set button shape",
+      defaultValueHint: "default"
+    },
+    disabled: {
+      type: "boolean",
+      description: "Disabled state of button",
+      defaultValueHint: false
+    },
+    ghost: {
+      type: "boolean",
+      description: "Make background transparent and invert text and border colors",
+      defaultValueHint: false
+    },
+    danger: {
+      type: "boolean",
+      description: "Set the danger status of button",
+      defaultValueHint: false
+    },
+    block: {
+      type: "boolean",
+      description: "Option to fit button width to its parent width",
+      defaultValueHint: false
+    },
+    loading: {
+      type: "boolean",
+      description: "Set the loading status of button",
+      defaultValueHint: false
+    },
+    href: {
+      type: "string",
+      description: "Redirect url of link button"
+    },
+    target: {
+      type: "choice",
+      options: ["_blank", "_self", "_parent", "_top"],
+      description: "Same as target attribute of a, works when href is specified",
+      hidden: function hidden(props) {
+        return !props.href;
+      },
+      defaultValueHint: "_self"
+    },
+    children: {
+      type: "slot",
+      defaultValue: [{
+        type: "text",
+        value: "Button"
+      }]
+    }
+  },
+  importPath: "antd/lib/button",
+  isDefaultExport: true,
+  importName: "Button"
+};
+function registerButton(loader, customButtonMeta) {
+  var doRegisterComponent = function doRegisterComponent() {
+    return loader ? loader.registerComponent.apply(loader, arguments) : registerComponent.apply(void 0, arguments);
+  };
+  doRegisterComponent(Button, customButtonMeta != null ? customButtonMeta : buttonMeta);
+}
+
+var contentStyle = {
+  height: "160px",
+  color: "#fff",
+  lineHeight: "160px",
+  textAlign: "center",
+  backgroundColor: "#364d79"
+};
+var carouselMeta = {
+  name: "AntdCarousel",
+  displayName: "Antd Carousel",
+  props: {
+    autoplay: {
+      type: "boolean",
+      description: "Whether to scroll automatically",
+      defaultValueHint: false
+    },
+    dotPosition: {
+      type: "choice",
+      options: ["top", "bottom", "left", "right"],
+      description: "The position of the dots",
+      defaultValueHint: "bottom"
+    },
+    dots: {
+      type: "boolean",
+      description: "Whether to show the dots at the bottom of the gallery",
+      defaultValueHint: true
+    },
+    effect: {
+      type: "choice",
+      options: ["scrollx", "fade"],
+      defaultValueHint: "scrollx"
+    },
+    children: {
+      type: "slot",
+      defaultValue: [{
+        type: "vbox",
+        children: {
+          type: "text",
+          value: "1",
+          styles: contentStyle
+        }
+      }, {
+        type: "vbox",
+        children: {
+          type: "text",
+          value: "2",
+          styles: contentStyle
+        }
+      }]
+    }
+  },
+  importPath: "antd/lib/carousel",
+  importName: "Carousel",
+  isDefaultExport: true
+};
+function registerCarousel(loader, customCarouselMeta) {
+  var doRegisterComponent = function doRegisterComponent() {
+    return loader ? loader.registerComponent.apply(loader, arguments) : registerComponent.apply(void 0, arguments);
+  };
+  doRegisterComponent(Carousel, customCarouselMeta != null ? customCarouselMeta : carouselMeta);
+}
+
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+  _setPrototypeOf(subClass, superClass);
+}
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+  return _setPrototypeOf(o, p);
+}
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+  return target;
+}
+
+/**
+ * Traverses the tree of elements from a `React.createElement`. Notice we can't
+ * traverse elements created within the children's render function since this is
+ * the tree before rendering.
+ */
+function traverseReactEltTree(children, callback) {
+  var rec = function rec(elts) {
+    (Array.isArray(elts) ? elts : [elts]).forEach(function (elt) {
+      if (elt) {
+        var _elt$props;
+        callback(elt);
+        if (elt.children) {
+          rec(elt.children);
+        }
+        if ((_elt$props = elt.props) != null && _elt$props.children && elt.props.children !== elt.children) {
+          rec(elt.props.children);
+        }
+      }
+    });
+  };
+  rec(children);
+}
+
+var CheckboxWrapper = /*#__PURE__*/function (_React$Component) {
+  _inheritsLoose(CheckboxWrapper, _React$Component);
+  function CheckboxWrapper() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+  var _proto = CheckboxWrapper.prototype;
+  _proto.render = function render() {
+    return React.createElement(Checkbox, Object.assign({}, this.props));
+  };
+  return CheckboxWrapper;
+}(React.Component);
+var checkboxMeta = {
+  name: "AntdCheckbox",
+  displayName: "Antd Checkbox",
+  props: {
+    autoFocus: {
+      type: "boolean",
+      description: "If get focus when component mounted",
+      defaultValueHint: false
+    },
+    checked: {
+      type: "boolean",
+      editOnly: true,
+      uncontrolledProp: "defaultChecked",
+      description: "Specifies the initial state: whether or not the checkbox is selected",
+      defaultValueHint: false
+    },
+    disabled: {
+      type: "boolean",
+      description: "If disable checkbox",
+      defaultValueHint: false
+    },
+    indeterminate: {
+      type: "boolean",
+      description: "The indeterminate checked state of checkbox",
+      defaultValueHint: false
+    },
+    value: {
+      type: "string",
+      description: "The checkbox value"
+    },
+    children: {
+      type: "slot",
+      defaultValue: [{
+        type: "text",
+        value: "Checkbox"
+      }]
+    }
+  },
+  importPath: "antd/lib/checkbox/Checkbox",
+  importName: "Checkbox",
+  defaultStyles: {
+    marginLeft: 0
+  },
+  isDefaultExport: true
+};
+function registerCheckbox(loader, customCheckboxMeta) {
+  var doRegisterComponent = function doRegisterComponent() {
+    return loader ? loader.registerComponent.apply(loader, arguments) : registerComponent.apply(void 0, arguments);
+  };
+  doRegisterComponent(CheckboxWrapper, customCheckboxMeta != null ? customCheckboxMeta : checkboxMeta);
+}
+var checkboxGroupMeta = {
+  name: "AntdCheckboxGroup",
+  displayName: "Antd Checkbox Group",
+  props: {
+    disabled: {
+      type: "boolean",
+      description: "If disable all checkboxes",
+      defaultValueHint: false
+    },
+    value: {
+      type: "choice",
+      editOnly: true,
+      uncontrolledProp: "defaultValue",
+      description: "Default selected value",
+      multiSelect: true,
+      options: function options(componentProps) {
+        var options = new Set();
+        traverseReactEltTree(componentProps.children, function (elt) {
+          var _elt$props;
+          if ((elt == null ? void 0 : elt.type) === CheckboxWrapper && typeof (elt == null ? void 0 : (_elt$props = elt.props) == null ? void 0 : _elt$props.value) === "string") {
+            options.add(elt.props.value);
+          }
+        });
+        return Array.from(options.keys());
+      }
+    },
+    children: {
+      type: "slot",
+      allowedComponents: ["AntdCheckbox"],
+      defaultValue: [{
+        type: "component",
+        name: "AntdCheckbox"
+      }]
+    }
+  },
+  importPath: "antd/lib/checkbox/Group",
+  importName: "CheckboxGroup",
+  parentComponentName: "AntdCheckbox",
+  isDefaultExport: true
+};
+function registerCheckboxGroup(loader, customCheckboxGroupMeta) {
+  var doRegisterComponent = function doRegisterComponent() {
+    return loader ? loader.registerComponent.apply(loader, arguments) : registerComponent.apply(void 0, arguments);
+  };
+  doRegisterComponent(CheckboxGroup, customCheckboxGroupMeta != null ? customCheckboxGroupMeta : checkboxGroupMeta);
+}
+
+var _excluded = ["openIcon", "closeIcon"];
+var collapstePanelMeta = {
+  name: "AntdCollapsePanel",
+  displayName: "Antd Collapse Panel",
+  props: {
+    collapsible: {
+      type: "choice",
+      options: ["header", "disabled"],
+      description: "Specify whether the panel be collapsible or the trigger area of collapsible"
+    },
+    forceRender: {
+      type: "boolean",
+      description: "Forced render of content on panel, instead of lazy rending after clicking on header",
+      defaultValueHint: false
+    },
+    header: {
+      type: "slot",
+      defaultValue: [{
+        type: "text",
+        value: "Header"
+      }]
+    },
+    key: {
+      type: "string",
+      description: "Unique key identifying the panel from among its siblings"
+    },
+    showArrow: {
+      type: "boolean",
+      description: "If false, panel will not show arrow icon",
+      defaultValueHint: true
+    },
+    extra: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    children: {
+      type: "slot",
+      defaultValue: [{
+        type: "text",
+        value: "Insert text here"
+      }]
+    }
+  },
+  importPath: "antd/lib/collapse/CollapsePanel",
+  importName: "CollapsePanel",
+  parentComponentName: "AntdCollapse",
+  isDefaultExport: true
+};
+function registerCollapsePanel(loader, customCollapsePanelMeta) {
+  var doRegisterComponent = function doRegisterComponent() {
+    return loader ? loader.registerComponent.apply(loader, arguments) : registerComponent.apply(void 0, arguments);
+  };
+  doRegisterComponent(CollapsePanel, customCollapsePanelMeta != null ? customCollapsePanelMeta : collapstePanelMeta);
+}
+var collapsteMeta = {
+  name: "AntdCollapse",
+  displayName: "Antd Collapse",
+  props: {
+    accordion: {
+      type: "boolean",
+      description: "If true, Collapse renders as Accordion",
+      defaultValueHint: false
+    },
+    activeKey: {
+      type: "choice",
+      editOnly: true,
+      uncontrolledProp: "defaultActiveKey",
+      description: "Key of the active panel",
+      multiSelect: true,
+      options: function options(componentProps) {
+        var options = new Set();
+        // `children` is not defined in the Collapse props
+        traverseReactEltTree(componentProps.children, function (elt) {
+          if ((elt == null ? void 0 : elt.type) === CollapsePanel && typeof (elt == null ? void 0 : elt.key) === "string") {
+            options.add(elt.key);
+          }
+        });
+        return Array.from(options.keys());
+      }
+    },
+    bordered: {
+      type: "boolean",
+      description: "Toggles rendering of the border around the collapse block",
+      defaultValueHint: true
+    },
+    collapsible: {
+      type: "choice",
+      options: ["header", "disabled"],
+      description: "Specify whether the panels of children be collapsible or the trigger area of collapsible"
+    },
+    expandIconPosition: {
+      type: "choice",
+      options: ["left", "right"],
+      description: "Set expand icon position",
+      defaultValueHint: "left"
+    },
+    ghost: {
+      type: "boolean",
+      description: "Make the collapse borderless and its background transparent",
+      defaultValueHint: false
+    },
+    children: {
+      type: "slot",
+      allowedComponents: ["AntdCollapsePanel"],
+      defaultValue: [{
+        type: "component",
+        name: "AntdCollapsePanel",
+        props: {
+          key: "1"
+        }
+      }]
+    },
+    openIcon: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    closeIcon: {
+      type: "slot",
+      hidePlaceholder: true
+    }
+  },
+  importPath: "@plasmicpkgs/antd/skinny/registerCollapse",
+  importName: "Collapse"
+};
+function Collapse(props) {
+  var openIcon = props.openIcon,
+    closeIcon = props.closeIcon,
+    rest = _objectWithoutPropertiesLoose(props, _excluded);
+  return React.createElement(AntdCollapse, Object.assign({}, rest, {
+    expandIcon: openIcon || closeIcon ? function (_ref) {
+      var isActive = _ref.isActive;
+      return isActive ? openIcon : closeIcon;
+    } : undefined
+  }));
+}
+function registerCollapse(loader, customCollapseMeta) {
+  var doRegisterComponent = function doRegisterComponent() {
+    return loader ? loader.registerComponent.apply(loader, arguments) : registerComponent.apply(void 0, arguments);
+  };
+  doRegisterComponent(Collapse, customCollapseMeta != null ? customCollapseMeta : collapsteMeta);
+}
+
+var Dropdown = /*#__PURE__*/function (_React$Component) {
+  _inheritsLoose(Dropdown, _React$Component);
+  function Dropdown() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+  var _proto = Dropdown.prototype;
+  _proto.render = function render() {
+    var finalProps = _extends({}, this.props);
+    finalProps.children = typeof this.props.children === "string" ? React.createElement("div", null, this.props.children) : this.props.children;
+    return React.createElement(AntdDropdown, Object.assign({}, finalProps));
+  };
+  return Dropdown;
+}(React.Component);
+var dropdownMeta = {
+  name: "AntdDropdown",
+  displayName: "Antd Dropdown",
+  props: {
+    arrow: {
+      type: "boolean",
+      description: "Whether the dropdown arrow should be visible",
+      defaultValueHint: false
+    },
+    disabled: {
+      type: "boolean",
+      description: "Whether the dropdown menu is disabled",
+      defaultValueHint: false
+    },
+    overlay: {
+      type: "slot",
+      allowedComponents: ["AntdMenu"],
+      defaultValue: [{
+        type: "component",
+        name: "AntdMenu"
+      }]
+    },
+    placement: {
+      type: "choice",
+      options: ["bottomLeft", "bottomCenter", "bottomRight", "topLeft", "topCenter", "topRight"],
+      description: "Placement of popup menu",
+      defaultValueHint: "bottomLeft"
+    },
+    trigger: {
+      type: "choice",
+      options: ["click", "hover", "contextMenu"],
+      description: "The trigger mode which executes the dropdown action",
+      defaultValueHint: "hover"
+    },
+    visible: {
+      type: "boolean",
+      description: "Toggle visibility of dropdown menu in Plasmic Editor",
+      editOnly: true,
+      defaultValueHint: false
+    },
+    children: {
+      type: "slot",
+      defaultValue: [{
+        type: "text",
+        value: "Dropdown"
+      }]
+    }
+  },
+  importPath: "@plasmicpkgs/antd/skinny/registerDropdown",
+  importName: "Dropdown"
+};
+function registerDropdown(loader, customDropdownMeta) {
+  var doRegisterComponent = function doRegisterComponent() {
+    return loader ? loader.registerComponent.apply(loader, arguments) : registerComponent.apply(void 0, arguments);
+  };
+  doRegisterComponent(Dropdown, customDropdownMeta != null ? customDropdownMeta : dropdownMeta);
+}
+var dropdownButtonMeta = {
+  name: "AntdDropdownButton",
+  displayName: "Antd Dropdown Button",
+  props: {
+    disabled: {
+      type: "boolean",
+      description: "Whether the dropdown menu is disabled",
+      defaultValueHint: false
+    },
+    icon: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    overlay: {
+      type: "slot",
+      allowedComponents: ["AntdMenu"],
+      defaultValue: [{
+        type: "component",
+        name: "AntdMenu"
+      }]
+    },
+    placement: {
+      type: "choice",
+      options: ["bottomLeft", "bottomCenter", "bottomRight", "topLeft", "topCenter", "topRight"],
+      description: "Placement of popup menu",
+      defaultValueHint: "bottomLeft"
+    },
+    size: {
+      type: "choice",
+      options: ["small", "medium", "large"],
+      description: "Set the size of button",
+      defaultValueHint: "medium"
+    },
+    trigger: {
+      type: "choice",
+      options: ["click", "hover", "contextMenu"],
+      description: "The trigger mode which executes the dropdown action",
+      defaultValueHint: "hover"
+    },
+    type: {
+      type: "choice",
+      options: ["default", "primary", "ghost", "dashed", "link", "text"],
+      description: "Can be set to primary, ghost, dashed, link, text, default",
+      defaultValueHint: "default"
+    },
+    visible: {
+      type: "boolean",
+      description: "Toggle visibility of dropdown menu in Plasmic Editor",
+      editOnly: true,
+      defaultValueHint: false
+    },
+    children: {
+      type: "slot",
+      defaultValue: [{
+        type: "text",
+        value: "Dropdown"
+      }]
+    }
+  },
+  importPath: "antd/lib/dropdown/dropdown-button",
+  importName: "DropdownButton",
+  parentComponentName: "AntdDropdown",
+  isDefaultExport: true
+};
+function registerDropdownButton(loader, customDropdownButtonMeta) {
+  var doRegisterComponent = function doRegisterComponent() {
+    return loader ? loader.registerComponent.apply(loader, arguments) : registerComponent.apply(void 0, arguments);
+  };
+  doRegisterComponent(DropdownButton, customDropdownButtonMeta != null ? customDropdownButtonMeta : dropdownButtonMeta);
+}
+
+function sortObjectKeys(obj) {
+  return Object.fromEntries(Object.entries(obj).sort());
+}
+function sortProps(props) {
+  return sortObjectKeys(props);
+}
+var commonHtmlAttributes = {
+  "aria-label": {
+    type: "string",
+    description: "The ARIA label for this input"
+  },
+  "aria-labelledby": {
+    type: "string",
+    description: "Identifies the element(s) that labels this input"
+  },
+  name: {
+    type: "string",
+    description: "The HTML name of the input"
+  }
+};
+var inputMeta = {
+  name: "AntdInput",
+  displayName: "Antd Input",
+  props: /*#__PURE__*/sortProps( /*#__PURE__*/_extends({}, commonHtmlAttributes, {
+    addonAfter: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    addonBefore: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    allowClear: {
+      type: "boolean",
+      description: "If allow to remove input content with clear icon",
+      defaultValueHint: false
+    },
+    bordered: {
+      type: "boolean",
+      description: "Whether has border style",
+      defaultValueHint: true
+    },
+    disabled: {
+      type: "boolean",
+      description: "Whether the input is disabled",
+      defaultValueHint: false
+    },
+    id: {
+      type: "string",
+      description: "The ID for input"
+    },
+    maxLength: {
+      type: "number",
+      description: "The max length"
+    },
+    placeholder: {
+      type: "string",
+      description: "Placeholder for the input"
+    },
+    prefix: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    size: {
+      type: "choice",
+      options: ["small", "middle", "large"],
+      description: "The size of the input box",
+      defaultValueHint: "middle,"
+    },
+    suffix: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    type: {
+      type: "string",
+      description: "The type of input",
+      defaultValueHint: "text"
+    },
+    value: {
+      type: "string",
+      editOnly: true,
+      uncontrolledProp: "defaultValue"
+    }
+  })),
+  importPath: "antd/lib/input",
+  importName: "Input",
+  isDefaultExport: true
+};
+function registerInput(loader, customInputMeta) {
+  var doRegisterComponent = function doRegisterComponent() {
+    return loader ? loader.registerComponent.apply(loader, arguments) : registerComponent.apply(void 0, arguments);
+  };
+  doRegisterComponent(Input, customInputMeta != null ? customInputMeta : inputMeta);
+}
+var inputTextAreaMeta = {
+  name: "AntdInputTextArea",
+  displayName: "Antd Input Text Area",
+  props: /*#__PURE__*/sortProps( /*#__PURE__*/_extends({}, commonHtmlAttributes, {
+    allowClear: {
+      type: "boolean",
+      description: "If allow to remove input content with clear icon",
+      defaultValueHint: false
+    },
+    autoSize: {
+      type: "object",
+      description: "Height autosize feature, can be set to true | false or an object { minRows: 2, maxRows: 6 }"
+    },
+    disabled: {
+      type: "boolean",
+      description: "Whether the input is disabled",
+      defaultValueHint: false
+    },
+    bordered: {
+      type: "boolean",
+      description: "Whether has border style",
+      defaultValueHint: true
+    },
+    showCount: {
+      type: "boolean",
+      description: "Whether show text count",
+      defaultValueHint: false
+    },
+    id: {
+      type: "string",
+      description: "The ID for input"
+    },
+    maxLength: {
+      type: "number",
+      description: "The max length"
+    },
+    placeholder: {
+      type: "string",
+      description: "Placeholder for the input"
+    },
+    value: {
+      type: "string",
+      editOnly: true,
+      uncontrolledProp: "defaultValue"
+    }
+  })),
+  importPath: "antd/lib/input/TextArea",
+  importName: "TextArea",
+  isDefaultExport: true,
+  parentComponentName: "AntdInput"
+};
+function registerInputTextArea(loader, customInputTextAreaMeta) {
+  var doRegisterComponent = function doRegisterComponent() {
+    return loader ? loader.registerComponent.apply(loader, arguments) : registerComponent.apply(void 0, arguments);
+  };
+  doRegisterComponent(TextArea, customInputTextAreaMeta != null ? customInputTextAreaMeta : inputTextAreaMeta);
+}
+var inputSearchMeta = {
+  name: "AntdInputSearch",
+  displayName: "Antd Input Search",
+  props: /*#__PURE__*/sortProps( /*#__PURE__*/_extends({}, commonHtmlAttributes, {
+    addonBefore: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    allowClear: {
+      type: "boolean",
+      description: "If allow to remove input content with clear icon",
+      defaultValueHint: false
+    },
+    bordered: {
+      type: "boolean",
+      description: "Whether has border style",
+      defaultValueHint: true
+    },
+    disabled: {
+      type: "boolean",
+      description: "Whether the input is disabled",
+      defaultValueHint: false
+    },
+    enterButton: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    id: {
+      type: "string",
+      description: "The ID for input"
+    },
+    loading: {
+      type: "boolean",
+      description: "Search box with loading",
+      defaultValueHint: false
+    },
+    maxLength: {
+      type: "number",
+      description: "The max length"
+    },
+    placeholder: {
+      type: "string",
+      description: "Placeholder for the input"
+    },
+    prefix: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    size: {
+      type: "choice",
+      options: ["small", "middle", "large"],
+      description: "The size of the input box",
+      defaultValueHint: "middle"
+    },
+    suffix: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    type: {
+      type: "string",
+      description: "The type of input"
+    },
+    value: {
+      type: "string",
+      editOnly: true,
+      uncontrolledProp: "defaultValue"
+    }
+  })),
+  importPath: "antd/lib/input/Search",
+  importName: "Search",
+  isDefaultExport: true,
+  parentComponentName: "AntdInput"
+};
+function registerInputSearch(loader, customInputSearchMeta) {
+  var doRegisterComponent = function doRegisterComponent() {
+    return loader ? loader.registerComponent.apply(loader, arguments) : registerComponent.apply(void 0, arguments);
+  };
+  doRegisterComponent(Search, customInputSearchMeta != null ? customInputSearchMeta : inputSearchMeta);
+}
+var inputPasswordMeta = {
+  name: "AntdInputPassword",
+  displayName: "Antd Input Password",
+  props: /*#__PURE__*/sortProps( /*#__PURE__*/_extends({}, commonHtmlAttributes, {
+    addonAfter: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    addonBefore: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    allowClear: {
+      type: "boolean",
+      description: "If allow to remove input content with clear icon",
+      defaultValueHint: false
+    },
+    bordered: {
+      type: "boolean",
+      description: "Whether has border style",
+      defaultValueHint: true
+    },
+    disabled: {
+      type: "boolean",
+      description: "Whether the input is disabled",
+      defaultValueHint: false
+    },
+    id: {
+      type: "string",
+      description: "The ID for input"
+    },
+    maxLength: {
+      type: "number",
+      description: "The max length"
+    },
+    placeholder: {
+      type: "string",
+      description: "Placeholder for the input"
+    },
+    prefix: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    size: {
+      type: "choice",
+      options: ["small", "middle", "large"],
+      description: "The size of the input box",
+      defaultValueHint: "middle"
+    },
+    type: {
+      type: "string",
+      description: "The type of input"
+    },
+    value: {
+      type: "string",
+      editOnly: true,
+      uncontrolledProp: "defaultValue"
+    },
+    visibilityToggle: {
+      type: "boolean",
+      description: "Whether show toggle button",
+      defaultValueHint: true
+    }
+  })),
+  importPath: "antd/lib/input/Password",
+  importName: "Password",
+  isDefaultExport: true,
+  parentComponentName: "AntdInput"
+};
+function registerInputPassword(loader, customInputPasswordMeta) {
+  var doRegisterComponent = function doRegisterComponent() {
+    return loader ? loader.registerComponent.apply(loader, arguments) : registerComponent.apply(void 0, arguments);
+  };
+  doRegisterComponent(Password, customInputPasswordMeta != null ? customInputPasswordMeta : inputPasswordMeta);
+}
+var inputGroupMeta = {
+  name: "AntdInputGroup",
+  displayName: "Antd Input Group",
+  props: {
+    compact: {
+      type: "boolean",
+      description: "Whether use compact style",
+      defaultValueHint: false
+    },
+    size: {
+      type: "choice",
+      options: ["small", "default", "large"],
+      description: "The size of Input.Group specifies the size of the included Input fields",
+      defaultValueHint: "default"
+    },
+    children: {
+      type: "slot",
+      defaultValue: [{
+        type: "component",
+        name: "AntdInput"
+      }, {
+        type: "component",
+        name: "AntdInput"
+      }]
+    }
+  },
+  importPath: "antd/lib/input/Group",
+  importName: "InputGroup",
+  isDefaultExport: true,
+  parentComponentName: "AntdInput"
+};
+function registerInputGroup(loader, customInputGroupMeta) {
+  var doRegisterComponent = function doRegisterComponent() {
+    return loader ? loader.registerComponent.apply(loader, arguments) : registerComponent.apply(void 0, arguments);
+  };
+  doRegisterComponent(InputGroup, customInputGroupMeta != null ? customInputGroupMeta : inputGroupMeta);
+}
+
+var menuDividerMeta = {
+  name: "AntdMenuDivider",
+  displayName: "Antd Menu Divider",
+  props: {
+    dashed: {
+      type: "boolean",
+      description: "Whether line is dashed",
+      defaultValueHint: false
+    }
+  },
+  importPath: "antd/lib/menu/MenuDivider",
+  importName: "MenuDivider",
+  isDefaultExport: true,
+  parentComponentName: "AntdMenu"
+};
+function registerMenuDivider(loader, customMenuDividerMeta) {
+  var doRegisterComponent = function doRegisterComponent() {
+    return loader ? loader.registerComponent.apply(loader, arguments) : registerComponent.apply(void 0, arguments);
+  };
+  doRegisterComponent(MenuDivider, customMenuDividerMeta != null ? customMenuDividerMeta : menuDividerMeta);
+}
+var menuItemMeta = {
+  name: "AntdMenuItem",
+  displayName: "Antd Menu Item",
+  props: {
+    danger: {
+      type: "boolean",
+      description: "Display the danger style",
+      defaultValueHint: false
+    },
+    disabled: {
+      type: "boolean",
+      description: "Whether disabled select",
+      defaultValueHint: false
+    },
+    key: {
+      type: "string",
+      description: "Unique ID of the menu item",
+      defaultValue: "menuItemKey"
+    },
+    title: {
+      type: "string",
+      description: "Set display title for collapsed item"
+    },
+    children: {
+      type: "slot",
+      defaultValue: [{
+        type: "text",
+        value: "Option"
+      }]
+    }
+  },
+  importPath: "antd/lib/menu/MenuItem",
+  importName: "MenuItem",
+  isDefaultExport: true,
+  parentComponentName: "AntdMenu"
+};
+function registerMenuItem(loader, customMenuItemMeta) {
+  var doRegisterComponent = function doRegisterComponent() {
+    return loader ? loader.registerComponent.apply(loader, arguments) : registerComponent.apply(void 0, arguments);
+  };
+  doRegisterComponent(MenuItem, customMenuItemMeta != null ? customMenuItemMeta : menuItemMeta);
+}
+var menuItemGroupMeta = {
+  name: "AntdMenuItemGroup",
+  displayName: "Antd Menu Item Group",
+  props: {
+    title: {
+      type: "slot",
+      defaultValue: [{
+        type: "text",
+        value: "Group"
+      }]
+    },
+    children: {
+      type: "slot",
+      allowedComponents: ["AntdMenuItem", "AntdMenuDivider", "AntdMenuItemGroup"],
+      defaultValue: [{
+        type: "component",
+        name: "AntdMenuItem"
+      }]
+    }
+  },
+  importPath: "rc-menu",
+  importName: "ItemGroup",
+  parentComponentName: "AntdMenu"
+};
+function registerMenuItemGroup(loader, customMenuItemGroupMeta) {
+  var doRegisterComponent = function doRegisterComponent() {
+    return loader ? loader.registerComponent.apply(loader, arguments) : registerComponent.apply(void 0, arguments);
+  };
+  doRegisterComponent(rcMenu.ItemGroup, customMenuItemGroupMeta != null ? customMenuItemGroupMeta : menuItemGroupMeta);
+}
+var subMenuMeta = {
+  name: "AntdSubMenu",
+  displayName: "Antd SubMenu",
+  props: {
+    disabled: {
+      type: "boolean",
+      description: "Whether sub-menu is disabled",
+      defaultValueHint: false
+    },
+    key: {
+      type: "string",
+      description: "Unique ID of the sub-menu",
+      defaultValue: "subMenuKey"
+    },
+    title: {
+      type: "slot",
+      defaultValue: [{
+        type: "text",
+        value: "Sub-menu"
+      }]
+    },
+    children: {
+      type: "slot",
+      allowedComponents: ["AntdMenuItem", "AntdMenuDivider", "AntdMenuItemGroup", "AntdSubMenu"],
+      defaultValue: /*#__PURE__*/[1, 2].map(function (i) {
+        return {
+          type: "component",
+          name: "AntdMenuItem",
+          props: {
+            key: "subMenuItemKey" + i,
+            children: [{
+              type: "text",
+              value: "Sub-menu item " + i
+            }]
+          }
+        };
+      })
+    }
+  },
+  importPath: "antd/lib/menu/SubMenu",
+  importName: "SubMenu",
+  isDefaultExport: true,
+  parentComponentName: "AntdMenu"
+};
+function registerSubMenu(loader, customSubMenuMeta) {
+  var doRegisterComponent = function doRegisterComponent() {
+    return loader ? loader.registerComponent.apply(loader, arguments) : registerComponent.apply(void 0, arguments);
+  };
+  doRegisterComponent(SubMenu, customSubMenuMeta != null ? customSubMenuMeta : subMenuMeta);
+}
+var menuMeta = {
+  name: "AntdMenu",
+  displayName: "Antd Menu",
+  props: {
+    expandIcon: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    forceSubMenuRender: {
+      type: "boolean",
+      description: "Render submenu into DOM before it becomes visible",
+      defaultValueHint: false
+    },
+    inlineIndent: {
+      type: "number",
+      description: "Indent (in pixels) of inline menu items on each level",
+      defaultValueHint: 24
+    },
+    mode: {
+      type: "choice",
+      options: ["horizontal", "vertical", "inline"],
+      description: "Type of menu",
+      defaultValueHint: "vertical"
+    },
+    multiple: {
+      type: "boolean",
+      description: "Allows selection of multiple items",
+      defaultValueHint: false
+    },
+    openKeys: {
+      type: "choice",
+      editOnly: true,
+      uncontrolledProp: "defaultOpenKeys",
+      description: "Array with the keys of default opened sub menus",
+      multiSelect: true,
+      options: function options(componentProps) {
+        var options = new Set();
+        traverseReactEltTree(componentProps.children, function (elt) {
+          if ((elt == null ? void 0 : elt.type) === SubMenu && typeof (elt == null ? void 0 : elt.key) === "string") {
+            options.add(elt.key);
+          }
+        });
+        return Array.from(options.keys());
+      }
+    },
+    overflowedIndicator: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    selectable: {
+      type: "boolean",
+      description: "Allows selecting menu items",
+      defaultValueHint: true
+    },
+    selectedKeys: {
+      type: "choice",
+      editOnly: true,
+      uncontrolledProp: "defaultSelectedKeys",
+      description: "Array with the keys of default selected menu items",
+      multiSelect: true,
+      options: function options(componentProps) {
+        var options = new Set();
+        traverseReactEltTree(componentProps.children, function (elt) {
+          if ([SubMenu, MenuItem].includes(elt == null ? void 0 : elt.type) && typeof (elt == null ? void 0 : elt.key) === "string") {
+            options.add(elt.key);
+          }
+        });
+        return Array.from(options.keys());
+      }
+    },
+    subMenuCloseDelay: {
+      type: "number",
+      description: "Delay time to hide submenu when mouse leaves (in seconds)",
+      defaultValueHint: 0.1
+    },
+    subMenuOpenDelay: {
+      type: "number",
+      description: "Delay time to show submenu when mouse enters, (in seconds)",
+      defaultValueHint: 0
+    },
+    theme: {
+      type: "choice",
+      options: ["light", "dark"],
+      description: "Color theme of the menu",
+      defaultValueHint: "light"
+    },
+    triggerSubMenuAction: {
+      type: "choice",
+      options: ["hover", "click"],
+      description: "Which action can trigger submenu open/close",
+      defaultValueHint: "hover"
+    },
+    children: {
+      type: "slot",
+      allowedComponents: ["AntdMenuItem", "AntdMenuDivider", "AntdSubMenu"],
+      defaultValue: [{
+        type: "component",
+        name: "AntdMenuItem"
+      }, {
+        type: "component",
+        name: "AntdSubMenu"
+      }]
+    }
+  },
+  importPath: "antd/lib/menu/index",
+  importName: "Menu",
+  isDefaultExport: true
+};
+function registerMenu(loader, customMenuMeta) {
+  var doRegisterComponent = function doRegisterComponent() {
+    return loader ? loader.registerComponent.apply(loader, arguments) : registerComponent.apply(void 0, arguments);
+  };
+  doRegisterComponent(Menu, customMenuMeta != null ? customMenuMeta : menuMeta);
+}
+
+var optionMeta = {
+  name: "AntdOption",
+  displayName: "Antd Option",
+  props: {
+    disabled: {
+      type: "boolean",
+      description: "Disable this option",
+      defaultValueHint: false
+    },
+    title: {
+      type: "string",
+      description: "title of Select after select this Option"
+    },
+    value: {
+      type: "string",
+      description: "Default to filter with this property"
+    },
+    key: {
+      type: "string",
+      description: "Option key"
+    },
+    children: {
+      type: "slot",
+      defaultValue: [{
+        type: "text",
+        value: "Option"
+      }]
+    }
+  },
+  importPath: "rc-select",
+  importName: "Option",
+  parentComponentName: "AntdSelect"
+};
+function registerOption(loader, customOptionMeta) {
+  var doRegisterComponent = function doRegisterComponent() {
+    return loader ? loader.registerComponent.apply(loader, arguments) : registerComponent.apply(void 0, arguments);
+  };
+  doRegisterComponent(rcSelect.Option, customOptionMeta != null ? customOptionMeta : optionMeta);
+}
+var optGroupMeta = {
+  name: "AntdOptionGroup",
+  displayName: "Antd Option Group",
+  props: {
+    key: {
+      type: "string",
+      description: "Group key"
+    },
+    label: {
+      type: "string",
+      description: "Group label"
+    },
+    children: {
+      type: "slot",
+      allowedComponents: ["AntdOption"],
+      defaultValue: [{
+        type: "component",
+        name: "AntdOption"
+      }]
+    }
+  },
+  importPath: "rc-select",
+  importName: "OptGroup",
+  parentComponentName: "AntdSelect"
+};
+function registerOptGroup(loader, customOptGroupMeta) {
+  var doRegisterComponent = function doRegisterComponent() {
+    return loader ? loader.registerComponent.apply(loader, arguments) : registerComponent.apply(void 0, arguments);
+  };
+  doRegisterComponent(rcSelect.OptGroup, customOptGroupMeta != null ? customOptGroupMeta : optGroupMeta);
+}
+
+var rateMeta = {
+  name: "AntdRate",
+  displayName: "Antd Rate",
+  props: {
+    allowClear: {
+      type: "boolean",
+      description: "Whether to allow clear when clicking again",
+      defaultValueHint: true
+    },
+    allowHalf: {
+      type: "boolean",
+      description: "Whether to allow semi selection",
+      defaultValueHint: false
+    },
+    autoFocus: {
+      type: "boolean",
+      description: "If componet is focused when mounted",
+      defaultValueHint: false
+    },
+    count: {
+      type: "number",
+      description: "Star count"
+    },
+    disabled: {
+      type: "boolean",
+      description: "Disabled state of component",
+      defaultValueHint: false
+    },
+    tooltips: {
+      type: "array",
+      description: "Array to customize tooltip for each icon"
+    },
+    value: {
+      type: "number",
+      description: "The default value",
+      editOnly: true,
+      uncontrolledProp: "defaultValue",
+      defaultValueHint: 0
+    },
+    character: {
+      type: "slot",
+      hidePlaceholder: true
+    }
+  },
+  importPath: "antd/lib/rate",
+  importName: "Rate",
+  isDefaultExport: true
+};
+function registerRate(loader, customRateMeta) {
+  var doRegisterComponent = function doRegisterComponent() {
+    return loader ? loader.registerComponent.apply(loader, arguments) : registerComponent.apply(void 0, arguments);
+  };
+  doRegisterComponent(Rate, customRateMeta != null ? customRateMeta : rateMeta);
+}
+
+var selectMeta = {
+  name: "AntdSelect",
+  displayName: "Antd Select",
+  props: {
+    allowClear: {
+      type: "boolean",
+      description: "Show clear button",
+      defaultValueHint: false
+    },
+    autoClearSearchValue: {
+      type: "boolean",
+      description: "Whether the current search will be cleared on selecting an item",
+      defaultValueHint: true,
+      hidden: function hidden(props) {
+        return props.mode !== "multiple" && props.mode !== "tags";
+      }
+    },
+    autoFocus: {
+      type: "boolean",
+      description: "Get focus by default",
+      defaultValueHint: false
+    },
+    bordered: {
+      type: "boolean",
+      description: "Whether has border style",
+      defaultValueHint: true
+    },
+    disabled: {
+      type: "boolean",
+      description: "Whether disabled select",
+      defaultValueHint: false
+    },
+    listHeight: {
+      type: "number",
+      description: "Config popup height",
+      defaultValueHint: 256
+    },
+    loading: {
+      type: "boolean",
+      description: "Indicate loading state",
+      defaultValueHint: false
+    },
+    mode: {
+      type: "choice",
+      options: ["multiple", "tags"],
+      description: "Set mode of Select"
+    },
+    open: {
+      type: "boolean",
+      editOnly: true,
+      uncontrolledProp: "defaultOpen",
+      description: "Initial open state of dropdown",
+      defaultValueHint: false
+    },
+    placeholder: {
+      type: "slot",
+      defaultValue: [{
+        type: "text",
+        value: "Select"
+      }]
+    },
+    showArrow: {
+      type: "boolean",
+      description: "Whether to show the drop-down arrow",
+      defaultValueHint: true
+    },
+    showSearch: {
+      type: "boolean",
+      description: "Whether show search input in single mode",
+      defaultValueHint: false
+    },
+    size: {
+      type: "choice",
+      options: ["large", "middle", "small"],
+      description: "Set mode of Select",
+      defaultValueHint: "middle"
+    },
+    value: {
+      type: "choice",
+      editOnly: true,
+      uncontrolledProp: "defaultValue",
+      description: "Initial selected option",
+      options: function options(componentProps) {
+        var options = new Set();
+        traverseReactEltTree(componentProps.children, function (elt) {
+          var _elt$props;
+          if ((elt == null ? void 0 : elt.type) === rcSelect.Option && typeof (elt == null ? void 0 : (_elt$props = elt.props) == null ? void 0 : _elt$props.value) === "string") {
+            options.add(elt.props.value);
+          }
+        });
+        return Array.from(options.keys());
+      }
+    },
+    virtual: {
+      type: "boolean",
+      description: "Disable virtual scroll when set to false",
+      defaultValueHint: true
+    },
+    children: {
+      type: "slot",
+      allowedComponents: ["AntdOption, AntdOptionGroup"],
+      defaultValue: [{
+        type: "component",
+        name: "AntdOption",
+        props: {
+          value: "Option",
+          children: {
+            type: "text",
+            value: "Option"
+          }
+        }
+      }]
+    }
+  },
+  importPath: "antd/lib/select",
+  importName: "Select",
+  isDefaultExport: true
+};
+function registerSelect(loader, customSelectMeta) {
+  var doRegisterComponent = function doRegisterComponent() {
+    return loader ? loader.registerComponent.apply(loader, arguments) : registerComponent.apply(void 0, arguments);
+  };
+  doRegisterComponent(Select, customSelectMeta != null ? customSelectMeta : selectMeta);
+}
+
+var _excluded$1 = ["value", "defaultValue", "value2", "defaultValue2"];
+var Slider = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
+  var value = _ref.value,
+    defaultValue = _ref.defaultValue,
+    value2 = _ref.value2,
+    defaultValue2 = _ref.defaultValue2,
+    props = _objectWithoutPropertiesLoose(_ref, _excluded$1);
+  var newProps = _extends({}, props);
+  if (props.range) {
+    if (typeof value === "number" || typeof value2 === "number") {
+      newProps.value = [value != null ? value : 0, value2 != null ? value2 : 0];
+    }
+    if (typeof defaultValue === "number" || typeof defaultValue2 === "number") {
+      newProps.defaultValue = [defaultValue != null ? defaultValue : 0, defaultValue2 != null ? defaultValue2 : 0];
+    }
+  } else {
+    if (typeof value === "number") {
+      newProps.value = value;
+    }
+    if (typeof defaultValue === "number") {
+      newProps.defaultValue = defaultValue;
+    }
+  }
+  return React.createElement(AntdSlider, Object.assign({}, newProps, {
+    ref: ref
+  }));
+});
+var sliderMeta = {
+  name: "AntdSlider",
+  displayName: "Antd Slider",
+  props: {
+    max: {
+      type: "number",
+      description: "The maximum value the slider can slide to",
+      defaultValueHint: 100
+    },
+    min: {
+      type: "number",
+      description: "The minimum value the slider can slide to",
+      defaultValueHint: 0
+    },
+    included: {
+      type: "boolean",
+      description: "Make effect when marks not null, true means containment and false means coordinative",
+      defaultValueHint: true
+    },
+    disabled: {
+      type: "boolean",
+      description: "If true, the slider will not be interactable",
+      defaultValueHint: false
+    },
+    range: {
+      type: "boolean",
+      description: "Dual thumb mode",
+      defaultValueHint: false
+    },
+    reverse: {
+      type: "boolean",
+      description: "Reverse the component",
+      defaultValueHint: false
+    },
+    vertical: {
+      type: "boolean",
+      description: "If true, the slider will be vertical",
+      defaultValueHint: false
+    },
+    value: {
+      type: "number",
+      editOnly: true,
+      uncontrolledProp: "defaultValue",
+      description: "The default value of slider"
+    },
+    value2: {
+      type: "number",
+      displayName: "value 2",
+      editOnly: true,
+      uncontrolledProp: "defaultValue2",
+      description: "The default value for the second value of the slider",
+      hidden: function hidden(props) {
+        return !props.range;
+      }
+    },
+    step: {
+      type: "number",
+      description: "The granularity the slider can step through values. Must greater than 0, and be divided by (max - min)." + " When marks no null, step can be null",
+      defaultValueHint: 1
+    },
+    marks: {
+      type: "object",
+      description: "Tick mark of Slider, type of key must be number, and must in closed interval [min, max]," + " each mark can declare its own style"
+    }
+  },
+  defaultStyles: {
+    width: "200px",
+    maxWidth: "100%"
+  },
+  importPath: "@plasmicpkgs/antd/skinny/registerSlider",
+  importName: "Slider"
+};
+function registerSlider(loader, customSliderMeta) {
+  var doRegisterComponent = function doRegisterComponent() {
+    return loader ? loader.registerComponent.apply(loader, arguments) : registerComponent.apply(void 0, arguments);
+  };
+  doRegisterComponent(Slider, customSliderMeta != null ? customSliderMeta : sliderMeta);
+}
+
+var switchMeta = {
+  name: "AntdSwitch",
+  displayName: "Antd Switch",
+  props: {
+    autoFocus: {
+      type: "boolean",
+      description: "Whether get focus when component mounted",
+      defaultValueHint: false
+    },
+    checked: {
+      type: "boolean",
+      editOnly: true,
+      uncontrolledProp: "defaultChecked",
+      description: "Whether to set the initial state",
+      defaultValueHint: false
+    },
+    disabled: {
+      type: "boolean",
+      description: "Disable switch",
+      defaultValueHint: false
+    },
+    loading: {
+      type: "boolean",
+      description: "Loading state of switch",
+      defaultValueHint: false
+    },
+    checkedChildren: {
+      type: "slot",
+      defaultValue: [],
+      hidePlaceholder: true
+    },
+    unCheckedChildren: {
+      type: "slot",
+      defaultValue: [],
+      hidePlaceholder: true
+    },
+    size: {
+      type: "choice",
+      options: ["small", "default"],
+      description: "The size of the Switch",
+      defaultValueHint: "default"
+    }
+  },
+  importPath: "antd/lib/switch",
+  importName: "Switch",
+  isDefaultExport: true
+};
+function registerSwitch(loader, customSwitchMeta) {
+  var doRegisterComponent = function doRegisterComponent() {
+    return loader ? loader.registerComponent.apply(loader, arguments) : registerComponent.apply(void 0, arguments);
+  };
+  doRegisterComponent(Switch, customSwitchMeta != null ? customSwitchMeta : switchMeta);
+}
+
+var _excluded$2 = ["columnTemplate", "title", "dataIndex"];
+// This is an empty virtual component used to allow users to define column
+// properties in plasmic.
+function TableColumn(_props) {
+  return null;
+}
+function TableValue(props) {
+  var _column$toString;
+  var className = props.className;
+  var column = host.useSelector("currentColumn");
+  return React.createElement("div", {
+    className: className
+  }, (_column$toString = column == null ? void 0 : column.toString()) != null ? _column$toString : "");
+}
+/**
+ * Wrapper used to consume internal canvas props
+ */
+function ColumnWrapper(props) {
+  return props.children;
+}
+function TableWrapper(props) {
+  var _columns$props$childr, _columns$props;
+  var className = props.className,
+    items = props.items,
+    columns = props.columns,
+    size = props.size,
+    onSelect = props.onSelect,
+    pagination = props.pagination;
+  // Plasmic Studio Canvas currently renders items in a slightly different way than the generated code:
+  // - In the studio:
+  //     - The `columns` prop value is an array of nested react <Column  /> nodes.
+  // - In the generated code (preview mode):
+  //     - The `columns` prop value is a React Node with a `children` property that contains
+  //       an array of the nested react <Column /> components.
+  var tableColumns = (_columns$props$childr = columns == null ? void 0 : (_columns$props = columns.props) == null ? void 0 : _columns$props.children) != null ? _columns$props$childr : columns;
+  // Convert the props.columns slot children to an array of column definitions
+  var columnDefinitions = React.useMemo(function () {
+    return React.Children.map(tableColumns, function (column, columnIndex) {
+      if (!column) {
+        return undefined;
+      }
+      var _column$props = column.props,
+        columnTemplate = _column$props.columnTemplate,
+        title = _column$props.title,
+        dataIndex = _column$props.dataIndex,
+        rest = _objectWithoutPropertiesLoose(_column$props, _excluded$2);
+      var columnDefinition = {
+        columnIndex: columnIndex,
+        title: title,
+        dataIndex: dataIndex,
+        key: columnIndex,
+        render: function render(value, record, rowIndex) {
+          return React.createElement(host.DataProvider, {
+            name: "currentRow",
+            data: record
+          }, React.createElement(host.DataProvider, {
+            name: "currentRowIndex",
+            data: rowIndex
+          }, React.createElement(host.DataProvider, {
+            name: "currentColumn",
+            data: value
+          }, host.repeatedElement(rowIndex, React.createElement(ColumnWrapper, Object.assign({}, rest), columnTemplate)))));
+        }
+      };
+      return columnDefinition;
+    }).filter(Boolean);
+  }, [tableColumns]);
+  return React.createElement(Table, {
+    className: className,
+    columns: columnDefinitions,
+    dataSource: items,
+    size: size,
+    onRow: function onRow(record) {
+      return {
+        onMouseUp: function onMouseUp() {
+          return onSelect == null ? void 0 : onSelect(record.id);
+        }
+      };
+    },
+    pagination: pagination ? undefined : pagination,
+    rowKey: "id"
+  });
+}
+var DEFAULT_ITEMS = [{
+  name: "John Brown",
+  age: 19,
+  address: "New York No. 1 Lake Park",
+  tags: ["student", "developer"]
+}, {
+  name: "Jim Green",
+  age: 42,
+  address: "London No. 1 Lake Park",
+  tags: ["teacher"]
+}, {
+  name: "Joe Black",
+  age: 32,
+  address: "Sidney No. 1 Lake Park",
+  tags: ["cool", "teacher"]
+}];
+function capitalize(input) {
+  return input.charAt(0).toUpperCase() + input.slice(1);
+}
+var tableMeta = {
+  name: "AntdTable",
+  displayName: "Antd Table",
+  props: {
+    items: {
+      type: "array",
+      description: "The data to display in the table, as a list of objects (one object per row)",
+      defaultValue: DEFAULT_ITEMS
+    },
+    columns: {
+      type: "slot",
+      allowedComponents: ["AntdTableColumn"],
+      defaultValue: /*#__PURE__*/Object.keys(DEFAULT_ITEMS[0]).map(function (columnName) {
+        return {
+          type: "component",
+          name: "AntdTableColumn",
+          props: {
+            title: capitalize(columnName),
+            dataIndex: columnName
+          }
+        };
+      })
+    },
+    size: {
+      type: "choice",
+      options: ["large", "middle", "small"],
+      defaultValueHint: "large"
+    },
+    pagination: {
+      type: "boolean",
+      defaultValueHint: true
+    }
+  },
+  importPath: "@plasmicpkgs/antd/skinny/registerTable",
+  importName: "TableWrapper"
+};
+var tableColumnMeta = {
+  name: "AntdTableColumn",
+  parentComponentName: "AntdTable",
+  providesData: true,
+  props: {
+    title: {
+      type: "string",
+      defaultValue: "Name"
+    },
+    dataIndex: {
+      type: "string",
+      defaultValue: "name",
+      description: "The field to show. The table accepts some data as a list of objects, and this is the name of the field in those objects that this column will display."
+    },
+    columnTemplate: {
+      type: "slot",
+      defaultValue: {
+        type: "vbox",
+        styles: {
+          padding: 0
+        },
+        children: [{
+          type: "component",
+          name: "AntdTableValue"
+        }]
+      }
+    }
+  },
+  importPath: "@plasmicpkgs/antd/skinny/registerTable",
+  importName: "TableColumn"
+};
+var tableValueMeta = {
+  name: "AntdTableValue",
+  parentComponentName: "AntdTableColumn",
+  props: {},
+  importPath: "@plasmicpkgs/antd/skinny/registerTable",
+  importName: "TableValue"
+};
+function registerTable(loader, customMeta) {
+  var doRegisterComponent = function doRegisterComponent() {
+    return loader ? loader.registerComponent.apply(loader, arguments) : host.registerComponent.apply(void 0, arguments);
+  };
+  doRegisterComponent(TableWrapper, customMeta != null ? customMeta : tableMeta);
+}
+function registerTableColumn(loader, customMeta) {
+  var doRegisterComponent = function doRegisterComponent() {
+    return loader ? loader.registerComponent.apply(loader, arguments) : host.registerComponent.apply(void 0, arguments);
+  };
+  doRegisterComponent(TableColumn, customMeta != null ? customMeta : tableColumnMeta);
+}
+function registerTableValue(loader, customMeta) {
+  var doRegisterComponent = function doRegisterComponent() {
+    return loader ? loader.registerComponent.apply(loader, arguments) : host.registerComponent.apply(void 0, arguments);
+  };
+  doRegisterComponent(TableValue, customMeta != null ? customMeta : tableValueMeta);
+}
+
+var _excluded$3 = ["leftTabBarExtraContent", "rightTabBarExtraContent"];
+var tabPaneMeta = {
+  name: "AntdTabPane",
+  displayName: "Antd Tab Pane",
+  props: {
+    tab: {
+      type: "slot",
+      defaultValue: [{
+        type: "text",
+        value: "Tab"
+      }]
+    },
+    key: {
+      type: "string",
+      description: "Unique TabPane's key",
+      defaultValue: "tabPaneKey"
+    },
+    closable: {
+      type: "boolean",
+      description: "Wether the tab can be closed or not. Only works for editable tabs",
+      defaultValueHint: true
+    },
+    disabled: {
+      type: "boolean",
+      description: "Disabled state of tab",
+      defaultValueHint: false
+    },
+    forceRender: {
+      type: "boolean",
+      description: "Forced render of content in tabs, not lazy render after clicking on tabs",
+      defaultValueHint: false
+    },
+    closeIcon: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    children: {
+      type: "slot",
+      defaultValue: [{
+        type: "text",
+        value: "Tab Content"
+      }]
+    }
+  },
+  parentComponentName: "AntdTabs",
+  importPath: "rc-tabs",
+  importName: "TabPane"
+};
+function registerTabPane(loader, customTabPaneMeta) {
+  var doRegisterComponent = function doRegisterComponent() {
+    return loader ? loader.registerComponent.apply(loader, arguments) : registerComponent.apply(void 0, arguments);
+  };
+  doRegisterComponent(rcTabs.TabPane, customTabPaneMeta != null ? customTabPaneMeta : tabPaneMeta);
+}
+function Tabs(props) {
+  var leftTabBarExtraContent = props.leftTabBarExtraContent,
+    rightTabBarExtraContent = props.rightTabBarExtraContent,
+    otherProps = _objectWithoutPropertiesLoose(props, _excluded$3);
+  return React.createElement(AntdTabs, Object.assign({}, otherProps, {
+    tabBarExtraContent: {
+      left: leftTabBarExtraContent,
+      right: rightTabBarExtraContent
+    }
+  }));
+}
+function NavigateTabs(_ref) {
+  var componentProps = _ref.componentProps,
+    studioOps = _ref.studioOps;
+  var tabPanes = [];
+  traverseReactEltTree(componentProps.children, function (elt) {
+    if ((elt == null ? void 0 : elt.type) === rcTabs.TabPane && typeof (elt == null ? void 0 : elt.key) === "string") {
+      tabPanes.push(elt.key);
+    }
+  });
+  var activeKey = componentProps.activeKey;
+  var currTabPos = activeKey ? tabPanes.findIndex(function (tabKey) {
+    return tabKey === activeKey;
+  }) : 0;
+  return React.createElement("div", {
+    style: {
+      width: "100%",
+      display: "flex",
+      flexDirection: "row",
+      gap: "10px",
+      justifyContent: "space-between"
+    }
+  }, React.createElement(antd.Button, {
+    style: {
+      width: "100%"
+    },
+    onClick: function onClick() {
+      if (tabPanes.length > 0) {
+        var prevTabPos = (currTabPos - 1 + tabPanes.length) % tabPanes.length;
+        studioOps.updateProps({
+          activeKey: tabPanes[prevTabPos]
+        });
+      }
+    }
+  }, "Prev tab"), React.createElement(antd.Button, {
+    style: {
+      width: "100%"
+    },
+    onClick: function onClick() {
+      if (tabPanes.length > 0) {
+        var nextTabPos = (currTabPos + 1) % tabPanes.length;
+        studioOps.updateProps({
+          activeKey: tabPanes[nextTabPos]
+        });
+      }
+    }
+  }, "Next tab"));
+}
+function OutlineMessage() {
+  return React.createElement("div", null, "* To re-arrange tab panes, use the Outline panel");
+}
+var tabsMeta = {
+  name: "AntdTabs",
+  displayName: "Antd Tabs",
+  props: {
+    type: {
+      type: "choice",
+      options: ["line", "card", "editable-card"],
+      defaultValueHint: "line",
+      description: "Basic style of tabs"
+    },
+    addIcon: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    animated: {
+      type: "object",
+      hidden: function hidden(props) {
+        return props.tabPosition !== "top" && !!props.tabPosition;
+      },
+      defaultValueHint: {
+        inkBar: true,
+        tabPane: false
+      },
+      description: "Whether to change tabs with animation. Can be either a boolean or specify for inkBar and tabPane"
+    },
+    hideAdd: {
+      type: "boolean",
+      hidden: function hidden(props) {
+        return props.type !== "editable-card";
+      },
+      defaultValueHint: false,
+      description: "Hide plus icon or not"
+    },
+    moreIcon: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    size: {
+      type: "choice",
+      options: ["large", "default", "small"],
+      defaultValueHint: "default",
+      description: "Preset tab bar size"
+    },
+    tabPosition: {
+      type: "choice",
+      options: ["top", "right", "bottom", "left"],
+      defaultValueHint: "top",
+      description: "Position of tabs"
+    },
+    tabBarGutter: {
+      type: "number",
+      description: "The gap between tabs"
+    },
+    centered: {
+      type: "boolean",
+      description: "Centers tabs",
+      defaultValueHint: false
+    },
+    leftTabBarExtraContent: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    rightTabBarExtraContent: {
+      type: "slot",
+      hidePlaceholder: true
+    },
+    tabBarStyle: {
+      type: "object",
+      description: "CSS for the Tab Bar style"
+    },
+    activeKey: {
+      type: "choice",
+      editOnly: true,
+      uncontrolledProp: "defaultActiveKey",
+      description: "Initial active TabPane's key",
+      options: function options(props) {
+        var options = new Set();
+        traverseReactEltTree(props.children, function (elt) {
+          if ((elt == null ? void 0 : elt.type) === rcTabs.TabPane && typeof (elt == null ? void 0 : elt.key) === "string") {
+            options.add(elt.key);
+          }
+        });
+        return Array.from(options.keys());
+      }
+    },
+    children: {
+      type: "slot",
+      allowedComponents: ["AntdTabPane"],
+      defaultValue: [{
+        type: "component",
+        name: "AntdTabPane",
+        props: {
+          key: "1",
+          tab: [{
+            type: "text",
+            value: "Tab"
+          }],
+          children: [{
+            type: "text",
+            value: "Tab content"
+          }]
+        }
+      }, {
+        type: "component",
+        name: "AntdTabPane",
+        props: {
+          key: "2",
+          tab: [{
+            type: "text",
+            value: "Tab"
+          }],
+          children: [{
+            type: "text",
+            value: "Tab content"
+          }]
+        }
+      }]
+    }
+  },
+  actions: [{
+    type: "custom-action",
+    control: NavigateTabs
+  }, {
+    type: "button-action",
+    label: "Add new tab",
+    onClick: function onClick(_ref2) {
+      var componentProps = _ref2.componentProps,
+        studioOps = _ref2.studioOps;
+      // Get the first positive integer that isn't already a key
+      var generateNewKey = function generateNewKey() {
+        var keysSet = new Set();
+        traverseReactEltTree(componentProps.children, function (elt) {
+          if ((elt == null ? void 0 : elt.type) === rcTabs.TabPane && typeof (elt == null ? void 0 : elt.key) === "string") {
+            keysSet.add(elt.key);
+          }
+        });
+        for (var keyCandidate = 1; keyCandidate <= keysSet.size + 1; keyCandidate++) {
+          var strKey = keyCandidate.toString();
+          if (!keysSet.has(strKey)) {
+            return strKey;
+          }
+        }
+        return undefined;
+      };
+      var tabKey = generateNewKey();
+      studioOps.appendToSlot({
+        type: "component",
+        name: "AntdTabPane",
+        props: {
+          key: tabKey
+        }
+      }, "children");
+      studioOps.updateProps({
+        activeKey: tabKey
+      });
+    }
+  }, {
+    type: "button-action",
+    label: "Delete current tab",
+    onClick: function onClick(_ref3) {
+      var componentProps = _ref3.componentProps,
+        studioOps = _ref3.studioOps;
+      if (componentProps.activeKey) {
+        var tabPanes = [];
+        traverseReactEltTree(componentProps.children, function (elt) {
+          if ((elt == null ? void 0 : elt.type) === rcTabs.TabPane && typeof (elt == null ? void 0 : elt.key) === "string") {
+            tabPanes.push(elt.key);
+          }
+        });
+        var activeKey = componentProps.activeKey;
+        var currTabPos = tabPanes.findIndex(function (tabKey) {
+          return tabKey === activeKey;
+        });
+        if (currTabPos !== -1) {
+          studioOps.removeFromSlotAt(currTabPos, "children");
+          if (tabPanes.length - 1 > 0) {
+            var prevTabPos = (currTabPos - 1 + tabPanes.length) % tabPanes.length;
+            studioOps.updateProps({
+              activeKey: tabPanes[prevTabPos]
+            });
+          }
+        }
+      }
+    }
+  }, {
+    type: "custom-action",
+    control: OutlineMessage
+  }],
+  importPath: "@plasmicpkgs/antd/skinny/registerTabs",
+  importName: "Tabs"
+};
+function registerTabs(loader, customTabsMeta) {
+  var doRegisterComponent = function doRegisterComponent() {
+    return loader ? loader.registerComponent.apply(loader, arguments) : registerComponent.apply(void 0, arguments);
+  };
+  doRegisterComponent(Tabs, customTabsMeta != null ? customTabsMeta : tabsMeta);
+}
+
+function registerAll(loader) {
+  registerButton(loader);
+  registerSlider(loader);
+  registerSwitch(loader);
+  registerOption(loader);
+  registerOptGroup(loader);
+  registerSelect(loader);
+  registerCollapsePanel(loader);
+  registerCollapse(loader);
+  registerCheckbox(loader);
+  registerCheckboxGroup(loader);
+  registerMenuDivider(loader);
+  registerMenuItem(loader);
+  registerMenuItemGroup(loader);
+  registerSubMenu(loader);
+  registerMenu(loader);
+  registerDropdown(loader);
+  registerDropdownButton(loader);
+  registerCarousel(loader);
+  registerInput(loader);
+  registerInputTextArea(loader);
+  registerInputSearch(loader);
+  registerInputPassword(loader);
+  registerInputGroup(loader);
+  registerTabPane(loader);
+  registerTable(loader);
+  registerTableColumn(loader);
+  registerTableValue(loader);
+  registerTabs(loader);
+  registerRate(loader);
+}
+
+exports.Collapse = Collapse;
+exports.Dropdown = Dropdown;
+exports.Slider = Slider;
+exports.Tabs = Tabs;
+exports.buttonMeta = buttonMeta;
+exports.carouselMeta = carouselMeta;
+exports.checkboxGroupMeta = checkboxGroupMeta;
+exports.checkboxMeta = checkboxMeta;
+exports.collapsteMeta = collapsteMeta;
+exports.collapstePanelMeta = collapstePanelMeta;
+exports.dropdownButtonMeta = dropdownButtonMeta;
+exports.dropdownMeta = dropdownMeta;
+exports.inputGroupMeta = inputGroupMeta;
+exports.inputMeta = inputMeta;
+exports.inputPasswordMeta = inputPasswordMeta;
+exports.inputSearchMeta = inputSearchMeta;
+exports.inputTextAreaMeta = inputTextAreaMeta;
+exports.menuDividerMeta = menuDividerMeta;
+exports.menuItemGroupMeta = menuItemGroupMeta;
+exports.menuItemMeta = menuItemMeta;
+exports.menuMeta = menuMeta;
+exports.optGroupMeta = optGroupMeta;
+exports.optionMeta = optionMeta;
+exports.rateMeta = rateMeta;
+exports.registerAll = registerAll;
+exports.registerButton = registerButton;
+exports.registerCarousel = registerCarousel;
+exports.registerCheckbox = registerCheckbox;
+exports.registerCheckboxGroup = registerCheckboxGroup;
+exports.registerCollapse = registerCollapse;
+exports.registerCollapsePanel = registerCollapsePanel;
+exports.registerDropdown = registerDropdown;
+exports.registerDropdownButton = registerDropdownButton;
+exports.registerInput = registerInput;
+exports.registerInputGroup = registerInputGroup;
+exports.registerInputPassword = registerInputPassword;
+exports.registerInputSearch = registerInputSearch;
+exports.registerInputTextArea = registerInputTextArea;
+exports.registerMenu = registerMenu;
+exports.registerMenuDivider = registerMenuDivider;
+exports.registerMenuItem = registerMenuItem;
+exports.registerMenuItemGroup = registerMenuItemGroup;
+exports.registerOptGroup = registerOptGroup;
+exports.registerOption = registerOption;
+exports.registerRate = registerRate;
+exports.registerSelect = registerSelect;
+exports.registerSlider = registerSlider;
+exports.registerSubMenu = registerSubMenu;
+exports.registerSwitch = registerSwitch;
+exports.registerTabPane = registerTabPane;
+exports.registerTabs = registerTabs;
+exports.selectMeta = selectMeta;
+exports.sliderMeta = sliderMeta;
+exports.subMenuMeta = subMenuMeta;
+exports.switchMeta = switchMeta;
+exports.tabPaneMeta = tabPaneMeta;
+exports.tabsMeta = tabsMeta;
+//# sourceMappingURL=antd.cjs.development.js.map