@hanwenbo/x-taro-ui 0.0.1

package/lib/components/masonryList/masonryList.js

@@ -0,0 +1,479 @@
+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/masonryList/masonryList.tsx
+var masonryList_exports = {};
+__export(masonryList_exports, {
+  default: () => masonryList_default
+});
+module.exports = __toCommonJS(masonryList_exports);
+var import_react = __toESM(require("react"));
+var import_components = require("@tarojs/components");
+var import_theme = require("../../theme");
+var import_utils = require("../../utils");
+var import_locale = require("../../utils/locale");
+var import_configProvider = require("../configProvider");
+var import_scrollView = require("../scrollView");
+function MasonryListInner({
+  data,
+  items,
+  renderItem,
+  keyExtractor,
+  columns,
+  numColumns = columns ?? 2,
+  columnGap,
+  itemGap,
+  gap,
+  variant = "plain",
+  estimatedHeight,
+  loading = false,
+  loadingText,
+  loadingComponent,
+  emptyText,
+  emptyComponent,
+  hasMore = true,
+  onEndReached,
+  onEndReachedThreshold = 100,
+  horizontal = false,
+  itemHeight,
+  header,
+  footer,
+  itemStyle,
+  getItemStyle,
+  onRefresh,
+  onDataChange,
+  height,
+  showScrollbar = true,
+  contentContainerStyle,
+  children,
+  className,
+  style,
+  testID
+}, ref) {
+  const { theme } = (0, import_theme.useTheme)();
+  const config = (0, import_configProvider.useConfigProvider)();
+  const reactId = (0, import_react.useId)();
+  const instanceIdRef = (0, import_react.useRef)(`x-masonry-list-${reactId.replace(/[^a-zA-Z0-9_-]/g, "")}`);
+  const latestPropItemsRef = (0, import_react.useRef)(data ?? items ?? []);
+  const [localItems, setLocalItems] = (0, import_react.useState)(() => data ?? items ?? []);
+  const localItemsRef = (0, import_react.useRef)(localItems);
+  const currentPropItems = data ?? items;
+  const propItemsChanged = currentPropItems !== void 0 && latestPropItemsRef.current !== currentPropItems;
+  if (propItemsChanged) {
+    latestPropItemsRef.current = currentPropItems;
+    localItemsRef.current = currentPropItems;
+  }
+  const renderedItems = propItemsChanged ? currentPropItems : localItems;
+  const [scrollRequest, setScrollRequest] = (0, import_react.useState)({
+    offset: 0,
+    animated: false,
+    sequence: 0,
+    target: null,
+    requested: false
+  });
+  const nearEndRef = (0, import_react.useRef)(false);
+  const hasDataProp = data !== void 0 || items !== void 0;
+  const childItems = hasDataProp ? [] : import_react.default.Children.toArray(children).filter(hasRenderableNode);
+  const resolvedColumns = normalizeColumnCount(numColumns);
+  const resolvedColumnGap = columnGap ?? gap ?? 10;
+  const resolvedItemGap = itemGap ?? gap ?? 10;
+  const resolvedEndReachedThreshold = normalizeScrollOffset(onEndReachedThreshold);
+  const scrollTargetId = scrollRequest.target ? `${instanceIdRef.current}-${scrollRequest.target}-${scrollRequest.sequence}` : void 0;
+  const resolvedLoadingText = loadingText ?? (0, import_locale.resolveLocaleText)(config.locale, "list.loading", "加载中...");
+  const resolvedEmptyText = emptyText ?? (0, import_locale.resolveLocaleText)(config.locale, "empty.text", "暂无数据");
+  (0, import_react.useEffect)(() => {
+    const nextItems = data ?? items ?? [];
+    latestPropItemsRef.current = nextItems;
+    localItemsRef.current = nextItems;
+    setLocalItems(nextItems);
+  }, [data, items]);
+  (0, import_react.useEffect)(() => {
+    nearEndRef.current = false;
+  }, [horizontal, renderedItems.length, resolvedEndReachedThreshold]);
+  const commitLocalItems = (0, import_react.useCallback)(
+    (updater) => {
+      const next = updater(localItemsRef.current);
+      localItemsRef.current = next;
+      setLocalItems(next);
+      onDataChange == null ? void 0 : onDataChange(next);
+    },
+    [onDataChange]
+  );
+  const requestScroll = (0, import_react.useCallback)((offset, animated) => {
+    setScrollRequest((current) => ({
+      offset: normalizeScrollOffset(offset),
+      animated,
+      sequence: current.sequence + 1,
+      target: null,
+      requested: true
+    }));
+  }, []);
+  const requestTarget = (0, import_react.useCallback)((target, animated) => {
+    setScrollRequest((current) => ({
+      ...current,
+      animated,
+      sequence: current.sequence + 1,
+      target,
+      requested: true
+    }));
+  }, []);
+  const emitEndReached = (0, import_react.useCallback)(() => {
+    if (nearEndRef.current || !hasMore || loading) return;
+    nearEndRef.current = true;
+    onEndReached == null ? void 0 : onEndReached();
+  }, [hasMore, loading, onEndReached]);
+  (0, import_react.useImperativeHandle)(
+    ref,
+    () => ({
+      refresh: () => {
+        const next = latestPropItemsRef.current;
+        localItemsRef.current = next;
+        setLocalItems(next);
+        nearEndRef.current = false;
+        onRefresh == null ? void 0 : onRefresh();
+      },
+      loadMore: () => {
+        if (hasMore && !loading) onEndReached == null ? void 0 : onEndReached();
+      },
+      scrollToOffset: ({ offset, animated = true }) => requestScroll(offset, animated),
+      scrollToTop: (animated = true) => requestTarget("start", animated),
+      scrollToEnd: (animated = true) => requestTarget("end", animated),
+      getData: () => localItemsRef.current,
+      updateItem: (updateFn) => commitLocalItems(updateFn),
+      removeItem: (key) => commitLocalItems(
+        (current) => current.filter((item, index) => resolveItemKey(item, index, keyExtractor) !== key)
+      ),
+      listLength: () => localItemsRef.current.length
+    }),
+    [
+      commitLocalItems,
+      hasMore,
+      keyExtractor,
+      loading,
+      onEndReached,
+      onRefresh,
+      requestScroll,
+      requestTarget
+    ]
+  );
+  const handleScroll = (event) => {
+    if (scrollRequest.requested) {
+      setScrollRequest(
+        (current) => current.requested && current.sequence === scrollRequest.sequence ? { ...current, requested: false } : current
+      );
+    }
+    const detail = event.detail;
+    const host = event.currentTarget;
+    const viewport = horizontal ? host.clientWidth ?? 0 : host.clientHeight ?? 0;
+    const extent = horizontal ? detail.scrollWidth : detail.scrollHeight;
+    const offset = horizontal ? detail.scrollLeft : detail.scrollTop;
+    const distanceFromEnd = extent - viewport - offset;
+    if (extent > 0 && viewport > 0) {
+      if (distanceFromEnd < resolvedEndReachedThreshold) emitEndReached();
+      else nearEndRef.current = false;
+    }
+  };
+  const sourceItems = renderedItems.map((item, index) => ({
+    key: resolveItemKey(item, index, keyExtractor),
+    node: renderMasonryItem(renderItem, item, index, theme.colors),
+    weight: normalizeWeight((estimatedHeight == null ? void 0 : estimatedHeight(item, index)) ?? inferWeight(item)),
+    style: getItemStyle == null ? void 0 : getItemStyle(item, index),
+    index
+  }));
+  const childEntries = childItems.map((child, index) => ({
+    key: String(index),
+    node: child,
+    weight: 1,
+    style: void 0,
+    index
+  }));
+  const entries = sourceItems.length > 0 ? sourceItems : childEntries;
+  const columnsData = buildColumns(entries, resolvedColumns);
+  const surfaceStyle = variant === "card" ? {
+    padding: 16,
+    borderRadius: "var(--x-list-card-radius)",
+    backgroundColor: theme.colors.card,
+    border: `1px solid ${theme.colors.border}`
+  } : variant === "outline" ? {
+    padding: 16,
+    borderRadius: "var(--x-list-card-radius)",
+    backgroundColor: theme.colors.background,
+    border: `1px solid ${theme.colors.border}`
+  } : void 0;
+  const renderEntry = (entry) => /* @__PURE__ */ import_react.default.createElement(
+    import_components.View,
+    {
+      key: entry.key,
+      "data-slot": "masonry-list-item",
+      "data-index": entry.index,
+      className: "x-masonry-list__item",
+      style: {
+        boxSizing: "border-box",
+        breakInside: "avoid",
+        flexShrink: horizontal ? 0 : void 0,
+        height: toLength(itemHeight),
+        ...surfaceStyle,
+        ...itemStyle,
+        ...entry.style
+      }
+    },
+    entry.node
+  );
+  return /* @__PURE__ */ import_react.default.createElement(
+    import_components.View,
+    {
+      "data-slot": "masonry-list-root",
+      "data-columns": horizontal ? void 0 : String(resolvedColumns),
+      "data-horizontal": horizontal ? "true" : void 0,
+      "data-loading": loading ? "true" : void 0,
+      "data-has-more": hasMore ? "true" : "false",
+      "data-scroll-target": scrollTargetId,
+      "data-testid": testID,
+      className: (0, import_utils.classNames)(
+        "x-masonry-list",
+        `x-masonry-list--${variant}`,
+        loading && "x-masonry-list--loading",
+        entries.length === 0 && "x-masonry-list--empty",
+        className
+      ),
+      style: { boxSizing: "border-box", width: "100%", ...style }
+    },
+    /* @__PURE__ */ import_react.default.createElement(
+      import_scrollView.ScrollView,
+      {
+        className: "x-masonry-list__scroll",
+        horizontal,
+        scrollX: horizontal,
+        scrollY: !horizontal,
+        flex: false,
+        height: height ?? (style == null ? void 0 : style.height) ?? "auto",
+        showScrollbar,
+        scrollWithAnimation: scrollRequest.animated,
+        scrollIntoView: scrollTargetId,
+        scrollIntoViewAlignment: "start",
+        scrollTop: horizontal || !scrollRequest.requested || scrollRequest.target ? void 0 : scrollRequest.offset + (scrollRequest.sequence % 2 === 0 ? 0 : 0.01),
+        scrollLeft: horizontal && scrollRequest.requested && !scrollRequest.target ? scrollRequest.offset + (scrollRequest.sequence % 2 === 0 ? 0 : 0.01) : void 0,
+        lowerThreshold: resolvedEndReachedThreshold,
+        onScrollToLower: emitEndReached,
+        onScroll: handleScroll
+      },
+      /* @__PURE__ */ import_react.default.createElement(
+        import_components.View,
+        {
+          "data-slot": "masonry-list-content",
+          className: "x-masonry-list__content",
+          style: { boxSizing: "border-box", width: "100%", ...contentContainerStyle }
+        },
+        !horizontal ? /* @__PURE__ */ import_react.default.createElement(
+          import_components.View,
+          {
+            id: scrollRequest.target === "start" ? scrollTargetId : `${instanceIdRef.current}-start`,
+            "aria-hidden": true,
+            "data-slot": "masonry-list-start",
+            style: anchorStyle
+          }
+        ) : null,
+        hasRenderableNode(header) ? /* @__PURE__ */ import_react.default.createElement(import_components.View, { "data-slot": "masonry-list-header", className: "x-masonry-list__header" }, header) : null,
+        entries.length === 0 && !loading ? /* @__PURE__ */ import_react.default.createElement(
+          import_components.View,
+          {
+            "data-slot": "masonry-list-empty",
+            className: "x-masonry-list__empty",
+            style: stateStyle
+          },
+          emptyComponent ?? renderText(resolvedEmptyText, theme.colors["muted-foreground"])
+        ) : horizontal ? /* @__PURE__ */ import_react.default.createElement(
+          import_components.View,
+          {
+            className: "x-masonry-list__horizontal",
+            style: {
+              display: "flex",
+              flexDirection: "row",
+              flexWrap: "nowrap",
+              alignItems: "flex-start",
+              minWidth: "100%",
+              gap: toLength(resolvedItemGap)
+            }
+          },
+          /* @__PURE__ */ import_react.default.createElement(
+            import_components.View,
+            {
+              id: scrollRequest.target === "start" ? scrollTargetId : `${instanceIdRef.current}-start`,
+              "aria-hidden": true,
+              "data-slot": "masonry-list-start",
+              style: anchorStyle
+            }
+          ),
+          entries.map(renderEntry),
+          /* @__PURE__ */ import_react.default.createElement(
+            import_components.View,
+            {
+              id: scrollRequest.target === "end" ? scrollTargetId : `${instanceIdRef.current}-end`,
+              "aria-hidden": true,
+              "data-slot": "masonry-list-end",
+              style: anchorStyle
+            }
+          )
+        ) : /* @__PURE__ */ import_react.default.createElement(
+          import_components.View,
+          {
+            className: "x-masonry-list__columns",
+            style: {
+              display: "flex",
+              flexDirection: "row",
+              alignItems: "flex-start",
+              gap: toLength(resolvedColumnGap)
+            }
+          },
+          columnsData.map((column, columnIndex) => /* @__PURE__ */ import_react.default.createElement(
+            import_components.View,
+            {
+              key: columnIndex,
+              "data-slot": "masonry-list-column",
+              "data-column": columnIndex,
+              className: "x-masonry-list__column",
+              style: {
+                display: "flex",
+                minWidth: 0,
+                flex: 1,
+                flexDirection: "column",
+                gap: toLength(resolvedItemGap)
+              }
+            },
+            column.map(renderEntry)
+          ))
+        ),
+        loading ? /* @__PURE__ */ import_react.default.createElement(
+          import_components.View,
+          {
+            "data-slot": "masonry-list-loading",
+            className: "x-masonry-list__loading",
+            style: stateStyle
+          },
+          loadingComponent ?? renderText(resolvedLoadingText, theme.colors["muted-foreground"])
+        ) : null,
+        hasRenderableNode(footer) ? /* @__PURE__ */ import_react.default.createElement(import_components.View, { "data-slot": "masonry-list-footer", className: "x-masonry-list__footer" }, footer) : null,
+        !horizontal ? /* @__PURE__ */ import_react.default.createElement(
+          import_components.View,
+          {
+            id: scrollRequest.target === "end" ? scrollTargetId : `${instanceIdRef.current}-end`,
+            "aria-hidden": true,
+            "data-slot": "masonry-list-end",
+            style: anchorStyle
+          }
+        ) : null
+      )
+    )
+  );
+}
+var stateStyle = {
+  boxSizing: "border-box",
+  display: "flex",
+  width: "100%",
+  alignItems: "center",
+  justifyContent: "center",
+  padding: 16
+};
+var anchorStyle = {
+  width: 0,
+  height: 0,
+  minWidth: 0,
+  minHeight: 0,
+  flexShrink: 0,
+  overflow: "hidden"
+};
+function resolveItemKey(item, index, keyExtractor) {
+  if (keyExtractor) return keyExtractor(item, index);
+  if (item && typeof item === "object" && "id" in item) {
+    const id = item.id;
+    if (id !== void 0 && id !== null) return String(id);
+  }
+  return `item-${index}`;
+}
+function renderMasonryItem(renderer, item, index, colors) {
+  if (!renderer) return renderDefaultNode(item, colors);
+  if (renderer.length >= 2) {
+    return renderer(item, index);
+  }
+  return renderer({ item, index });
+}
+function buildColumns(items, columns) {
+  const buckets = Array.from({ length: columns }, () => []);
+  const heights = Array.from({ length: columns }, () => 0);
+  items.forEach((item) => {
+    let targetIndex = 0;
+    heights.forEach((height, index) => {
+      if (height < heights[targetIndex]) targetIndex = index;
+    });
+    buckets[targetIndex].push(item);
+    heights[targetIndex] += item.weight;
+  });
+  return buckets;
+}
+function inferWeight(item) {
+  if (item && typeof item === "object") {
+    const height = item.height;
+    if (typeof height === "number" && Number.isFinite(height) && height > 0) return height;
+  }
+  return 1;
+}
+function normalizeColumnCount(value) {
+  return Number.isFinite(value) ? Math.max(1, Math.floor(value) || 1) : 1;
+}
+function normalizeScrollOffset(value) {
+  return Number.isFinite(value) ? Math.max(0, value) : 0;
+}
+function normalizeWeight(value) {
+  return Number.isFinite(value) && value > 0 ? value : 1;
+}
+function hasRenderableNode(node) {
+  return node !== null && node !== void 0 && node !== false;
+}
+function renderText(content, color) {
+  return typeof content === "string" || typeof content === "number" ? /* @__PURE__ */ import_react.default.createElement(import_components.Text, { style: { color } }, content) : content;
+}
+function renderDefaultNode(item, colors) {
+  if (import_react.default.isValidElement(item)) return item;
+  if (typeof item === "string" || typeof item === "number") {
+    return /* @__PURE__ */ import_react.default.createElement(import_components.Text, { style: { color: colors.foreground } }, item);
+  }
+  if (item && typeof item === "object") {
+    const record = item;
+    const title = record.title ?? record.label ?? record.name;
+    const description = record.description ?? record.subtitle;
+    const extra = record.extra ?? record.value;
+    return /* @__PURE__ */ import_react.default.createElement(import_components.View, { style: { display: "flex", flexDirection: "column", gap: 8 } }, title !== void 0 ? /* @__PURE__ */ import_react.default.createElement(import_components.Text, { style: { color: colors.foreground, fontWeight: "600" } }, String(title)) : null, description !== void 0 ? /* @__PURE__ */ import_react.default.createElement(import_components.Text, { style: { color: colors["muted-foreground"], fontSize: 13 } }, String(description)) : null, extra !== void 0 ? /* @__PURE__ */ import_react.default.createElement(import_components.Text, { style: { color: colors.foreground } }, String(extra)) : null);
+  }
+  return null;
+}
+function toLength(value) {
+  return typeof value === "number" ? `${value}px` : value;
+}
+var MasonryList = import_react.default.forwardRef(MasonryListInner);
+MasonryList.displayName = "MasonryList";
+var masonryList_default = MasonryList;

