@bifrostui/react 2.0.0-alpha.0 → 2.0.0-alpha.1

package/dist/Transition/TransitionCore.js

@@ -92,7 +92,7 @@ const TransitionCore = (0, import_react.forwardRef)(
       enter = true,
       exit = true,
       timeout: _timeout,
-      delay: _delay,
+      delay: _delay = 0,
       onEnter,
       onEntering,
       onEntered,
@@ -130,13 +130,16 @@ const TransitionCore = (0, import_react.forwardRef)(
     });
     const innerNodeRef = (0, import_react.useRef)();
     const nodeRef = (0, import_utils.useForkRef)(innerNodeRef, ref);
-    const timeout = typeof _timeout === "object" ? __spreadValues({}, _timeout) : { enter: _timeout, exit: _timeout };
-    const delay = typeof _delay === "object" ? _delay : { enter: _delay, exit: _delay };
-    timeout.enter += delay.enter;
-    timeout.exit += delay.exit;
+    const timeout = typeof _timeout === "object" ? __spreadValues({}, _timeout) : { enter: _timeout, exit: _timeout, appear: _timeout };
+    const delay = typeof _delay === "object" ? _delay : { enter: _delay, exit: _delay, appear: _delay };
+    if (timeout.enter !== void 0)
+      timeout.enter += delay.enter || 0;
+    if (timeout.exit !== void 0)
+      timeout.exit += delay.exit || 0;
+    if (timeout.appear !== void 0)
+      timeout.appear += delay.appear || 0;
     const nextCallback = (0, import_react.useRef)(null);
     const appearStatus = (0, import_react.useRef)(inProp && appear ? ENTERING : null);
-    const isFirstRender = (0, import_react.useRef)(false);
     const cancelNextCallback = () => {
       var _a2;
       if (nextCallback.current !== null) {
@@ -173,8 +176,8 @@ const TransitionCore = (0, import_react.forwardRef)(
         (_a2 = nextCallback == null ? void 0 : nextCallback.current) == null ? void 0 : _a2.call(nextCallback);
       });
     };
