@pisell/materials 1.0.1 → 1.0.3

package/lib/components/dropdown/index.js

@@ -0,0 +1,45 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/dropdown/index.tsx
+var dropdown_exports = {};
+__export(dropdown_exports, {
+  default: () => dropdown_default
+});
+module.exports = __toCommonJS(dropdown_exports);
+var import_react = __toESM(require("react"));
+var import_antd = require("antd");
+var import_hoc = require("../../utils/hoc");
+var Dropdown = (props) => {
+  const innerProps = {};
+  if (props.__designMode === "design") {
+    innerProps.open = true;
+  }
+  return /* @__PURE__ */ import_react.default.createElement(import_antd.Dropdown, { ...props, ...innerProps });
+};
+var dropdown_default = (0, import_hoc.withSingleChild)(Dropdown, ["children", "overlay"]);

package/lib/components/form/index.d.ts

@@ -0,0 +1,8 @@
+import React, { Component } from 'react';
+declare class Form extends Component<any, any> {
+    formRef: React.RefObject<any>;
+    componentDidUpdate(prevProps: any): void;
+    componentDidMount(): void;
+    render(): JSX.Element;
+}
+export default Form;

package/lib/components/form/index.js

@@ -0,0 +1,114 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/form/index.tsx
+var form_exports = {};
+__export(form_exports, {
+  default: () => form_default
+});
+module.exports = __toCommonJS(form_exports);
+var import_react = __toESM(require("react"));
+var import_antd = require("antd");
+var import_hoc = require("../../utils/hoc");
+var Form = class extends import_react.Component {
+  constructor() {
+    super(...arguments);
+    this.formRef = (0, import_react.createRef)();
+  }
+  componentDidUpdate(prevProps) {
+    const { values: prevValues } = prevProps;
+    const { values: currentValues } = this.props;
+    if (prevValues !== currentValues) {
+      if (currentValues && Object.keys(currentValues).length > 0) {
+        this.formRef.current.setFieldsValue(currentValues);
+      } else {
+        this.formRef.current.resetFields();
+      }
+    }
+  }
+  componentDidMount() {
+    const { values } = this.props;
+    Object.defineProperties(
+      this,
+      Object.keys(this.formRef.current).reduce((out, key) => {
+        const property = this.formRef.current[key];
+        let getter = () => property;
+        if (typeof property === "function") {
+          getter = () => property.bind(this.formRef.current);
+        }
+        out[key] = { get: getter };
+        return out;
+      }, {})
+    );
+    if (values) {
+      this.formRef.current.setFieldsValue(values);
+    }
+  }
+  render() {
+    const { values, ...rest } = this.props;
+    return /* @__PURE__ */ import_react.default.createElement(import_antd.Form, { ref: this.formRef, ...rest });
+  }
+};
+Form.Item = (props) => {
+  const { name, requiredobj, typeobj, patternobj, lenobj, validator } = props;
+  const rules = [];
+  if (requiredobj && requiredobj.required) {
+    rules.push(requiredobj);
+  }
+  if (typeobj && typeobj.type) {
+    rules.push(typeobj);
+  }
+  if (patternobj && patternobj.pattern) {
+    rules.push(patternobj);
+  }
+  if (lenobj && (lenobj.max || lenobj.min)) {
+    rules.push(lenobj);
+  }
+  if (validator && typeof validator === "function") {
+    rules.push({
+      validator: (_, value) => validator(value)
+    });
+  }
+  const namePath = typeof name === "string" && name.indexOf(".") > 0 ? name.split(".") : name;
+  const { children, ...other } = props;
+  let node = children;
+  if (Array.isArray(children) && children.length === 1) {
+    node = children[0];
+  }
+  return /* @__PURE__ */ import_react.default.createElement(
+    import_antd.Form.Item,
+    {
+      ...other,
+      name: namePath,
+      rules
+    },
+    node
+  );
+};
+Form.List = (0, import_hoc.withSingleFunctionChild)(import_antd.Form.List);
+var form_default = Form;

package/lib/components/icon/index.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+interface IconProps {
+    type: string;
+    className?: string;
+    size?: number;
+    color?: string;
+    rotate?: number;
+    spin?: boolean;
+    style?: React.CSSProperties;
+}
+declare const _default: React.ForwardRefExoticComponent<IconProps & React.RefAttributes<any>>;
+export default _default;

package/lib/components/icon/index.js

