@mercurjs/admin 2.0.0-canary.100

package/dist/chunk-XSEF6KRY.js

@@ -0,0 +1,335 @@
+import {
+  KeyboundForm
+} from "./chunk-U2ZFCAPX.js";
+import {
+  RouteFocusModal
+} from "./chunk-V6LO4BXB.js";
+
+// src/components/tabbed-form/tabbed-form.tsx
+import { Button, ProgressTabs } from "@medusajs/ui";
+import {
+  Children,
+  createContext,
+  useContext,
+  useMemo as useMemo2
+} from "react";
+import { useTranslation } from "react-i18next";
+
+// src/components/tabbed-form/use-tab-management.ts
+import { useCallback, useEffect, useMemo, useState } from "react";
+var validateTab = async (form, tab) => {
+  if (tab.validationFields?.length) {
+    return form.trigger(tab.validationFields);
+  }
+  return form.trigger();
+};
+var validateTabRange = async (form, tabs, fromIndex, toIndex) => {
+  for (let i = fromIndex; i <= toIndex; i++) {
+    if (!await validateTab(form, tabs[i])) {
+      return false;
+    }
+  }
+  return true;
+};
+var useTabManagement = ({
+  tabs,
+  form
+}) => {
+  const visibleTabs = useMemo(
+    () => tabs.filter((t) => !t.isVisible || t.isVisible(form)),
+    [tabs, form]
+  );
+  const [activeTabId, setActiveTabId] = useState(
+    visibleTabs[0]?.id ?? ""
+  );
+  const [tabState, setTabState] = useState(() => {
+    const state = {};
+    visibleTabs.forEach((t, i) => {
+      state[t.id] = i === 0 ? "in-progress" : "not-started";
+    });
+    return state;
+  });
+  useEffect(() => {
+    let resolvedActiveId = activeTabId;
+    const activeExists = visibleTabs.some((t) => t.id === activeTabId);
+    if (!activeExists && visibleTabs.length > 0) {
+      resolvedActiveId = visibleTabs[0].id;
+      setActiveTabId(resolvedActiveId);
+    }
+    const newState = {};
+    const resolvedIndex = visibleTabs.findIndex(
+      (t) => t.id === resolvedActiveId
+    );
+    visibleTabs.forEach((t, i) => {
+      if (i < resolvedIndex) {
+        newState[t.id] = "completed";
+      } else if (i === resolvedIndex) {
+        newState[t.id] = "in-progress";
+      } else {
+        newState[t.id] = tabState[t.id] ?? "not-started";
+      }
+    });
+    setTabState(newState);
+  }, [activeTabId, visibleTabs]);
+  const activeIndex = visibleTabs.findIndex((t) => t.id === activeTabId);
+  const isLastTab = activeIndex === visibleTabs.length - 1;
+  const onNext = useCallback(async () => {
+    const currentTab = visibleTabs[activeIndex];
+    if (!currentTab) return;
+    const valid = await validateTab(form, currentTab);
+    if (!valid) return;
+    if (activeIndex < visibleTabs.length - 1) {
+      setActiveTabId(visibleTabs[activeIndex + 1].id);
+    }
+  }, [form, activeIndex, visibleTabs]);
+  const onTabChange = useCallback(
+    async (tabId) => {
+      const targetIndex = visibleTabs.findIndex((t) => t.id === tabId);
+      if (targetIndex === -1) return;
+      const currentIndex = visibleTabs.findIndex(
+        (t) => t.id === activeTabId
+      );
+      if (currentIndex === -1) {
+        setActiveTabId(tabId);
+        return;
+      }
+      if (targetIndex <= currentIndex) {
+        setActiveTabId(tabId);
+        return;
+      }
+      const valid = await validateTabRange(
+        form,
+        visibleTabs,
+        currentIndex,
+        targetIndex - 1
+      );
+      if (!valid) return;
+      setActiveTabId(tabId);
+    },
+    [form, visibleTabs, activeTabId]
+  );
+  return {
+    activeTabId,
+    setActiveTabId,
+    tabState,
+    visibleTabs,
+    isLastTab,
+    onNext,
+    onTabChange
+  };
+};
+
+// src/components/tabbed-form/tabbed-form.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var TabbedFormContext = createContext(null);
+var useTabbedForm = () => {
+  const form = useContext(TabbedFormContext);
+  if (!form) {
+    throw new Error("useTabbedForm must be used within a TabbedForm");
+  }
+  return form;
+};
+function resolveTabMeta(child) {
+  const type = child.type;
+  const meta = type?._tabMeta;
+  if (!meta && !child.props?.id) {
+    return null;
+  }
+  const id = child.props?.id ?? meta?.id ?? "";
+  const labelKey = meta?.labelKey ?? "";
+  const label = child.props?.label;
+  if (process.env.NODE_ENV !== "production") {
+    if (!id) {
+      console.warn(
+        "[TabbedForm] A child component is missing a tab id. Either set _tabMeta.id or pass an id prop."
+      );
+    }
+    if (!labelKey && !label) {
+      console.warn(
+        `[TabbedForm] Tab "${id}" has no label or labelKey \u2014 header will be empty.`
+      );
+    }
+  }
+  return {
+    id,
+    labelKey,
+    label,
+    validationFields: child.props?.validationFields ?? meta?.validationFields,
+    isVisible: child.props?.isVisible ?? meta?.isVisible
+  };
+}
+function collectTabs(children) {
+  const tabs = [];
+  const elements = [];
+  Children.forEach(children, (child) => {
+    if (!child || typeof child !== "object" || !("type" in child)) {
+      return;
+    }
+    const meta = resolveTabMeta(child);
+    if (meta) {
+      tabs.push(meta);
+      elements.push(child);
+    }
+  });
+  return { tabs, elements };
+}
+function Root({
+  form,
+  onSubmit,
+  children,
+  isLoading,
+  footer,
+  transformTabs
+}) {
+  const { t } = useTranslation();
+  const { tabs: rawTabs, elements } = useMemo2(
+    () => collectTabs(children),
+    [children]
+  );
+  const tabs = useMemo2(
+    () => transformTabs ? transformTabs(rawTabs) : rawTabs,
+    [transformTabs, rawTabs]
+  );
+  const {
+    activeTabId,
+    tabState,
+    visibleTabs,
+    isLastTab,
+    onNext,
+    onTabChange
+  } = useTabManagement({
+    tabs,
+    form
+  });
+  const visibleElements = elements.filter((el) => {
+    const meta = resolveTabMeta(el);
+    return meta && visibleTabs.some((vt) => vt.id === meta.id);
+  });
+  return /* @__PURE__ */ jsx(TabbedFormContext.Provider, { value: form, children: /* @__PURE__ */ jsx(RouteFocusModal.Form, { form, children: /* @__PURE__ */ jsxs(
+    KeyboundForm,
+    {
+      onKeyDown: (e) => {
+        if (e.key === "Enter") {
+          if (e.target instanceof HTMLTextAreaElement && !(e.metaKey || e.ctrlKey)) {
+            return;
+          }
+          e.preventDefault();
+          if (e.metaKey || e.ctrlKey) {
+            if (isLoading) {
+              return;
+            }
+            if (!isLastTab) {
+              e.preventDefault();
+              e.stopPropagation();
+              onNext();
+              return;
+            }
+            onSubmit();
+          }
+        }
+      },
+      onSubmit,
+      className: "flex h-full flex-col",
+      children: [
+        /* @__PURE__ */ jsxs(
+          ProgressTabs,
+          {
+            value: activeTabId,
+            onValueChange: onTabChange,
+            className: "flex h-full flex-col overflow-hidden",
+            children: [
+              /* @__PURE__ */ jsx(RouteFocusModal.Header, { children: /* @__PURE__ */ jsx("div", { className: "-my-2 w-full border-l", children: /* @__PURE__ */ jsx(ProgressTabs.List, { className: "justify-start-start flex w-full items-center", children: visibleTabs.map((tab) => /* @__PURE__ */ jsx(
+                ProgressTabs.Trigger,
+                {
+                  status: tabState[tab.id] ?? "not-started",
+                  value: tab.id,
+                  className: "max-w-[200px] truncate",
+                  children: tab.label ?? t(tab.labelKey)
+                },
+                tab.id
+              )) }) }) }),
+              /* @__PURE__ */ jsx(RouteFocusModal.Body, { className: "size-full overflow-hidden", children: visibleElements.map((element) => {
+                const meta = resolveTabMeta(element);
+                return /* @__PURE__ */ jsx(
+                  ProgressTabs.Content,
+                  {
+                    className: "size-full overflow-y-auto",
+                    value: meta.id,
+                    children: element
+                  },
+                  meta.id
+                );
+              }) })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx(RouteFocusModal.Footer, { children: footer ? footer({ isLastTab, onNext, isLoading }) : /* @__PURE__ */ jsx(
+          DefaultFooter,
+          {
+            isLastTab,
+            onNext,
+            isLoading
+          }
+        ) })
+      ]
+    }
+  ) }) });
+}
+var DefaultFooter = ({
+  isLastTab,
+  onNext,
+  isLoading
+}) => {
+  const { t } = useTranslation();
+  return /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-end gap-x-2", children: [
+    /* @__PURE__ */ jsx(RouteFocusModal.Close, { asChild: true, children: /* @__PURE__ */ jsx(Button, { variant: "secondary", size: "small", children: t("actions.cancel") }) }),
+    isLastTab ? /* @__PURE__ */ jsx(
+      Button,
+      {
+        type: "submit",
+        variant: "primary",
+        size: "small",
+        isLoading,
+        children: t("actions.save")
+      },
+      "submit-button"
+    ) : /* @__PURE__ */ jsx(
+      Button,
+      {
+        type: "button",
+        variant: "primary",
+        size: "small",
+        onClick: () => onNext(),
+        children: t("actions.continue")
+      },
+      "next-button"
+    )
+  ] });
+};
+var Tab = ({
+  children
+}) => {
+  return /* @__PURE__ */ jsx("div", { className: "flex flex-col items-center p-16", children: /* @__PURE__ */ jsx("div", { className: "flex w-full max-w-[720px] flex-col gap-y-8", children }) });
+};
+var TabbedForm = Object.assign(Root, { Tab, useForm: useTabbedForm });
+
+// src/components/tabbed-form/types.ts
+var defineTabMeta = (meta) => {
+  if (process.env.NODE_ENV !== "production") {
+    if (!meta.id) {
+      console.warn("[TabbedForm] Tab meta is missing required 'id' field");
+    }
+    if (!meta.labelKey && !meta.label) {
+      console.warn(
+        `[TabbedForm] Tab "${meta.id}" has neither 'labelKey' nor 'label' \u2014 the tab header will be empty`
+      );
+    }
+  }
+  return meta;
+};
+
+export {
+  useTabbedForm,
+  TabbedForm,
+  defineTabMeta
+};

