@daouypkgs/antd 2.0.157

package/dist/index.js

@@ -0,0 +1,2644 @@
+'use strict';
+
+var registerComponent = require('@daouy/host/registerComponent');
+var antd = require('antd');
+var React = require('react');
+var host = require('@daouy/host');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var registerComponent__default = /*#__PURE__*/_interopDefault(registerComponent);
+var React__default = /*#__PURE__*/_interopDefault(React);
+
+const Button = antd.Button;
+const 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: (props) => !props.href,
+      defaultValueHint: "_self"
+    },
+    children: {
+      type: "slot",
+      defaultValue: [
+        {
+          type: "text",
+          value: "Button"
+        }
+      ]
+    }
+  },
+  importPath: "@daouypkgs/antd/skinny/registerButton",
+  importName: "Button"
+};
+function registerButton(loader, customButtonMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(antd.Button, customButtonMeta != null ? customButtonMeta : buttonMeta);
+}
+
+const Carousel = antd.Carousel;
+const contentStyle = {
+  height: 160,
+  color: "#fff",
+  lineHeight: 160,
+  textAlign: "center",
+  backgroundColor: "#364d79"
+};
+const 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: "@daouypkgs/antd/skinny/registerCarousel",
+  importName: "Carousel"
+};
+function registerCarousel(loader, customCarouselMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(Carousel, customCarouselMeta != null ? customCarouselMeta : carouselMeta);
+}
+
+function traverseReactEltTree(children, callback) {
+  const rec = (elts) => {
+    (Array.isArray(elts) ? elts : [elts]).forEach((elt) => {
+      var _a;
+      if (elt) {
+        callback(elt);
+        if (elt.children) {
+          rec(elt.children);
+        }
+        if (((_a = elt.props) == null ? void 0 : _a.children) && elt.props.children !== elt.children) {
+          rec(elt.props.children);
+        }
+      }
+    });
+  };
+  rec(children);
+}
+
+var __defProp$6 = Object.defineProperty;
+var __getOwnPropSymbols$6 = Object.getOwnPropertySymbols;
+var __hasOwnProp$6 = Object.prototype.hasOwnProperty;
+var __propIsEnum$6 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$6 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$6.call(b, prop))
+      __defNormalProp$6(a, prop, b[prop]);
+  if (__getOwnPropSymbols$6)
+    for (var prop of __getOwnPropSymbols$6(b)) {
+      if (__propIsEnum$6.call(b, prop))
+        __defNormalProp$6(a, prop, b[prop]);
+    }
+  return a;
+};
+const Checkbox = antd.Checkbox;
+const CheckboxGroup = Checkbox.Group;
+class CheckboxWrapper extends React__default.default.Component {
+  render() {
+    return /* @__PURE__ */ React__default.default.createElement(Checkbox, __spreadValues$6({}, this.props));
+  }
+}
+const checkboxHelpers = {
+  states: {
+    value: {
+      onChangeArgsToValue: (e) => e.target.checked
+    }
+  }
+};
+const checkboxMeta = {
+  name: "AntdCheckbox",
+  displayName: "Antd Checkbox",
+  props: {
+    autoFocus: {
+      type: "boolean",
+      description: "If get focus when component mounted",
+      defaultValueHint: false
+    },
+    checked: {
+      type: "boolean",
+      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"
+        }
+      ]
+    },
+    onChange: {
+      type: "eventHandler",
+      argTypes: [
+        {
+          name: "event",
+          type: "object"
+        }
+      ]
+    }
+  },
+  states: {
+    value: {
+      type: "writable",
+      variableType: "boolean",
+      onChangeProp: "onChange",
+      valueProp: "checked"
+    }
+  },
+  componentHelpers: {
+    helpers: checkboxHelpers,
+    importName: "checkboxHelpers",
+    importPath: "@daouypkgs/antd/skinny/registerCheckbox"
+  },
+  importPath: "@daouypkgs/antd/skinny/registerCheckbox",
+  importName: "Checkbox",
+  defaultStyles: {
+    marginLeft: 0
+  }
+};
+function registerCheckbox(loader, customCheckboxMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(CheckboxWrapper, customCheckboxMeta != null ? customCheckboxMeta : checkboxMeta);
+}
+function getGroupOptions(componentProps) {
+  const options = /* @__PURE__ */ new Set();
+  traverseReactEltTree(componentProps.children, (elt) => {
+    var _a;
+    if ((elt == null ? void 0 : elt.type) === CheckboxWrapper && typeof ((_a = elt == null ? void 0 : elt.props) == null ? void 0 : _a.value) === "string") {
+      options.add(elt.props.value);
+    }
+  });
+  return Array.from(options.keys());
+}
+const checkboxGroupMeta = {
+  name: "AntdCheckboxGroup",
+  displayName: "Antd Checkbox Group",
+  props: {
+    disabled: {
+      type: "boolean",
+      description: "If disable all checkboxes",
+      defaultValueHint: false
+    },
+    value: {
+      type: "choice",
+      editOnly: true,
+      description: "Default selected value",
+      multiSelect: true,
+      options: getGroupOptions
+    },
+    onChange: {
+      type: "eventHandler",
+      argTypes: [
+        {
+          name: "value",
+          type: {
+            type: "choice",
+            multiSelect: true,
+            options: getGroupOptions
+          }
+        }
+      ]
+    },
+    children: {
+      type: "slot",
+      allowedComponents: ["AntdCheckbox"],
+      defaultValue: [
+        {
+          type: "component",
+          name: "AntdCheckbox"
+        }
+      ]
+    }
+  },
+  states: {
+    value: {
+      type: "writable",
+      variableType: "array",
+      valueProp: "value",
+      onChangeProp: "onChange"
+    }
+  },
+  importPath: "@daouypkgs/antd/skinny/registerCheckbox",
+  importName: "CheckboxGroup",
+  parentComponentName: "AntdCheckbox"
+};
+function registerCheckboxGroup(loader, customCheckboxGroupMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(
+    CheckboxGroup,
+    customCheckboxGroupMeta != null ? customCheckboxGroupMeta : checkboxGroupMeta
+  );
+}
+
+var __defProp$5 = Object.defineProperty;
+var __defProps$3 = Object.defineProperties;
+var __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$5 = Object.getOwnPropertySymbols;
+var __hasOwnProp$5 = Object.prototype.hasOwnProperty;
+var __propIsEnum$5 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$5 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$5.call(b, prop))
+      __defNormalProp$5(a, prop, b[prop]);
+  if (__getOwnPropSymbols$5)
+    for (var prop of __getOwnPropSymbols$5(b)) {
+      if (__propIsEnum$5.call(b, prop))
+        __defNormalProp$5(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
+var __objRest$3 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$5.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$5)
+    for (var prop of __getOwnPropSymbols$5(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$5.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+const CollapsePanel = antd.Collapse.Panel;
+const 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: "@daouypkgs/antd/skinny/registerCollapse",
+  importName: "CollapsePanel",
+  parentComponentName: "AntdCollapse"
+};
+function registerCollapsePanel(loader, customCollapsePanelMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(
+    CollapsePanel,
+    customCollapsePanelMeta != null ? customCollapsePanelMeta : collapstePanelMeta
+  );
+}
+function getOptions(componentProps) {
+  const options = /* @__PURE__ */ new Set();
+  traverseReactEltTree(componentProps.children, (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());
+}
+const collapsteMeta = {
+  name: "AntdCollapse",
+  displayName: "Antd Collapse",
+  props: {
+    accordion: {
+      type: "boolean",
+      description: "If true, Collapse renders as Accordion",
+      defaultValueHint: false
+    },
+    activeKey: {
+      type: "choice",
+      editOnly: true,
+      description: "Key of the active panel",
+      multiSelect: true,
+      options: getOptions
+    },
+    onChange: {
+      type: "eventHandler",
+      argTypes: [
+        {
+          name: "value",
+          type: {
+            type: "choice",
+            multiSelect: true,
+            options: getOptions
+          }
+        }
+      ]
+    },
+    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
+    }
+  },
+  states: {
+    activeKey: {
+      type: "writable",
+      variableType: "array",
+      valueProp: "activeKey",
+      onChangeProp: "onChange"
+    }
+  },
+  importPath: "@daouypkgs/antd/skinny/registerCollapse",
+  importName: "Collapse"
+};
+function Collapse(props) {
+  const _a = props, { openIcon, closeIcon } = _a, rest = __objRest$3(_a, ["openIcon", "closeIcon"]);
+  return /* @__PURE__ */ React__default.default.createElement(
+    antd.Collapse,
+    __spreadProps$3(__spreadValues$5({}, rest), {
+      expandIcon: openIcon || closeIcon ? ({ isActive }) => isActive ? openIcon : closeIcon : void 0
+    })
+  );
+}
+function registerCollapse(loader, customCollapseMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(Collapse, customCollapseMeta != null ? customCollapseMeta : collapsteMeta);
+}
+
+var __defProp$4 = Object.defineProperty;
+var __getOwnPropSymbols$4 = Object.getOwnPropertySymbols;
+var __hasOwnProp$4 = Object.prototype.hasOwnProperty;
+var __propIsEnum$4 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$4 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$4.call(b, prop))
+      __defNormalProp$4(a, prop, b[prop]);
+  if (__getOwnPropSymbols$4)
+    for (var prop of __getOwnPropSymbols$4(b)) {
+      if (__propIsEnum$4.call(b, prop))
+        __defNormalProp$4(a, prop, b[prop]);
+    }
+  return a;
+};
+const DropdownButton = antd.Dropdown.Button;
+class Dropdown extends React__default.default.Component {
+  render() {
+    const thisProps = this.props;
+    const finalProps = __spreadValues$4({}, thisProps);
+    finalProps.children = typeof thisProps.children === "string" ? /* @__PURE__ */ React__default.default.createElement("div", null, thisProps.children) : thisProps.children;
+    return /* @__PURE__ */ React__default.default.createElement(antd.Dropdown, __spreadValues$4({}, finalProps));
+  }
+}
+const 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 Daouy Editor",
+      editOnly: true,
+      defaultValueHint: false
+    },
+    children: {
+      type: "slot",
+      defaultValue: [
+        {
+          type: "text",
+          value: "Dropdown"
+        }
+      ]
+    }
+  },
+  importPath: "@daouypkgs/antd/skinny/registerDropdown",
+  importName: "Dropdown"
+};
+function registerDropdown(loader, customDropdownMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(Dropdown, customDropdownMeta != null ? customDropdownMeta : dropdownMeta);
+}
+const 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 Daouy Editor",
+      editOnly: true,
+      defaultValueHint: false
+    },
+    children: {
+      type: "slot",
+      defaultValue: [
+        {
+          type: "text",
+          value: "Dropdown"
+        }
+      ]
+    }
+  },
+  importPath: "@daouypkgs/antd/skinny/registerDropdown",
+  importName: "DropdownButton",
+  parentComponentName: "AntdDropdown"
+};
+function registerDropdownButton(loader, customDropdownButtonMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(
+    DropdownButton,
+    customDropdownButtonMeta != null ? customDropdownButtonMeta : dropdownButtonMeta
+  );
+}
+
+var __defProp$3 = Object.defineProperty;
+var __defProps$2 = Object.defineProperties;
+var __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$3 = Object.getOwnPropertySymbols;
+var __hasOwnProp$3 = Object.prototype.hasOwnProperty;
+var __propIsEnum$3 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$3 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$3.call(b, prop))
+      __defNormalProp$3(a, prop, b[prop]);
+  if (__getOwnPropSymbols$3)
+    for (var prop of __getOwnPropSymbols$3(b)) {
+      if (__propIsEnum$3.call(b, prop))
+        __defNormalProp$3(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
+const Input = antd.Input;
+const InputGroup = Input.Group;
+const Password = Input.Password;
+const Search = Input.Search;
+const TextArea = Input.TextArea;
+function sortObjectKeys(obj) {
+  return Object.fromEntries(Object.entries(obj).sort());
+}
+function sortProps(props) {
+  return sortObjectKeys(props);
+}
+const 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"
+  }
+};
+const inputHelpers = {
+  states: {
+    value: {
+      onChangeArgsToValue: (e) => e.target.value
+    }
+  }
+};
+const inputMeta = {
+  name: "AntdInput",
+  displayName: "Antd Input",
+  props: sortProps(__spreadProps$2(__spreadValues$3({}, 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"
+    },
+    onChange: {
+      type: "eventHandler",
+      argTypes: [
+        {
+          name: "event",
+          type: "object"
+        }
+      ]
+    }
+  })),
+  states: {
+    value: {
+      type: "writable",
+      variableType: "text",
+      onChangeProp: "onChange",
+      valueProp: "value"
+    }
+  },
+  componentHelpers: {
+    helpers: inputHelpers,
+    importName: "inputHelpers",
+    importPath: "@daouypkgs/antd/skinny/registerInput"
+  },
+  importPath: "@daouypkgs/antd/skinny/registerInput",
+  importName: "Input"
+};
+function registerInput(loader, customInputMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(Input, customInputMeta != null ? customInputMeta : inputMeta);
+}
+const inputTextAreaMeta = {
+  name: "AntdInputTextArea",
+  displayName: "Antd Input Text Area",
+  props: sortProps(__spreadProps$2(__spreadValues$3({}, 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"
+    },
+    onChange: {
+      type: "eventHandler",
+      argTypes: [
+        {
+          name: "event",
+          type: "object"
+        }
+      ]
+    }
+  })),
+  states: {
+    value: {
+      type: "writable",
+      variableType: "text",
+      onChangeProp: "onChange",
+      valueProp: "value"
+    }
+  },
+  componentHelpers: {
+    helpers: inputHelpers,
+    importName: "inputHelpers",
+    importPath: "@daouypkgs/antd/skinny/registerInput"
+  },
+  importPath: "@daouypkgs/antd/skinny/registerInput",
+  importName: "TextArea",
+  parentComponentName: "AntdInput"
+};
+function registerInputTextArea(loader, customInputTextAreaMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(TextArea, customInputTextAreaMeta != null ? customInputTextAreaMeta : inputTextAreaMeta);
+}
+const inputSearchMeta = {
+  name: "AntdInputSearch",
+  displayName: "Antd Input Search",
+  props: sortProps(__spreadProps$2(__spreadValues$3({}, 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"
+    },
+    onChange: {
+      type: "eventHandler",
+      argTypes: [
+        {
+          name: "event",
+          type: "object"
+        }
+      ]
+    }
+  })),
+  states: {
+    value: {
+      type: "writable",
+      variableType: "text",
+      onChangeProp: "onChange",
+      valueProp: "value"
+    }
+  },
+  componentHelpers: {
+    helpers: inputHelpers,
+    importName: "inputHelpers",
+    importPath: "@daouypkgs/antd/skinny/registerInput"
+  },
+  importPath: "@daouypkgs/antd/skinny/registerInput",
+  importName: "Search",
+  parentComponentName: "AntdInput"
+};
+function registerInputSearch(loader, customInputSearchMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(Search, customInputSearchMeta != null ? customInputSearchMeta : inputSearchMeta);
+}
+const inputPasswordMeta = {
+  name: "AntdInputPassword",
+  displayName: "Antd Input Password",
+  props: sortProps(__spreadProps$2(__spreadValues$3({}, 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"
+    },
+    visibilityToggle: {
+      type: "boolean",
+      description: "Whether show toggle button",
+      defaultValueHint: true
+    },
+    onChange: {
+      type: "eventHandler",
+      argTypes: [
+        {
+          name: "event",
+          type: "object"
+        }
+      ]
+    }
+  })),
+  states: {
+    value: {
+      type: "writable",
+      variableType: "text",
+      onChangeProp: "onChange",
+      valueProp: "value"
+    }
+  },
+  componentHelpers: {
+    helpers: inputHelpers,
+    importName: "inputHelpers",
+    importPath: "@daouypkgs/antd/skinny/registerInput"
+  },
+  importPath: "@daouypkgs/antd/skinny/registerInput",
+  importName: "Password",
+  parentComponentName: "AntdInput"
+};
+function registerInputPassword(loader, customInputPasswordMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(Password, customInputPasswordMeta != null ? customInputPasswordMeta : inputPasswordMeta);
+}
+const 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: "@daouypkgs/antd/skinny/registerInput",
+  importName: "InputGroup",
+  parentComponentName: "AntdInput"
+};
+function registerInputGroup(loader, customInputGroupMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(InputGroup, customInputGroupMeta != null ? customInputGroupMeta : inputGroupMeta);
+}
+
+const Menu = antd.Menu;
+const MenuDivider = Menu.Divider;
+const MenuItemGroup = Menu.ItemGroup;
+const MenuItem = Menu.Item;
+const SubMenu = Menu.SubMenu;
+const menuDividerMeta = {
+  name: "AntdMenuDivider",
+  displayName: "Antd Menu Divider",
+  props: {
+    dashed: {
+      type: "boolean",
+      description: "Whether line is dashed",
+      defaultValueHint: false
+    }
+  },
+  importPath: "@daouypkgs/antd/skinny/registerMenu",
+  importName: "MenuDivider",
+  parentComponentName: "AntdMenu"
+};
+function registerMenuDivider(loader, customMenuDividerMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(MenuDivider, customMenuDividerMeta != null ? customMenuDividerMeta : menuDividerMeta);
+}
+const 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: "@daouypkgs/antd/skinny/registerMenu",
+  importName: "MenuItem",
+  parentComponentName: "AntdMenu"
+};
+function registerMenuItem(loader, customMenuItemMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(MenuItem, customMenuItemMeta != null ? customMenuItemMeta : menuItemMeta);
+}
+const 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: "@daouypkgs/antd/skinny/registerMenu",
+  importName: "MenuItemGroup",
+  parentComponentName: "AntdMenu"
+};
+function registerMenuItemGroup(loader, customMenuItemGroupMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(
+    MenuItemGroup,
+    customMenuItemGroupMeta != null ? customMenuItemGroupMeta : menuItemGroupMeta
+  );
+}
+const 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: [1, 2].map((i) => ({
+        type: "component",
+        name: "AntdMenuItem",
+        props: {
+          key: `subMenuItemKey${i}`,
+          children: [
+            {
+              type: "text",
+              value: `Sub-menu item ${i}`
+            }
+          ]
+        }
+      }))
+    }
+  },
+  importPath: "@daouypkgs/antd/skinny/registerMenu",
+  importName: "SubMenu",
+  parentComponentName: "AntdMenu"
+};
+function registerSubMenu(loader, customSubMenuMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(SubMenu, customSubMenuMeta != null ? customSubMenuMeta : subMenuMeta);
+}
+function getOpenKeysOptions(componentProps) {
+  const options = /* @__PURE__ */ new Set();
+  traverseReactEltTree(componentProps.children, (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());
+}
+const 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,
+      description: "Array with the keys of default opened sub menus",
+      multiSelect: true,
+      options: getOpenKeysOptions
+    },
+    onOpenChange: {
+      type: "eventHandler",
+      argTypes: [
+        {
+          name: "openKeys",
+          type: {
+            type: "choice",
+            multiSelect: true,
+            options: getOpenKeysOptions
+          }
+        }
+      ]
+    },
+    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: (componentProps) => {
+        const options = /* @__PURE__ */ new Set();
+        traverseReactEltTree(componentProps.children, (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"
+        }
+      ]
+    }
+  },
+  states: {
+    openKeys: {
+      type: "writable",
+      variableType: "array",
+      valueProp: "openKeys",
+      onChangeProp: "onOpenChange"
+    }
+  },
+  importPath: "@daouypkgs/antd/skinny/registerMenu",
+  importName: "Menu"
+};
+function registerMenu(loader, customMenuMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(Menu, customMenuMeta != null ? customMenuMeta : menuMeta);
+}
+
+const Option$1 = antd.Select.Option;
+const OptGroup = antd.Select.OptGroup;
+const 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: "@daouypkgs/antd/skinny/registerOption",
+  importName: "Option",
+  parentComponentName: "AntdSelect"
+};
+function registerOption(loader, customOptionMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(Option$1, customOptionMeta != null ? customOptionMeta : optionMeta);
+}
+const 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: "@daouypkgs/antd/skinny/registerOption",
+  importName: "OptGroup",
+  parentComponentName: "AntdSelect"
+};
+function registerOptGroup(loader, customOptGroupMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(OptGroup, customOptGroupMeta != null ? customOptGroupMeta : optGroupMeta);
+}
+
+const Rate = antd.Rate;
+const 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,
+      defaultValueHint: 0
+    },
+    onChange: {
+      type: "eventHandler",
+      argTypes: [
+        {
+          name: "value",
+          type: "number"
+        }
+      ]
+    },
+    character: {
+      type: "slot",
+      hidePlaceholder: true
+    }
+  },
+  states: {
+    value: {
+      type: "writable",
+      variableType: "text",
+      onChangeProp: "onChange",
+      valueProp: "value"
+    }
+  },
+  importPath: "@daouypkgs/antd/skinny/registerRate",
+  importName: "Rate"
+};
+function registerRate(loader, customRateMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(Rate, customRateMeta != null ? customRateMeta : rateMeta);
+}
+
+const Select = antd.Select;
+const Option = Select.Option;
+const 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: (props) => 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,
+      description: "Initial open state of dropdown",
+      defaultValueHint: false
+    },
+    onDropdownVisibleChange: {
+      type: "eventHandler",
+      argTypes: [
+        {
+          name: "open",
+          type: "boolean"
+        }
+      ]
+    },
+    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",
+      description: "Initial selected option",
+      options: (componentProps) => {
+        const options = /* @__PURE__ */ new Set();
+        traverseReactEltTree(componentProps.children, (elt) => {
+          var _a;
+          if ((elt == null ? void 0 : elt.type) === Option && typeof ((_a = elt == null ? void 0 : elt.props) == null ? void 0 : _a.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"
+            }
+          }
+        }
+      ]
+    },
+    onChange: {
+      type: "eventHandler",
+      argTypes: [
+        {
+          name: "value",
+          type: "string"
+        },
+        {
+          name: "option",
+          type: "object"
+        }
+      ]
+    }
+  },
+  states: {
+    value: {
+      type: "writable",
+      variableType: "text",
+      onChangeProp: "onChange",
+      valueProp: "value"
+    },
+    open: {
+      type: "writable",
+      variableType: "boolean",
+      onChangeProp: "onDropdownVisibleChange",
+      valueProp: "open"
+    }
+  },
+  importPath: "@daouypkgs/antd/skinny/registerSelect",
+  importName: "Select"
+};
+function registerSelect(loader, customSelectMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(Select, customSelectMeta != null ? customSelectMeta : selectMeta);
+}
+
+var __defProp$2 = Object.defineProperty;
+var __defProps$1 = Object.defineProperties;
+var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
+var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
+var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$2 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$2.call(b, prop))
+      __defNormalProp$2(a, prop, b[prop]);
+  if (__getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(b)) {
+      if (__propIsEnum$2.call(b, prop))
+        __defNormalProp$2(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
+var __objRest$2 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$2.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$2.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+const Slider = React__default.default.forwardRef(function Slider2(_a, ref) {
+  var _b = _a, { value, value2, onChange, onChange2 } = _b, props = __objRest$2(_b, ["value", "value2", "onChange", "onChange2"]);
+  const newProps = __spreadValues$2({}, props);
+  if (props.range) {
+    if (typeof value === "number" || typeof value2 === "number") {
+      newProps.value = [value != null ? value : 0, value2 != null ? value2 : 0];
+    }
+    newProps.onChange = (values) => {
+      onChange(values[0]);
+      onChange2(values[1]);
+    };
+  } else {
+    if (typeof value === "number") {
+      newProps.value = value;
+    }
+    newProps.onChange = onChange;
+  }
+  return /* @__PURE__ */ React__default.default.createElement(antd.Slider, __spreadProps$1(__spreadValues$2({}, newProps), { ref }));
+});
+const 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",
+      displayName: "Value",
+      editOnly: true,
+      description: "Initial value for the slider"
+    },
+    onChange: {
+      type: "eventHandler",
+      argTypes: [{ name: "value", type: "number" }]
+    },
+    value2: {
+      type: "number",
+      displayName: "Second Value",
+      editOnly: true,
+      description: "Initial second value for the slider",
+      hidden: (props) => !props.range
+    },
+    onChange2: {
+      type: "eventHandler",
+      argTypes: [{ name: "value", type: "number" }],
+      hidden: (props) => !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"
+    }
+  },
+  states: {
+    value: {
+      type: "writable",
+      variableType: "number",
+      valueProp: "value",
+      onChangeProp: "onChange"
+    },
+    value2: {
+      type: "writable",
+      variableType: "number",
+      valueProp: "value2",
+      onChangeProp: "onChange2"
+    }
+  },
+  defaultStyles: {
+    width: "200px",
+    maxWidth: "100%"
+  },
+  importPath: "@daouypkgs/antd/skinny/registerSlider",
+  importName: "Slider"
+};
+function registerSlider(loader, customSliderMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(Slider, customSliderMeta != null ? customSliderMeta : sliderMeta);
+}
+
+const Switch = antd.Switch;
+const switchMeta = {
+  name: "AntdSwitch",
+  displayName: "Antd Switch",
+  props: {
+    autoFocus: {
+      type: "boolean",
+      description: "Whether get focus when component mounted",
+      defaultValueHint: false
+    },
+    checked: {
+      type: "boolean",
+      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"
+    },
+    onChange: {
+      type: "eventHandler",
+      argTypes: [
+        {
+          name: "checked",
+          type: "boolean"
+        },
+        {
+          name: "event",
+          type: "object"
+        }
+      ]
+    }
+  },
+  states: {
+    value: {
+      type: "writable",
+      variableType: "boolean",
+      onChangeProp: "onChange",
+      valueProp: "checked"
+    }
+  },
+  importPath: "@daouypkgs/antd/skinny/registerSwitch",
+  importName: "Switch"
+};
+function registerSwitch(loader, customSwitchMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(Switch, customSwitchMeta != null ? customSwitchMeta : switchMeta);
+}
+
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
+var __objRest$1 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$1.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$1.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+function TableColumn(_props) {
+  return null;
+}
+function TableValue(props) {
+  var _a;
+  const { className } = props;
+  const column = host.useSelector("currentColumn");
+  return /* @__PURE__ */ React__default.default.createElement("div", { className }, (_a = column == null ? void 0 : column.toString()) != null ? _a : "");
+}
+function ColumnWrapper(props) {
+  return props.children;
+}
+function TableWrapper(props) {
+  var _a, _b;
+  const { className, items, columns, size, onSelect, pagination } = props;
+  const tableColumns = (_b = (_a = columns == null ? void 0 : columns.props) == null ? void 0 : _a.children) != null ? _b : columns;
+  const columnDefinitions = React__default.default.useMemo(() => {
+    return React__default.default.Children.map(
+      tableColumns,
+      (column, columnIndex) => {
+        if (!column) {
+          return void 0;
+        }
+        const _a2 = column.props, { columnTemplate, title, dataIndex } = _a2, rest = __objRest$1(_a2, ["columnTemplate", "title", "dataIndex"]);
+        const columnDefinition = {
+          columnIndex,
+          title,
+          dataIndex,
+          key: columnIndex,
+          render: (value, record, rowIndex) => {
+            return /* @__PURE__ */ React__default.default.createElement(host.DataProvider, { name: "currentRow", data: record }, /* @__PURE__ */ React__default.default.createElement(host.DataProvider, { name: "currentRowIndex", data: rowIndex }, /* @__PURE__ */ React__default.default.createElement(host.DataProvider, { name: "currentColumn", data: value }, host.repeatedElement(
+              rowIndex,
+              /* @__PURE__ */ React__default.default.createElement(ColumnWrapper, __spreadValues$1({}, rest), columnTemplate)
+            ))));
+          }
+        };
+        return columnDefinition;
+      }
+    ).filter(Boolean);
+  }, [tableColumns]);
+  return /* @__PURE__ */ React__default.default.createElement(
+    antd.Table,
+    {
+      className,
+      columns: columnDefinitions,
+      dataSource: items,
+      size,
+      onRow: (record) => {
+        return {
+          onMouseUp: () => {
+            return onSelect == null ? void 0 : onSelect(record.id);
+          }
+        };
+      },
+      pagination: pagination ? void 0 : pagination,
+      rowKey: "id"
+    }
+  );
+}
+const 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);
+}
+const 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: Object.keys(DEFAULT_ITEMS[0]).map((columnName) => ({
+        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: "@daouypkgs/antd/skinny/registerTable",
+  importName: "TableWrapper"
+};
+const 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: "@daouypkgs/antd/skinny/registerTable",
+  importName: "TableColumn"
+};
+const tableValueMeta = {
+  name: "AntdTableValue",
+  parentComponentName: "AntdTableColumn",
+  props: {},
+  importPath: "@daouypkgs/antd/skinny/registerTable",
+  importName: "TableValue"
+};
+function registerTable(loader, customMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : host.registerComponent(...args);
+  doRegisterComponent(TableWrapper, customMeta != null ? customMeta : tableMeta);
+}
+function registerTableColumn(loader, customMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : host.registerComponent(...args);
+  doRegisterComponent(TableColumn, customMeta != null ? customMeta : tableColumnMeta);
+}
+function registerTableValue(loader, customMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : host.registerComponent(...args);
+  doRegisterComponent(TableValue, customMeta != null ? customMeta : tableValueMeta);
+}
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+const TabPane = antd.Tabs.TabPane;
+const 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: "@daouypkgs/antd/skinny/registerTabs",
+  importName: "TabPane"
+};
+function registerTabPane(loader, customTabPaneMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  doRegisterComponent(TabPane, customTabPaneMeta != null ? customTabPaneMeta : tabPaneMeta);
+}
+function Tabs(props) {
+  const _a = props, { leftTabBarExtraContent, rightTabBarExtraContent } = _a, otherProps = __objRest(_a, ["leftTabBarExtraContent", "rightTabBarExtraContent"]);
+  return /* @__PURE__ */ React__default.default.createElement(
+    antd.Tabs,
+    __spreadProps(__spreadValues({}, otherProps), {
+      tabBarExtraContent: {
+        left: leftTabBarExtraContent,
+        right: rightTabBarExtraContent
+      }
+    })
+  );
+}
+function NavigateTabs({ componentProps, studioOps }) {
+  const tabPanes = [];
+  traverseReactEltTree(componentProps.children, (elt) => {
+    if ((elt == null ? void 0 : elt.type) === TabPane && typeof (elt == null ? void 0 : elt.key) === "string") {
+      tabPanes.push(elt.key);
+    }
+  });
+  const activeKey = componentProps.activeKey;
+  const currTabPos = activeKey ? tabPanes.findIndex((tabKey) => {
+    return tabKey === activeKey;
+  }) : 0;
+  return /* @__PURE__ */ React__default.default.createElement(
+    "div",
+    {
+      style: {
+        width: "100%",
+        display: "flex",
+        flexDirection: "row",
+        gap: "10px",
+        justifyContent: "space-between"
+      }
+    },
+    /* @__PURE__ */ React__default.default.createElement(
+      antd.Button,
+      {
+        style: { width: "100%" },
+        onClick: () => {
+          if (tabPanes.length > 0) {
+            const prevTabPos = (currTabPos - 1 + tabPanes.length) % tabPanes.length;
+            studioOps.updateProps({ activeKey: tabPanes[prevTabPos] });
+          }
+        }
+      },
+      "Prev tab"
+    ),
+    /* @__PURE__ */ React__default.default.createElement(
+      antd.Button,
+      {
+        style: { width: "100%" },
+        onClick: () => {
+          if (tabPanes.length > 0) {
+            const nextTabPos = (currTabPos + 1) % tabPanes.length;
+            studioOps.updateProps({ activeKey: tabPanes[nextTabPos] });
+          }
+        }
+      },
+      "Next tab"
+    )
+  );
+}
+function OutlineMessage() {
+  return /* @__PURE__ */ React__default.default.createElement("div", null, "* To re-arrange tab panes, use the Outline panel");
+}
+function getActiveKeyOptions(props) {
+  const options = /* @__PURE__ */ new Set();
+  traverseReactEltTree(props.children, (elt) => {
+    if ((elt == null ? void 0 : elt.type) === TabPane && typeof (elt == null ? void 0 : elt.key) === "string") {
+      options.add(elt.key);
+    }
+  });
+  return Array.from(options.keys());
+}
+const 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: (props) => 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: (props) => 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,
+      description: "Initial active TabPane's key",
+      options: getActiveKeyOptions
+    },
+    onChange: {
+      type: "eventHandler",
+      argTypes: [
+        {
+          name: "activeKey",
+          type: {
+            type: "choice",
+            options: getActiveKeyOptions
+          }
+        }
+      ]
+    },
+    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"
+              }
+            ]
+          }
+        }
+      ]
+    }
+  },
+  states: {
+    activeKey: {
+      type: "writable",
+      variableType: "array",
+      valueProp: "activeKey",
+      onChangeProp: "onChange"
+    }
+  },
+  actions: [
+    {
+      type: "custom-action",
+      control: NavigateTabs
+    },
+    {
+      type: "button-action",
+      label: "Add new tab",
+      onClick: ({ componentProps, studioOps }) => {
+        const generateNewKey = () => {
+          const keysSet = /* @__PURE__ */ new Set();
+          traverseReactEltTree(componentProps.children, (elt) => {
+            if ((elt == null ? void 0 : elt.type) === TabPane && typeof (elt == null ? void 0 : elt.key) === "string") {
+              keysSet.add(elt.key);
+            }
+          });
+          for (let keyCandidate = 1; keyCandidate <= keysSet.size + 1; keyCandidate++) {
+            const strKey = keyCandidate.toString();
+            if (!keysSet.has(strKey)) {
+              return strKey;
+            }
+          }
+          return void 0;
+        };
+        const tabKey = generateNewKey();
+        studioOps.appendToSlot(
+          {
+            type: "component",
+            name: "AntdTabPane",
+            props: {
+              key: tabKey
+            }
+          },
+          "children"
+        );
+        studioOps.updateProps({ activeKey: tabKey });
+      }
+    },
+    {
+      type: "button-action",
+      label: "Delete current tab",
+      onClick: ({ componentProps, studioOps }) => {
+        if (componentProps.activeKey) {
+          const tabPanes = [];
+          traverseReactEltTree(componentProps.children, (elt) => {
+            if ((elt == null ? void 0 : elt.type) === TabPane && typeof (elt == null ? void 0 : elt.key) === "string") {
+              tabPanes.push(elt.key);
+            }
+          });
+          const activeKey = componentProps.activeKey;
+          const currTabPos = tabPanes.findIndex((tabKey) => {
+            return tabKey === activeKey;
+          });
+          if (currTabPos !== -1) {
+            studioOps.removeFromSlotAt(currTabPos, "children");
+            if (tabPanes.length - 1 > 0) {
+              const prevTabPos = (currTabPos - 1 + tabPanes.length) % tabPanes.length;
+              studioOps.updateProps({ activeKey: tabPanes[prevTabPos] });
+            }
+          }
+        }
+      }
+    },
+    {
+      type: "custom-action",
+      control: OutlineMessage
+    }
+  ],
+  importPath: "@daouypkgs/antd/skinny/registerTabs",
+  importName: "Tabs"
+};
+function registerTabs(loader, customTabsMeta) {
+  const doRegisterComponent = (...args) => loader ? loader.registerComponent(...args) : registerComponent__default.default(...args);
+  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.Button = Button;
+exports.Carousel = Carousel;
+exports.Checkbox = Checkbox;
+exports.CheckboxGroup = CheckboxGroup;
+exports.Collapse = Collapse;
+exports.CollapsePanel = CollapsePanel;
+exports.Dropdown = Dropdown;
+exports.DropdownButton = DropdownButton;
+exports.Input = Input;
+exports.InputGroup = InputGroup;
+exports.Menu = Menu;
+exports.MenuDivider = MenuDivider;
+exports.MenuItem = MenuItem;
+exports.MenuItemGroup = MenuItemGroup;
+exports.OptGroup = OptGroup;
+exports.Option = Option$1;
+exports.Password = Password;
+exports.Rate = Rate;
+exports.Search = Search;
+exports.Select = Select;
+exports.Slider = Slider;
+exports.SubMenu = SubMenu;
+exports.Switch = Switch;
+exports.TabPane = TabPane;
+exports.Tabs = Tabs;
+exports.TextArea = TextArea;
+exports.buttonMeta = buttonMeta;
+exports.carouselMeta = carouselMeta;
+exports.checkboxGroupMeta = checkboxGroupMeta;
+exports.checkboxHelpers = checkboxHelpers;
+exports.checkboxMeta = checkboxMeta;
+exports.collapsteMeta = collapsteMeta;
+exports.collapstePanelMeta = collapstePanelMeta;
+exports.dropdownButtonMeta = dropdownButtonMeta;
+exports.dropdownMeta = dropdownMeta;
+exports.inputGroupMeta = inputGroupMeta;
+exports.inputHelpers = inputHelpers;
+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=index.js.map