@@ -0,0 +1,52 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/icon/index.tsx
+var icon_exports = {};
+__export(icon_exports, {
+  default: () => icon_default
+});
+module.exports = __toCommonJS(icon_exports);
+var import_react = __toESM(require("react"));
+var icons = __toESM(require("@ant-design/icons"));
+var createFromIconfontCN2 = icons.createFromIconfontCN;
+var Icon = (props, ref) => {
+  const { type = "", size, color, ...rest } = props;
+  const IconComp = (icons || {})[type];
+  const style = {
+    ...rest.style,
+    fontSize: size,
+    color
+  };
+  if (!IconComp) {
+    const IconFont = createFromIconfontCN2();
+    return /* @__PURE__ */ import_react.default.createElement(IconFont, { type, ...rest, style, ref });
+  }
+  return /* @__PURE__ */ import_react.default.createElement(IconComp, { ...rest, style, twoToneColor: color, ref });
+};
+var icon_default = (0, import_react.forwardRef)(Icon);

package/lib/components/input/index.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const Input: import("react").ForwardRefExoticComponent<Omit<any, "ref"> & import("react").RefAttributes<any>>;
+export default Input;

package/lib/components/input/index.js

@@ -0,0 +1,38 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/input/index.tsx
+var input_exports = {};
+__export(input_exports, {
+  default: () => input_default
+});
+module.exports = __toCommonJS(input_exports);
+var import_antd = require("antd");
+var import_hoc = require("../../utils/hoc");
+var {
+  Group: OriginalGroup,
+  TextArea: OriginalTextArea,
+  Password: OriginalPassword,
+  Search: OriginalSearch
+} = import_antd.Input;
+var Input = (0, import_hoc.withWrap)(import_antd.Input);
+Input.Group = OriginalGroup;
+Input.TextArea = (0, import_hoc.withWrap)(OriginalTextArea);
+Input.Password = (0, import_hoc.withWrap)(OriginalPassword);
+Input.Search = (0, import_hoc.withWrap)(OriginalSearch);
+var input_default = Input;

package/lib/components/modal/index.d.ts

@@ -0,0 +1,2 @@
+declare const Modal: any;
+export default Modal;

package/lib/components/modal/index.js

@@ -0,0 +1,50 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/modal/index.tsx
+var modal_exports = {};
+__export(modal_exports, {
+  default: () => modal_default
+});
+module.exports = __toCommonJS(modal_exports);
+var import_react = __toESM(require("react"));
+var import_antd = require("antd");
+var Modal = (props) => {
+  const innerProps = {};
+  if (props.__designMode === "design") {
+    innerProps.open = true;
+  }
+  return /* @__PURE__ */ import_react.default.createElement(import_antd.Modal, { ...props, ...innerProps });
+};
+Modal.info = import_antd.Modal.info;
+Modal.success = import_antd.Modal.success;
+Modal.error = import_antd.Modal.error;
+Modal.warning = import_antd.Modal.warning;
+Modal.warn = import_antd.Modal.warn;
+Modal.confirm = import_antd.Modal.confirm;
+var modal_default = Modal;

package/lib/components/radio/index.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const Radio: import("react").ForwardRefExoticComponent<Omit<any, "ref"> & import("react").RefAttributes<any>>;
+export default Radio;

package/lib/components/radio/index.js

@@ -0,0 +1,29 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/radio/index.tsx
+var radio_exports = {};
+__export(radio_exports, {
+  default: () => radio_default
+});
+module.exports = __toCommonJS(radio_exports);
+var import_antd = require("antd");
+var import_hoc = require("../../utils/hoc");
+var Radio = (0, import_hoc.withWrap)(import_antd.Radio);
+Radio.Group = import_antd.Radio.Group;
+var radio_default = Radio;

package/lib/components/select/index.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const Select: import("react").ForwardRefExoticComponent<Omit<any, "ref"> & import("react").RefAttributes<any>>;
+export default Select;

package/lib/components/select/index.js

@@ -0,0 +1,28 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/select/index.tsx
+var select_exports = {};
+__export(select_exports, {
+  default: () => select_default
+});
+module.exports = __toCommonJS(select_exports);
+var import_antd = require("antd");
+var import_hoc = require("../../utils/hoc");
+var Select = (0, import_hoc.withWrap)(import_antd.Select);
+var select_default = Select;

package/lib/components/skeleton/index.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const Skeleton: (props: any) => JSX.Element;
+export default Skeleton;

package/lib/components/skeleton/index.js

