@trilogy-ds/react 0.0.27-esm-cjs → 0.0.28-esm-cjs

package/lib/components/dropdown/index.js

@@ -0,0 +1,501 @@
+"use client";
+"use strict";
+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);
+
+// components/dropdown/index.ts
+var dropdown_exports = {};
+__export(dropdown_exports, {
+  Dropdown: () => Dropdown_default,
+  DropdownGroup: () => DropdownGroup_default,
+  DropdownItem: () => DropdownItem_default,
+  DropdownTrigger: () => DropdownTrigger_default
+});
+module.exports = __toCommonJS(dropdown_exports);
+
+// context/context/trilogyContext.tsx
+var React = __toESM(require("react"));
+var TrilogyContext = React.createContext({
+  styled: false,
+  setStyled: () => void 0
+});
+var useTrilogyContext = () => {
+  const context = React.useContext(TrilogyContext);
+  if (context === void 0) {
+    throw new Error("useTrilogyContext must be used within a TrilogyProvider");
+  }
+  return context;
+};
+
+// context/provider/provider.tsx
+var import_react = __toESM(require("react"));
+
+// context/providerStates/index.ts
+var import_react2 = require("react");
+var StatesContext = (0, import_react2.createContext)({
+  inverted: false,
+  active: false,
+  flat: false
+});
+
+// context/providerStyled/providerStyled.tsx
+var React3 = __toESM(require("react"));
+
+// context/providerTheme/providerTheme.tsx
+var import_react3 = __toESM(require("react"));
+var defaultTheme = {
+  icons: {},
+  colors: {},
+  fontFamily: {}
+};
+var defaultContextValue = {
+  theme: defaultTheme,
+  setTheme: () => void 0
+};
+var TrilogyThemeContext = import_react3.default.createContext(defaultContextValue);
+
+// helpers/hashClassesHelpers/index.tsx
+var hashClass = (addHash = false, classes) => {
+  const { hash, styled } = useTrilogyContext();
+  if (classes.trim().length < 1) return "";
+  if (styled) {
+    return classes.split(" ").map((classe) => classe = `${classe}_${hash}`).join(" ");
+  }
+  return classes;
+};
+
+// services/classify/index.ts
+function classify(prefix) {
+  return (classname) => classname !== "" ? `${prefix}-${classname.toLowerCase()}` : "";
+}
+var is = classify("is");
+var has = classify("has");
+
+// components/dropdown/Dropdown.tsx
+var import_clsx2 = __toESM(require("clsx"));
+var React7 = __toESM(require("react"));
+
+// components/dropdown/context/DropdownContext.tsx
+var import_react4 = __toESM(require("react"));
+var DropdownContext = (0, import_react4.createContext)(void 0);
+var useDropdownContext = () => {
+  const context = (0, import_react4.useContext)(DropdownContext);
+  if (!context) {
+    throw new Error("useDropdownContext must be used within a DropdownProvider");
+  }
+  return context;
+};
+var DropdownProvider = ({
+  children,
+  defaultOpen = false,
+  onToggle
+}) => {
+  const [isOpen, setIsOpen] = (0, import_react4.useState)(defaultOpen);
+  const toggle = () => {
+    const newState = !isOpen;
+    setIsOpen(newState);
+    onToggle == null ? void 0 : onToggle(newState);
+  };
+  const open = () => {
+    setIsOpen(true);
+    onToggle == null ? void 0 : onToggle(true);
+  };
+  const close = () => {
+    setIsOpen(false);
+    onToggle == null ? void 0 : onToggle(false);
+  };
+  const value = {
+    isOpen,
+    toggle,
+    open,
+    close
+  };
+  return /* @__PURE__ */ import_react4.default.createElement(DropdownContext.Provider, { value }, children);
+};
+
+// components/dropdown/trigger/DropdownTrigger.tsx
+var React6 = __toESM(require("react"));
+var import_clsx = __toESM(require("clsx"));
+var DropdownTrigger = React6.forwardRef(
+  ({
+    children,
+    onClick,
+    className,
+    testId,
+    ...others
+  }, ref) => {
+    const { styled } = useTrilogyContext();
+    let contextState = null;
+    try {
+      contextState = useDropdownContext();
+    } catch {
+      contextState = null;
+    }
+    const classes = hashClass(
+      styled,
+      (0, import_clsx.default)(
+        "dropdown-trigger",
+        className
+      )
+    );
+    const handleClick = (event) => {
+      if (contextState) {
+        contextState.toggle();
+      }
+      onClick == null ? void 0 : onClick(event);
+    };
+    const enhancedChildren = React6.Children.map(children, (child) => {
+      if (React6.isValidElement(child)) {
+        if (!child.props.onClick) {
+          return React6.cloneElement(child, {
+            onClick: (e) => {
+              e.preventDefault();
+              e.stopPropagation();
+              handleClick(e);
+            }
+          });
+        }
+        return React6.cloneElement(child, {
+          onClick: (e) => {
+            var _a, _b;
+            (_b = (_a = child.props).onClick) == null ? void 0 : _b.call(_a, e);
+            if (!e.defaultPrevented) {
+              handleClick(e);
+            }
+          }
+        });
+      }
+      return child;
+    });
+    return /* @__PURE__ */ React6.createElement(
+      "div",
+      {
+        ref,
+        className: classes,
+        onClick: handleClick,
+        "data-testid": testId,
+        ...others
+      },
+      enhancedChildren
+    );
+  }
+);
+DropdownTrigger.displayName = "DropdownTrigger" /* DropdownTrigger */;
+var DropdownTrigger_default = DropdownTrigger;
+
+// components/dropdown/Dropdown.tsx
+var DropdownContent = React7.forwardRef(
+  ({
+    children,
+    className,
+    testId,
+    ...others
+  }, ref) => {
+    const { styled } = useTrilogyContext();
+    const dropdownRef = React7.useRef(null);
+    const menuRef = React7.useRef(null);
+    const hasDropdownTrigger = React7.Children.toArray(children).some(
+      (child) => React7.isValidElement(child) && child.type === DropdownTrigger_default
+    );
+    const { isOpen } = useDropdownContext();
+    React7.useEffect(() => {
+      if (!isOpen || !dropdownRef.current || !menuRef.current) return;
+      const dropdown = dropdownRef.current;
+      const menu = menuRef.current;
+      const checkPosition = () => {
+        const rect = dropdown.getBoundingClientRect();
+        const viewportHeight = window.innerHeight;
+        const spaceBelow = viewportHeight - rect.bottom - 8;
+        const spaceAbove = rect.top - 8;
+        const menuHeight = 300;
+        if (spaceBelow < menuHeight && spaceAbove >= menuHeight) {
+          menu.setAttribute("data-position", "upward");
+        } else {
+          menu.removeAttribute("data-position");
+        }
+      };
+      requestAnimationFrame(checkPosition);
+    }, [isOpen]);
+    const classes = hashClass(
+      styled,
+      (0, import_clsx2.default)(
+        "dropdown",
+        isOpen && is("active"),
+        !hasDropdownTrigger && "dropdown-manual",
+        className
+      )
+    );
+    const triggerChildren = [];
+    const contentChildren = [];
+    if (hasDropdownTrigger) {
+      React7.Children.forEach(children, (child) => {
+        if (React7.isValidElement(child) && child.type === DropdownTrigger_default) {
+          triggerChildren.push(child);
+        } else {
+          contentChildren.push(child);
+        }
+      });
+    }
+    return /* @__PURE__ */ React7.createElement(
+      "div",
+      {
+        ref: (node) => {
+          if (dropdownRef.current !== node) {
+            dropdownRef.current = node;
+          }
+          if (typeof ref === "function") {
+            ref(node);
+          } else if (ref) {
+            ref.current = node;
+          }
+        },
+        className: classes,
+        "data-testid": testId,
+        ...others
+      },
+      hasDropdownTrigger ? triggerChildren : null,
+      /* @__PURE__ */ React7.createElement("div", { ref: menuRef, className: hashClass(styled, "dropdown-menu") }, /* @__PURE__ */ React7.createElement("div", { className: hashClass(styled, "dropdown-content") }, hasDropdownTrigger ? contentChildren : children))
+    );
+  }
+);
+var Dropdown = React7.forwardRef(
+  ({
+    children,
+    isActive,
+    defaultOpen,
+    onToggle,
+    className,
+    testId,
+    ...others
+  }, ref) => {
+    const hasDropdownTrigger = React7.Children.toArray(children).some(
+      (child) => React7.isValidElement(child) && child.type === DropdownTrigger_default
+    );
+    const useTrigger = defaultOpen !== void 0 || onToggle !== void 0 || hasDropdownTrigger;
+    const isManualMode = !useTrigger && isActive !== void 0;
+    const providerDefaultOpen = isManualMode ? isActive : defaultOpen;
+    return /* @__PURE__ */ React7.createElement(DropdownProvider, { defaultOpen: providerDefaultOpen, onToggle }, /* @__PURE__ */ React7.createElement(
+      DropdownContent,
+      {
+        ref,
+        className,
+        testId,
+        ...others
+      },
+      children
+    ));
+  }
+);
+Dropdown.displayName = "Dropdown" /* Dropdown */;
+var Dropdown_default = Dropdown;
+
+// components/dropdown/group/DropdownGroup.tsx
+var import_clsx3 = __toESM(require("clsx"));
+var React8 = __toESM(require("react"));
+var DropdownGroup = React8.forwardRef(
+  ({ className, id, children, hideSeparator, testId, ...others }, ref) => {
+    const { styled } = useTrilogyContext();
+    const classes = hashClass(styled, (0, import_clsx3.default)("dropdown-group", hideSeparator && is("no-separator"), className));
+    return /* @__PURE__ */ React8.createElement("div", { ref, id, className: classes, role: "group", "data-testid": testId, ...others }, children);
+  }
+);
+DropdownGroup.displayName = "DropdownGroup" /* DropdownGroup */;
+var DropdownGroup_default = DropdownGroup;
+
+// components/dropdown/item/DropdownItem.tsx
+var import_clsx5 = __toESM(require("clsx"));
+var React10 = __toESM(require("react"));
+
+// helpers/device/index.ts
+var Device = /* @__PURE__ */ ((Device2) => {
+  Device2["Browser"] = "browser";
+  Device2["Server"] = "server";
+  Device2["Native"] = "native";
+  return Device2;
+})(Device || {});
+var { Browser, Server, Native } = Device;
+var canUseDOM = !!(typeof window !== "undefined" && window.document && window.document.createElement);
+var canUseNative = typeof navigator != "undefined" && navigator.product == "ReactNative";
+var device = canUseNative ? Native : canUseDOM ? Browser : Server;
+var SSRObjectDefined = {
+  isBrowser: device === Browser,
+  isServer: device === Server,
+  isNative: device === Native,
+  device,
+  canUseWorkers: typeof Worker !== "undefined",
+  canUseEventListeners: device === Browser && !!window.addEventListener,
+  canUseViewport: device === Browser && !!window.screen
+};
+var assign = (...args) => Object.assign({}, ...args);
+var values = (obj) => Object.values(obj);
+var toArrayObject = () => assign((values(SSRObjectDefined), SSRObjectDefined));
+var SSRObject = toArrayObject();
+
+// objects/facets/Color/index.tsx
+var import_react5 = require("react");
+var colors = {
+  ["WHITE" /* BACKGROUND */]: ["#fff", "white", "main"],
+  ["MAIN" /* MAIN */]: ["#3d5d7e", "main", "white"],
+  ["MAIN_FADE" /* MAIN_FADE */]: ["#BBC6CD", "main-fade", "white"],
+  ["ACCENT" /* ACCENT */]: ["#da641b", "accent", "white"],
+  ["ACCENT_FADE" /* ACCENT_FADE */]: ["#faebe3", "accent-fade", "white"],
+  ["FONT" /* FONT */]: ["#3d5d7e", "main", "white"],
+  ["FONT_PLACEHOLDER" /* FONT_PLACEHOLDER */]: ["#687a87", "font-placeholder", "white"],
+  ["SUCCESS" /* SUCCESS */]: ["#007B52", "success", "white"],
+  ["SUCCESS_FADE" /* SUCCESS_FADE */]: ["#cae8ca", "success-fade", "white"],
+  ["INFO" /* INFO */]: ["#1A688A", "info", "white"],
+  ["INFO_FADE" /* INFO_FADE */]: ["#c8dbec", "info-fade", "white"],
+  ["WARNING" /* WARNING */]: ["#FFBB33", "warning", "white"],
+  ["WARNING_FADE" /* WARNING_FADE */]: ["#ecdbc6", "warning-fade", "white"],
+  ["ERROR" /* ERROR */]: ["#D42D02", "error", "white"],
+  ["ERROR_FADE" /* ERROR_FADE */]: ["#eecccc", "error-fade", "white"],
+  ["DISABLED" /* DISABLED */]: ["#646464", "disabled", "white"],
+  ["DISABLED_FADE" /* DISABLED_FADE */]: ["#D1D1D1", "disabled-fade", "white"],
+  ["NEUTRAL" /* NEUTRAL */]: ["#707070", "grey", "white"],
+  ["NEUTRAL_FADE" /* NEUTRAL_FADE */]: ["#F4F4F4", "grey-fade", "white"],
+  ["STROKE" /* STROKE */]: ["#BBC1CE", "stroke", "white"],
+  ["STROKE_FADE" /* STROKE_FADE */]: ["#cadbe8", "stroke-fade", "white"]
+};
+var getColorClassName = (trilogyColor) => {
+  const color = colors[trilogyColor];
+  return color[1];
+};
+
+// objects/atoms/Background/index.ts
+var getBackgroundClassName = (backgroundType) => {
+  return `background-${getColorClassName(backgroundType)}`;
+};
+
+// objects/facets/Justifiable/index.ts
+var getJustifySelfClassName = (justifyContent) => {
+  if (!justifyContent) return "justified-selfstart";
+  switch (true) {
+    case ["ALIGNED_CENTER", "CENTER"].includes(justifyContent):
+      return "justified-self-center";
+    case ["START", "ALIGNED_START"].includes(justifyContent):
+      return "justified-self-start";
+    case ["ALIGNED_END", "END"].includes(justifyContent):
+      return "justified-selfend";
+    default:
+      return "justified-selfstart";
+  }
+};
+
+// components/icon/Icon.tsx
+var import_clsx4 = __toESM(require("clsx"));
+var React9 = __toESM(require("react"));
+var Icon = React9.forwardRef(
+  ({ className, id, size, name, circled, stretched, color, backgroundColor, onClick, skeleton, align, ...others }, ref) => {
+    const { styled } = useTrilogyContext();
+    const background = backgroundColor && has(getBackgroundClassName(backgroundColor)) || circled && has(getBackgroundClassName("MAIN" /* MAIN */)) || "";
+    const classes = hashClass(
+      styled,
+      (0, import_clsx4.default)(
+        "icon",
+        stretched && is("stretched"),
+        size && is(size),
+        circled && is("circled"),
+        circled && !color && has("text-white"),
+        color && is(`${getColorClassName(color)}`),
+        skeleton && is("loading"),
+        align && (0, import_clsx4.default)(is("flex"), is(getJustifySelfClassName(align))),
+        background,
+        className
+      )
+    );
+    return /* @__PURE__ */ React9.createElement("span", { id, onClick: onClick && onClick, className: classes, ...others, ref }, /* @__PURE__ */ React9.createElement("i", { className: hashClass(styled, (0, import_clsx4.default)(name)), "aria-hidden": "true" }));
+  }
+);
+Icon.displayName = "Icon" /* Icon */;
+var Icon_default = Icon;
+
+// components/dropdown/item/DropdownItem.tsx
+var DropdownItem = React10.forwardRef(
+  ({
+    children,
+    iconName,
+    active,
+    disabled,
+    onSelect,
+    ...others
+  }, ref) => {
+    const { styled } = useTrilogyContext();
+    const classes = hashClass(
+      styled,
+      (0, import_clsx5.default)(
+        "dropdown-item",
+        active && is("active"),
+        disabled && is("disabled")
+      )
+    );
+    const handleClick = (e) => {
+      if (disabled) {
+        e.preventDefault();
+        return;
+      }
+      if (onSelect) {
+        onSelect();
+      }
+    };
+    const handleKeyDown = (e) => {
+      if (disabled) return;
+      if (e.key === "Enter" || e.key === " ") {
+        e.preventDefault();
+        if (onSelect) {
+          onSelect();
+        }
+      }
+    };
+    return /* @__PURE__ */ React10.createElement(
+      "button",
+      {
+        ref,
+        type: "button",
+        className: classes,
+        onClick: handleClick,
+        onKeyDown: handleKeyDown,
+        disabled,
+        "aria-disabled": disabled,
+        role: "menuitem",
+        tabIndex: disabled ? -1 : 0,
+        ...others
+      },
+      iconName && /* @__PURE__ */ React10.createElement(Icon_default, { name: iconName, size: "smaller" /* SMALLER */ }),
+      children
+    );
+  }
+);
+DropdownItem.displayName = "DropdownItem" /* DropdownItem */;
+var DropdownItem_default = DropdownItem;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Dropdown,
+  DropdownGroup,
+  DropdownItem,
+  DropdownTrigger
+});