package/lib/components/masonryList/types.d.ts

@@ -0,0 +1,65 @@
+import type { CSSProperties, ReactNode } from 'react';
+export declare type MasonryListVariant = 'plain' | 'card' | 'outline';
+export interface MasonryListRenderItemInfo<T> {
+    item: T;
+    index: number;
+}
+export declare type MasonryListRenderItem<T> = ((info: MasonryListRenderItemInfo<T>) => ReactNode) | ((item: T, index: number) => ReactNode);
+export interface MasonryListRef<T = unknown> {
+    /** Reset the local rendered snapshot from the latest data/items prop and call onRefresh. */
+    refresh: () => void;
+    loadMore: () => void;
+    scrollToOffset: (params: {
+        offset: number;
+        animated?: boolean;
+    }) => void;
+    scrollToTop: (animated?: boolean) => void;
+    scrollToEnd: (animated?: boolean) => void;
+    getData: () => T[];
+    /** Mutates the local rendered snapshot; the next data/items prop change replaces it. */
+    updateItem: (updateFn: (data: T[]) => T[]) => void;
+    /** Mutates the local rendered snapshot and reports it through onDataChange. */
+    removeItem: (key: string) => void;
+    listLength: () => number;
+}
+export interface MasonryListProps<T = unknown> {
+    data?: T[];
+    /** @deprecated Use data. */
+    items?: T[];
+    /** Canonical renderer receives { item, index }; the legacy two-argument form remains supported. */
+    renderItem?: MasonryListRenderItem<T>;
+    keyExtractor?: (item: T, index: number) => string;
+    /** @deprecated Use numColumns. */
+    columns?: number;
+    numColumns?: number;
+    columnGap?: number | string;
+    itemGap?: number | string;
+    loadingComponent?: ReactNode;
+    emptyComponent?: ReactNode;
+    hasMore?: boolean;
+    onEndReached?: () => void;
+    onEndReachedThreshold?: number;
+    horizontal?: boolean;
+    itemHeight?: number | string;
+    /** Compatibility gap alias; canonical columnGap and itemGap remain independent. */
+    gap?: number | string;
+    variant?: MasonryListVariant;
+    estimatedHeight?: (item: T, index: number) => number;
+    loading?: boolean;
+    loadingText?: ReactNode;
+    emptyText?: ReactNode;
+    header?: ReactNode;
+    footer?: ReactNode;
+    itemStyle?: CSSProperties;
+    getItemStyle?: (item: T, index: number) => CSSProperties | undefined;
+    onRefresh?: () => void;
+    onDataChange?: (data: T[]) => void;
+    height?: number | string;
+    showScrollbar?: boolean;
+    contentContainerStyle?: CSSProperties;
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+    testID?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/components/masonryList/types.js

@@ -0,0 +1,17 @@
+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);
+
+// src/components/masonryList/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

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

@@ -0,0 +1,4 @@
+export * from './types';
+export { default as Menu } from './menu';
+export { default } from './menu';
+//# sourceMappingURL=index.d.ts.map

package/lib/components/menu/index.js

@@ -0,0 +1,44 @@
+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);
+
+// src/components/menu/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Menu: () => import_menu.default,
+  default: () => import_menu2.default
+});
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./types"), module.exports);
+var import_menu = __toESM(require("./menu"));
+var import_menu2 = __toESM(require("./menu"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Menu,
+  ...require("./types")
+});

package/lib/components/menu/menu.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { MenuProps } from './types';
+declare const Menu: React.FC<MenuProps>;
+export default Menu;
+//# sourceMappingURL=menu.d.ts.map