package/dist/chunk-XSX255FK.js

@@ -0,0 +1,12 @@
+// src/lib/format-currency.ts
+var formatCurrency = (amount, currency) => {
+  return new Intl.NumberFormat(void 0, {
+    style: "currency",
+    currency,
+    signDisplay: "auto"
+  }).format(amount);
+};
+
+export {
+  formatCurrency
+};

package/dist/chunk-Y2M536WR.js

@@ -0,0 +1,67 @@
+// src/pages/orders/order-detail/constants.ts
+var DEFAULT_PROPERTIES = [
+  "id",
+  "status",
+  "created_at",
+  "canceled_at",
+  "email",
+  "display_id",
+  "currency_code",
+  "metadata",
+  // --- TOTALS ---
+  "total",
+  "credit_line_total",
+  "item_subtotal",
+  "item_total",
+  "item_tax_total",
+  "original_item_tax_total",
+  "item_discount_total",
+  "shipping_subtotal",
+  "original_total",
+  "original_tax_total",
+  "subtotal",
+  "discount_total",
+  "discount_subtotal",
+  "shipping_total",
+  "shipping_tax_total",
+  "original_shipping_tax_total",
+  "shipping_discount_total",
+  "tax_total",
+  "refundable_total",
+  "order_change"
+];
+var DEFAULT_RELATIONS = [
+  "*customer",
+  "*items",
+  // -> we get LineItem here with added `quantity` and `detail` which is actually an OrderItem (which is a parent object to LineItem in the DB)
+  "*items.variant",
+  "*items.variant.product",
+  "*items.variant.options",
+  "+items.variant.manage_inventory",
+  "*items.variant.inventory_items.inventory",
+  "+items.variant.inventory_items.required_quantity",
+  "+summary",
+  "*shipping_address",
+  "*billing_address",
+  "*sales_channel",
+  // "*promotions",
+  "*shipping_methods",
+  "*credit_lines",
+  "*fulfillments",
+  "+fulfillments.shipping_option.service_zone.fulfillment_set.type",
+  "*fulfillments.items",
+  "*fulfillments.labels",
+  "*fulfillments.labels",
+  "*payment_collections",
+  "*payment_collections.payments",
+  "*payment_collections.payments.refunds",
+  "*payment_collections.payments.refunds.refund_reason",
+  "region.automatic_taxes"
+];
+var DEFAULT_FIELDS = `${DEFAULT_PROPERTIES.join(
+  ","
+)},${DEFAULT_RELATIONS.join(",")}`;
+
+export {
+  DEFAULT_FIELDS
+};