package/lib/components/dropdown/index.mjs

@@ -0,0 +1,48 @@
+"use client";
+import "../../chunk-GA52AA6D.mjs";
+import {
+  DropdownItem_default
+} from "../../chunk-RPYWD5K3.mjs";
+import {
+  DropdownGroup_default
+} from "../../chunk-57ZCA2JK.mjs";
+import {
+  Dropdown_default
+} from "../../chunk-CQ4R52AQ.mjs";
+import {
+  DropdownTrigger_default
+} from "../../chunk-HAIHG3RG.mjs";
+import "../../chunk-N6PAYRHX.mjs";
+import "../../chunk-M5US2UAQ.mjs";
+import "../../chunk-Y3ROARMA.mjs";
+import "../../chunk-LGL3XQ7F.mjs";
+import "../../chunk-LBHJFKKZ.mjs";
+import "../../chunk-MTRPTXD2.mjs";
+import "../../chunk-FRHV2QIJ.mjs";
+import "../../chunk-UXQWL2JF.mjs";
+import "../../chunk-AHFPVKHD.mjs";
+import "../../chunk-BU5IIOVY.mjs";
+import "../../chunk-GA2G3UAN.mjs";
+import "../../chunk-SWVRRUW7.mjs";
+import "../../chunk-Y7CEUBIZ.mjs";
+import "../../chunk-HU3FAWMX.mjs";
+import "../../chunk-ODKCJMCG.mjs";
+import "../../chunk-OGATDHMZ.mjs";
+import "../../chunk-PKMC2LCN.mjs";
+import "../../chunk-X6SQUIXU.mjs";
+import "../../chunk-HZ3DFWF6.mjs";
+import "../../chunk-XGS2TGKN.mjs";
+import "../../chunk-SJHSDGQP.mjs";
+import "../../chunk-DBSMMWLO.mjs";
+import "../../chunk-RYABO2EX.mjs";
+import "../../chunk-6IKR6FTJ.mjs";
+import "../../chunk-OXCSBRU5.mjs";
+import "../../chunk-4UHBBNZ7.mjs";
+import "../../chunk-M6FZOPDH.mjs";
+import "../../chunk-QIPGVLHJ.mjs";
+export {
+  Dropdown_default as Dropdown,
+  DropdownGroup_default as DropdownGroup,
+  DropdownItem_default as DropdownItem,
+  DropdownTrigger_default as DropdownTrigger
+};