@@ -0,0 +1,29 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/skeleton/index.tsx
+var skeleton_exports = {};
+__export(skeleton_exports, {
+  default: () => skeleton_default
+});
+module.exports = __toCommonJS(skeleton_exports);
+var import_antd = require("antd");
+var import_hoc = require("../../utils/hoc");
+console.log(import_antd.Skeleton, "OriginalSleleton");
+var Skeleton = (0, import_hoc.withSingleChild)(import_antd.Skeleton, ["children"]);
+var skeleton_default = Skeleton;

package/lib/components/slider/index.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const SliderOuter: (props: any) => JSX.Element;
+export default SliderOuter;

package/lib/components/slider/index.js

@@ -0,0 +1,47 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/slider/index.tsx
+var slider_exports = {};
+__export(slider_exports, {
+  default: () => slider_default
+});
+module.exports = __toCommonJS(slider_exports);
+var import_react = __toESM(require("react"));
+var import_antd = require("antd");
+var SliderOuter = (props) => {
+  const { range } = props;
+  let { defaultValue } = props;
+  if (range) {
+    defaultValue = Array.isArray(defaultValue) ? defaultValue : [0, defaultValue];
+  } else {
+    defaultValue = Array.isArray(defaultValue) ? defaultValue[1] || defaultValue[0] : defaultValue;
+  }
+  return /* @__PURE__ */ import_react.default.createElement(import_antd.Slider, { ...props, defaultValue });
+};
+var slider_default = SliderOuter;

package/lib/components/table/index.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const Table: (props: any) => JSX.Element;
+export default Table;

package/lib/components/table/index.js

@@ -0,0 +1,41 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/table/index.tsx
+var table_exports = {};
+__export(table_exports, {
+  default: () => table_default
+});
+module.exports = __toCommonJS(table_exports);
+var import_react = __toESM(require("react"));
+var import_antd = require("antd");
+var Table = (props) => {
+  const columns = (props.columns || []).filter((item) => !(item == null ? void 0 : item.hidden));
+  return /* @__PURE__ */ import_react.default.createElement(import_antd.Table, { ...props, columns });
+};
+var table_default = Table;

package/lib/components/tabs/index.d.ts

@@ -0,0 +1,11 @@
+import { Component } from 'react';
+declare class Tabs extends Component<any> {
+    state: {
+        activeKey: any;
+    };
+    private _handleChange;
+    setActiveKey: (key: string) => void;
+    getActiveKey: () => any;
+    render(): JSX.Element;
+}
+export default Tabs;

package/lib/components/tabs/index.js

@@ -0,0 +1,92 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/tabs/index.tsx
+var tabs_exports = {};
+__export(tabs_exports, {
+  default: () => tabs_default
+});
+module.exports = __toCommonJS(tabs_exports);
+var import_react = __toESM(require("react"));
+var import_antd = require("antd");
+var import_warning = require("../../utils/warning");
+var Tabs = class extends import_react.Component {
+  constructor() {
+    super(...arguments);
+    this.state = {
+      activeKey: this.props.activeKey ?? this.props.defaultActiveKey
+    };
+    this._handleChange = (key) => {
+      this.setActiveKey(key);
+    };
+    // 编辑器里可以通过 this.$(refId).setActiveKey(key) 调用
+    this.setActiveKey = (key) => {
+      const { onChange = () => {
+      } } = this.props;
+      this.setState({ activeKey: key });
+      onChange(key);
+    };
+    // 编辑器里可以通过 this.$(refId).getActiveKey() 调用
+    this.getActiveKey = () => {
+      return this.state.activeKey;
+    };
+  }
+  render() {
+    const { props } = this;
+    const { activeKey } = this.state;
+    const { children } = props;
+    let items = props.items;
+    if (!props.items && Array.isArray(children) && children.length > 0) {
+      (0, import_warning.warning)("Tabs.TabPane is deprecated. Please use `items` directly.");
+      items = children.map((node) => {
+        if (import_react.default.isValidElement(node)) {
+          const { key, props: props2 } = node;
+          const { tab, ...restProps } = props2 || {};
+          const item = {
+            key: String(key),
+            ...restProps,
+            label: tab
+          };
+          return item;
+        }
+        return null;
+      }).filter(Boolean);
+    }
+    return /* @__PURE__ */ import_react.default.createElement(
+      import_antd.Tabs,
+      {
+        ...props,
+        items,
+        activeKey,
+        onChange: this._handleChange
+      }
+    );
+  }
+};
+Tabs.TabPane = import_antd.Tabs.TabPane;
+var tabs_default = Tabs;

package/lib/components/time-picker/index.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const TimePicker: (props: any) => JSX.Element;
+export default TimePicker;