package/dist/chunk-Y456KVIN.js

@@ -0,0 +1,116 @@
+// src/pages/categories/common/utils.ts
+function getIsActiveProps(isActive, t) {
+  switch (isActive) {
+    case true:
+      return {
+        label: t("categories.fields.status.active"),
+        color: "green"
+      };
+    case false:
+      return {
+        label: t("categories.fields.status.inactive"),
+        color: "red"
+      };
+  }
+}
+function getIsInternalProps(isInternal, t) {
+  switch (isInternal) {
+    case true:
+      return {
+        label: t("categories.fields.visibility.internal"),
+        color: "blue"
+      };
+    case false:
+      return {
+        label: t("categories.fields.visibility.public"),
+        color: "green"
+      };
+  }
+}
+function getCategoryPath(category) {
+  if (!category) {
+    return [];
+  }
+  const path = category.parent_category ? getCategoryPath(category.parent_category) : [];
+  path.push({ id: category.id, name: category.name });
+  return path;
+}
+function getCategoryChildren(category) {
+  if (!category || !category.category_children) {
+    return [];
+  }
+  return category.category_children.map((child) => ({
+    id: child.id,
+    name: child.name
+  }));
+}
+var insertCategoryTreeItem = (categories, newItem) => {
+  const seen = /* @__PURE__ */ new Set();
+  const remove = (items, id) => {
+    const stack = [...items];
+    const result = [];
+    while (stack.length > 0) {
+      const item = stack.pop();
+      if (item.id !== id) {
+        if (item.category_children) {
+          item.category_children = remove(item.category_children, id);
+        }
+        result.push(item);
+      }
+    }
+    return result;
+  };
+  const insert = (items) => {
+    const stack = [...items];
+    while (stack.length > 0) {
+      const item = stack.pop();
+      if (seen.has(item.id)) {
+        continue;
+      }
+      seen.add(item.id);
+      if (item.id === newItem.parent_category_id) {
+        if (!item.category_children) {
+          item.category_children = [];
+        }
+        if (newItem.rank === null) {
+          item.category_children.push(newItem);
+        } else {
+          item.category_children.splice(newItem.rank, 0, newItem);
+        }
+        item.category_children.forEach((child, index) => {
+          child.rank = index;
+        });
+        item.category_children.sort((a, b) => (a.rank ?? 0) - (b.rank ?? 0));
+        return categories;
+      }
+      if (item.category_children) {
+        stack.push(...item.category_children);
+      }
+    }
+    return items;
+  };
+  categories = remove(categories, newItem.id);
+  if (newItem.parent_category_id === null && newItem.rank === null) {
+    categories.unshift(newItem);
+    categories.forEach((child, index) => {
+      child.rank = index;
+    });
+  } else if (newItem.parent_category_id === null && newItem.rank !== null) {
+    categories.splice(newItem.rank, 0, newItem);
+    categories.forEach((child, index) => {
+      child.rank = index;
+    });
+  } else {
+    categories = insert(categories);
+  }
+  categories.sort((a, b) => (a.rank ?? 0) - (b.rank ?? 0));
+  return categories;
+};
+
+export {
+  getIsActiveProps,
+  getIsInternalProps,
+  getCategoryPath,
+  getCategoryChildren,
+  insertCategoryTreeItem
+};

package/dist/chunk-Y7QKP6QU.js

@@ -0,0 +1,35 @@
+// src/hooks/use-document-direction.tsx
+import { useEffect, useState } from "react";
+var useDocumentDirection = () => {
+  const [direction, setDirection] = useState(() => {
+    if (typeof document !== "undefined") {
+      return document.documentElement.getAttribute("dir") || void 0;
+    }
+    return void 0;
+  });
+  useEffect(() => {
+    if (typeof document === "undefined") {
+      return;
+    }
+    const observer = new MutationObserver((mutations) => {
+      mutations.forEach((mutation) => {
+        if (mutation.type === "attributes" && mutation.attributeName === "dir" && mutation.target === document.documentElement) {
+          const newDirection = document.documentElement.getAttribute("dir");
+          setDirection(newDirection || void 0);
+        }
+      });
+    });
+    observer.observe(document.documentElement, {
+      attributes: true,
+      attributeFilter: ["dir"]
+    });
+    return () => {
+      observer.disconnect();
+    };
+  }, []);
+  return direction;
+};
+
+export {
+  useDocumentDirection
+};