package/lib/components/dropdown/index.native.d.mts

@@ -0,0 +1,9 @@
+import Dropdown from './Dropdown.native';
+import DropdownGroup from './group/DropdownGroup.native';
+import DropdownItem from './item/DropdownItem.native';
+import DropdownTrigger from './trigger/DropdownTrigger.native';
+export * from './DropdownProps';
+export * from './group/DropdownGroupProps';
+export * from './item/DropdownItemProps';
+export * from './trigger/DropdownTriggerProps';
+export { Dropdown, DropdownGroup, DropdownItem, DropdownTrigger };

package/lib/components/dropdown/index.native.d.ts

@@ -0,0 +1,9 @@
+import Dropdown from './Dropdown.native';
+import DropdownGroup from './group/DropdownGroup.native';
+import DropdownItem from './item/DropdownItem.native';
+import DropdownTrigger from './trigger/DropdownTrigger.native';
+export * from './DropdownProps';
+export * from './group/DropdownGroupProps';
+export * from './item/DropdownItemProps';
+export * from './trigger/DropdownTriggerProps';
+export { Dropdown, DropdownGroup, DropdownItem, DropdownTrigger };

package/lib/components/dropdown/index.native.js

@@ -0,0 +1,78 @@
+"use client";
+"use strict";
+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);
+
+// components/dropdown/index.native.ts
+var index_native_exports = {};
+__export(index_native_exports, {
+  Dropdown: () => Dropdown_native_default,
+  DropdownGroup: () => DropdownGroup_native_default,
+  DropdownItem: () => DropdownItem_native_default,
+  DropdownTrigger: () => DropdownTrigger_native_default
+});
+module.exports = __toCommonJS(index_native_exports);
+
+// components/dropdown/Dropdown.native.tsx
+var React = __toESM(require("react"));
+var Dropdown = React.forwardRef((props, ref) => {
+  return /* @__PURE__ */ React.createElement(React.Fragment, null);
+});
+Dropdown.displayName = "Dropdown" /* Dropdown */;
+var Dropdown_native_default = Dropdown;
+
+// components/dropdown/group/DropdownGroup.native.tsx
+var React2 = __toESM(require("react"));
+var DropdownGroup = React2.forwardRef((props, ref) => {
+  return /* @__PURE__ */ React2.createElement(React2.Fragment, null);
+});
+DropdownGroup.displayName = "DropdownGroup" /* DropdownGroup */;
+var DropdownGroup_native_default = DropdownGroup;
+
+// components/dropdown/item/DropdownItem.native.tsx
+var React3 = __toESM(require("react"));
+var DropdownItem = React3.forwardRef((props, ref) => {
+  return /* @__PURE__ */ React3.createElement(React3.Fragment, null);
+});
+DropdownItem.displayName = "DropdownItem" /* DropdownItem */;
+var DropdownItem_native_default = DropdownItem;
+
+// components/dropdown/trigger/DropdownTrigger.native.tsx
+var React4 = __toESM(require("react"));
+var DropdownTrigger = React4.forwardRef((props, ref) => {
+  return /* @__PURE__ */ React4.createElement(React4.Fragment, null);
+});
+DropdownTrigger.displayName = "DropdownTrigger" /* DropdownTrigger */;
+var DropdownTrigger_native_default = DropdownTrigger;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Dropdown,
+  DropdownGroup,
+  DropdownItem,
+  DropdownTrigger
+});