-    const performEnter = () => __async(void 0, null, function* () {
-      if (!enter) {
+    const performEnter = (mounting) => __async(void 0, null, function* () {
+      if (!enter && !mounting) {
         safeSetState(ENTERED, () => __async(void 0, null, function* () {
           yield onEntered == null ? void 0 : onEntered(innerNodeRef == null ? void 0 : innerNodeRef.current);
         }));
@@ -193,7 +196,9 @@ const TransitionCore = (0, import_react.forwardRef)(
     });
     const performExit = () => __async(void 0, null, function* () {
       if (!exit) {
-        safeSetState(unmountOnExit ? UNMOUNTED : EXITED, () => __async(void 0, null, function* () {
+        safeSetState(EXITED, () => __async(void 0, null, function* () {
+          if (unmountOnExit)
+            setStatus(UNMOUNTED);
           yield onExited == null ? void 0 : onExited(innerNodeRef == null ? void 0 : innerNodeRef.current);
         }));
         return;
@@ -202,34 +207,34 @@ const TransitionCore = (0, import_react.forwardRef)(
       safeSetState(EXITING, () => __async(void 0, null, function* () {
         yield onExiting == null ? void 0 : onExiting(innerNodeRef == null ? void 0 : innerNodeRef.current);
         onTransitionEnd(timeout.exit, () => {
-          safeSetState(unmountOnExit ? UNMOUNTED : EXITED, () => __async(void 0, null, function* () {
+          safeSetState(EXITED, () => __async(void 0, null, function* () {
+            if (unmountOnExit)
+              setStatus(UNMOUNTED);
             yield onExited == null ? void 0 : onExited(innerNodeRef == null ? void 0 : innerNodeRef.current);
           }));
         });
       }));
     });
-    const updateStatus = (nextStatus) => {
+    const updateStatus = (nextStatus, mounting) => {
       if (nextStatus !== null) {
         cancelNextCallback();
         if (nextStatus === ENTERING) {
-          performEnter();
+          if (unmountOnExit || mountOnEnter) {
+            forceReflow(innerNodeRef == null ? void 0 : innerNodeRef.current);
+          }
+          performEnter(mounting);
         } else if (nextStatus === EXITING) {
           performExit();
         }
       }
     };
     (0, import_react.useEffect)(() => {
-      nextTick(() => updateStatus(appearStatus.current));
+      nextTick(() => updateStatus(appearStatus.current, true));
       return () => {
         cancelNextCallback();
       };
     }, []);
-    (0, import_react.useEffect)(() => {
-      const isMounted = status !== UNMOUNTED;
-      if (!isFirstRender.current) {
-        isFirstRender.current = true;
-        return;
-      }
+    (0, import_utils.useDidMountEffect)(() => {
       let nextStatus = null;
       if (inProp) {
         if (status !== ENTERING && status !== ENTERED) {
@@ -238,13 +243,13 @@ const TransitionCore = (0, import_react.forwardRef)(
       } else if (status === ENTERING || status === ENTERED) {
         nextStatus = EXITING;
       }
-      if (isMounted)
-        updateStatus(nextStatus);
-      else
-        safeSetState(inProp ? "EXITED" : "ENTERED", () => {
-          forceReflow(innerNodeRef == null ? void 0 : innerNodeRef.current);
-          updateStatus(nextStatus);
+      if (inProp && status === UNMOUNTED) {
+        safeSetState(EXITED, () => {
+          updateStatus(nextStatus, false);
         });
+      } else {
+        updateStatus(nextStatus, false);
+      }
     }, [inProp]);
     if (status === UNMOUNTED)
       return null;

package/dist/TransitionGroup/TransitionGroup.js

@@ -0,0 +1,132 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+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;
+};
+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);
+var TransitionGroup_exports = {};
+__export(TransitionGroup_exports, {
+  default: () => TransitionGroup_default
+});
+module.exports = __toCommonJS(TransitionGroup_exports);
+var import_react = __toESM(require("react"));
+var import_childMapping = require("./utils/childMapping");
+const TransitionGroupContext = import_react.default.createContext(null);
+const values = Object.values || ((obj) => Object.keys(obj).map((k) => obj[k]));
+const TransitionGroup = (props) => {
+  const _a = props, {
+    component: Component = "div",
+    children,
+    appear,
+    enter,
+    exit,
+    childFactory = (child) => child
+  } = _a, restProps = __objRest(_a, [
+    "component",
+    "children",
+    "appear",
+    "enter",
+    "exit",
+    "childFactory"
+  ]);
+  const [state, setState] = (0, import_react.useState)({
+    contextValue: { isMounting: true },
+    firstRender: true,
+    children: {}
+  });
+  const mountedRef = (0, import_react.useRef)(false);
+  const handleExitedRef = (0, import_react.useRef)((child, node) => {
+    const currentChildMapping = (0, import_childMapping.getChildMapping)(children);
+    if (child.key in currentChildMapping)
+      return;
+    if (child.props.onExited) {
+      child.props.onExited(node);
+    }
+    if (mountedRef.current) {
+      setState((prevState) => {
+        const tempChildren = __spreadValues({}, prevState.children);
+        delete tempChildren[child.key];
+        return __spreadProps(__spreadValues({}, prevState), { children: tempChildren });
+      });
+    }
+  });
+  (0, import_react.useEffect)(() => {
+    mountedRef.current = true;
+    setState((prevState) => __spreadProps(__spreadValues({}, prevState), {
+      contextValue: { isMounting: false }
+    }));
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  (0, import_react.useEffect)(() => {
+    setState((prevState) => {
+      const { firstRender, children: prevChildMapping } = prevState;
+      const handleExited = handleExitedRef.current;
+      return __spreadProps(__spreadValues({}, prevState), {
+        children: firstRender ? (0, import_childMapping.getInitialChildMapping)(props, handleExited) : (0, import_childMapping.getNextChildMapping)(props, prevChildMapping, handleExited),
+        firstRender: false
+      });
+    });
+  }, [children, appear, enter, exit]);
+  const { contextValue, children: mappedChildren } = state;
+  const valuedChildren = values(mappedChildren).map(
+    childFactory
+  );
+  if (Component === null) {
+    return /* @__PURE__ */ import_react.default.createElement(TransitionGroupContext.Provider, { value: contextValue }, valuedChildren);
+  }
+  return /* @__PURE__ */ import_react.default.createElement(TransitionGroupContext.Provider, { value: contextValue }, /* @__PURE__ */ import_react.default.createElement(Component, __spreadValues({}, restProps), valuedChildren));
+};
+TransitionGroup.displayName = "BuiTransitionGroup";
+var TransitionGroup_default = TransitionGroup;

package/dist/TransitionGroup/TransitionGroup.types.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+var TransitionGroup_types_exports = {};
+module.exports = __toCommonJS(TransitionGroup_types_exports);

package/dist/TransitionGroup/demo/TransitionGroupDemo.js

@@ -0,0 +1,68 @@
+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);
+var TransitionGroupDemo_exports = {};
+__export(TransitionGroupDemo_exports, {
+  default: () => TransitionGroupDemo_default
+});
+module.exports = __toCommonJS(TransitionGroupDemo_exports);
+var import_react = require("@bifrostui/react");
+var import_react2 = __toESM(require("react"));
+var import_index = require("./index.css");
+const TransitionGroupDemo = () => {
+  const [items, setItems] = (0, import_react2.useState)([
+    { id: 1, text: "Item 1" },
+    { id: 2, text: "Item 2" },
+    { id: 3, text: "Item 3" }
+  ]);
+  const handleAddItem = () => {
+    const id = items.length > 0 ? Math.max(...items.map((item) => item.id)) + 1 : 1;
+    setItems((prev) => [...prev, { id, text: `Item ${id}` }]);
+  };
+  const handleRemoveItem = (id) => {
+    setItems((prev) => prev.filter((item) => item.id !== id));
+  };
+  return /* @__PURE__ */ import_react2.default.createElement("div", null, /* @__PURE__ */ import_react2.default.createElement(import_react.Button, { onClick: handleAddItem }, "\u6DFB\u52A0\u9879\u76EE"), /* @__PURE__ */ import_react2.default.createElement(import_react.TransitionGroup, { className: "transition-group-container" }, items.map((item) => /* @__PURE__ */ import_react2.default.createElement(
+    import_react.CSSTransition,
+    {
+      key: item.id,
+      unmountOnExit: true,
+      timeout: 300,
+      classNames: "item"
+    },
+    /* @__PURE__ */ import_react2.default.createElement("div", { className: "item-container" }, /* @__PURE__ */ import_react2.default.createElement("span", null, item.text), /* @__PURE__ */ import_react2.default.createElement(
+      import_react.Button,
+      {
+        size: "small",
+        color: "danger",
+        onClick: () => handleRemoveItem(item.id)
+      },
+      "\u5220\u9664"
+    ))
+  ))));
+};
+var TransitionGroupDemo_default = TransitionGroupDemo;

package/dist/TransitionGroup/demo/index.css

@@ -0,0 +1,33 @@
+.transition-group-container {
+  margin-top: 10px;
+}
+.transition-group-container .item-container {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 10px;
+  margin-bottom: 10px;
+  background-color: #f5f5f5;
+  border-radius: 4px;
+}
+.transition-group-container .item-enter {
+  opacity: 0;
+  transform: translateX(-100%);
+}
+.transition-group-container .item-enter-active {
+  opacity: 1;
+  transform: translateX(0);
+  transition: all 300ms ease-in;
+}
+.transition-group-container .item-exit {
+  opacity: 1;
+  transform: translateX(0);
+}
+.transition-group-container .item-exit-active {
+  opacity: 0;
+  transform: translateX(-100%);
+  transition: all 300ms ease-in;
+}
+.transition-group-container .bui-btn {
+  margin-bottom: 0;
+}

package/dist/TransitionGroup/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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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);
+var TransitionGroup_exports = {};
+__export(TransitionGroup_exports, {
+  TransitionGroup: () => import_TransitionGroup.default,
+  default: () => import_TransitionGroup.default
+});
+module.exports = __toCommonJS(TransitionGroup_exports);
+var import_TransitionGroup = __toESM(require("./TransitionGroup"));
+__reExport(TransitionGroup_exports, require("./TransitionGroup.types"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TransitionGroup,
+  ...require("./TransitionGroup.types")
+});

package/dist/TransitionGroup/utils/childMapping.js

@@ -0,0 +1,119 @@
+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);
+var childMapping_exports = {};
+__export(childMapping_exports, {
+  getChildMapping: () => getChildMapping,
+  getInitialChildMapping: () => getInitialChildMapping,
+  getNextChildMapping: () => getNextChildMapping,
+  mergeChildMappings: () => mergeChildMappings
+});
+module.exports = __toCommonJS(childMapping_exports);
+var import_react = require("react");
+const getChildMapping = (children, mapFn) => {
+  const mapper = (child) => mapFn && (0, import_react.isValidElement)(child) ? mapFn(child) : child;
+  const result = /* @__PURE__ */ Object.create(null);
+  if (children)
+    import_react.Children.map(children, (c) => c).forEach((child) => {
+      result[child.key] = mapper(child);
+    });
+  return result;
+};
+const mergeChildMappings = (prev, next) => {
+  prev = prev || {};
+  next = next || {};
+  function getValueForKey(key) {
+    return key in next ? next[key] : prev[key];
+  }
+  const nextKeysPending = /* @__PURE__ */ Object.create(null);
+  let pendingKeys = [];
+  Object.keys(prev).forEach((prevKey) => {
+    if (prevKey in next) {
+      if (pendingKeys.length) {
+        nextKeysPending[prevKey] = pendingKeys;
+        pendingKeys = [];
+      }
+    } else {
+      pendingKeys.push(prevKey);
+    }
+  });
+  const childMapping = {};
+  Object.keys(next).forEach((nextKey) => {
+    if (nextKeysPending[nextKey]) {
+      nextKeysPending[nextKey].forEach((pendingNextKey) => {
+        childMapping[pendingNextKey] = getValueForKey(pendingNextKey);
+      });
+    }
+    childMapping[nextKey] = getValueForKey(nextKey);
+  });
+  pendingKeys.forEach((pendingKey) => {
+    childMapping[pendingKey] = getValueForKey(pendingKey);
+  });
+  return childMapping;
+};
+const getProp = (child, prop, props) => {
+  return props[prop] != null ? props[prop] : child.props[prop];
+};
+const getInitialChildMapping = (props, onExited) => {
+  return getChildMapping(props.children, (child) => {
+    return (0, import_react.cloneElement)(child, {
+      onExited: onExited.bind(null, child),
+      in: true,
+      appear: getProp(child, "appear", props),
+      enter: getProp(child, "enter", props),
+      exit: getProp(child, "exit", props)
+    });
+  });
+};
+const getNextChildMapping = (nextProps, prevChildMapping, onExited) => {
+  const nextChildMapping = getChildMapping(nextProps.children);
+  const children = mergeChildMappings(prevChildMapping, nextChildMapping);
+  Object.keys(children).forEach((key) => {
+    const child = children[key];
+    if (!(0, import_react.isValidElement)(child))
+      return;
+    const hasPrev = key in prevChildMapping;
+    const hasNext = key in nextChildMapping;
+    const prevChild = prevChildMapping[key];
+    const isLeaving = (0, import_react.isValidElement)(prevChild) && !prevChild.props.in;
+    if (hasNext && (!hasPrev || isLeaving)) {
+      children[key] = (0, import_react.cloneElement)(child, {
+        onExited: onExited.bind(null, child),
+        in: true,
+        exit: getProp(child, "exit", nextProps),
+        enter: getProp(child, "enter", nextProps)
+      });
+    } else if (!hasNext && hasPrev && !isLeaving) {
+      children[key] = (0, import_react.cloneElement)(child, { in: false });
+    } else if (hasNext && hasPrev && (0, import_react.isValidElement)(prevChild)) {
+      children[key] = (0, import_react.cloneElement)(child, {
+        onExited: onExited.bind(null, child),
+        in: prevChild.props.in,
+        exit: getProp(child, "exit", nextProps),
+        enter: getProp(child, "enter", nextProps)
+      });
+    }
+  });
+  return children;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getChildMapping,
+  getInitialChildMapping,
+  getNextChildMapping,
+  mergeChildMappings
+});

package/dist/_.._/benchmarks/components/Button.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);
+var Button_exports = {};
+__export(Button_exports, {
+  Button: () => ButtonView
+});
+module.exports = __toCommonJS(Button_exports);
+var import_react = __toESM(require("react"));
+var import_Button = require("../../src/Button");
+const ButtonView = () => {
+  return /* @__PURE__ */ import_react.default.createElement(import_Button.Button, { color: "primary", variant: "contained" }, "Text");
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Button
+});

package/dist/_.._/benchmarks/components/Input.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);
+var Input_exports = {};
+__export(Input_exports, {
+  Input: () => InputView
+});
+module.exports = __toCommonJS(Input_exports);
+var import_react = __toESM(require("react"));
+var import_Input = require("../../src/Input");
+const InputView = () => {
+  const [value, setValue] = (0, import_react.useState)("");
+  const handleChange = (_e, data) => {
+    setValue(data == null ? void 0 : data.value);
+  };
+  return /* @__PURE__ */ import_react.default.createElement(import_Input.Input, { value, placeholder: "\u8BF7\u586B\u5199\u5185\u5BB9", onChange: handleChange });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Input
+});

package/dist/_.._/benchmarks/components/Tabs.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);
+var Tabs_exports = {};
+__export(Tabs_exports, {
+  Tabs: () => TabsView
+});
+module.exports = __toCommonJS(Tabs_exports);
+var import_react = __toESM(require("react"));
+var import_Tabs = require("../../src/Tabs");
+const TabsView = () => {
+  const [value, setValue] = (0, import_react.useState)("one");
+  const tabList = [
+    { title: "TAB ONE", index: "one" },
+    { title: "TAB TWO", index: "two" },
+    { title: "TAB THREE", index: "three" }
+  ];
+  const handleClick = (_e, { index }) => {
+    setValue(index);
+  };
+  return /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, /* @__PURE__ */ import_react.default.createElement(import_Tabs.Tabs, { style: { marginBottom: "12px" }, value }, tabList.map((item) => /* @__PURE__ */ import_react.default.createElement(import_Tabs.Tab, { key: item.index, index: item.index, onClick: handleClick }, item.title))), /* @__PURE__ */ import_react.default.createElement(import_Tabs.TabPanel, { value, index: "one" }, "Tab Panel 1"), /* @__PURE__ */ import_react.default.createElement(import_Tabs.TabPanel, { value, index: "two" }, "Tab Panel 2"), /* @__PURE__ */ import_react.default.createElement(import_Tabs.TabPanel, { value, index: "three" }, "Tab Panel 3"));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Tabs
+});

package/dist/benchmarks/components/Button.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const ButtonView: () => React.JSX.Element;
+export { ButtonView as Button };