package/lib/components/dropdown/index.native.mjs

@@ -0,0 +1,26 @@
+"use client";
+import "../../chunk-OQCQ2H22.mjs";
+import {
+  DropdownTrigger_native_default
+} from "../../chunk-LZH3HQCB.mjs";
+import {
+  DropdownItem_native_default
+} from "../../chunk-UAHBURVC.mjs";
+import {
+  DropdownGroup_native_default
+} from "../../chunk-HPMZZUFH.mjs";
+import {
+  Dropdown_native_default
+} from "../../chunk-VFI6BIAG.mjs";
+import "../../chunk-FRHV2QIJ.mjs";
+import "../../chunk-UXQWL2JF.mjs";
+import "../../chunk-AHFPVKHD.mjs";
+import "../../chunk-BU5IIOVY.mjs";
+import "../../chunk-M6FZOPDH.mjs";
+import "../../chunk-QIPGVLHJ.mjs";
+export {
+  Dropdown_native_default as Dropdown,
+  DropdownGroup_native_default as DropdownGroup,
+  DropdownItem_native_default as DropdownItem,
+  DropdownTrigger_native_default as DropdownTrigger
+};

package/lib/components/dropdown/item/DropdownItem.d.mts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import { DropdownItemProps, DropdownItemRef } from './DropdownItemProps';
+/**
+ * DropdownItem Component
+ * @param children {React.ReactNode} Children
+ * @param iconName {string} Icon displayed on the left of the text
+ * @param active {boolean} Active/selected item state
+ * @param disabled {boolean} Disabled item state
+ * @param onSelect {Function} Callback called when item is selected
+ */
+declare const DropdownItem: React.ForwardRefExoticComponent<DropdownItemProps & React.RefAttributes<DropdownItemRef>>;
+export default DropdownItem;