@mercurjs/admin 2.0.0-canary.100

package/dist/chunk-6HJINLUB.js

@@ -0,0 +1,94 @@
+import {
+  getStylizedAmount
+} from "./chunk-PXYDR7WQ.js";
+import {
+  SingleColumnPage
+} from "./chunk-XIZLPYEE.js";
+import {
+  SingleColumnPageSkeleton
+} from "./chunk-INNFZYX2.js";
+import {
+  usePayout
+} from "./chunk-L7DIEO5B.js";
+
+// src/pages/payouts/payout-detail/payout-detail.tsx
+import { Children } from "react";
+import { useParams } from "react-router-dom";
+
+// src/pages/payouts/payout-detail/components/payout-general-section.tsx
+import { Container, Heading, StatusBadge, Text } from "@medusajs/ui";
+import { useTranslation } from "react-i18next";
+import { jsx, jsxs } from "react/jsx-runtime";
+var payoutStatusColor = (status) => {
+  switch (status) {
+    case "paid":
+      return "green";
+    case "processing":
+      return "orange";
+    case "pending":
+      return "grey";
+    case "failed":
+    case "canceled":
+      return "red";
+    default:
+      return "grey";
+  }
+};
+var PayoutGeneralSection = ({ payout }) => {
+  const { t } = useTranslation();
+  const statusText = payout.status.charAt(0).toUpperCase() + payout.status.slice(1);
+  return /* @__PURE__ */ jsxs(Container, { className: "divide-y p-0", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between px-6 py-4", children: [
+      /* @__PURE__ */ jsxs(Heading, { children: [
+        "#",
+        payout.display_id
+      ] }),
+      /* @__PURE__ */ jsx("div", { className: "flex items-center gap-x-2", children: /* @__PURE__ */ jsx(StatusBadge, { color: payoutStatusColor(payout.status), children: statusText }) })
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "text-ui-fg-subtle grid grid-cols-2 items-center px-6 py-4", children: [
+      /* @__PURE__ */ jsx(Text, { size: "small", leading: "compact", weight: "plus", children: t("fields.amount") }),
+      /* @__PURE__ */ jsx(Text, { size: "small", leading: "compact", children: getStylizedAmount(payout.amount, payout.currency_code) })
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "text-ui-fg-subtle grid grid-cols-2 items-center px-6 py-4", children: [
+      /* @__PURE__ */ jsx(Text, { size: "small", leading: "compact", weight: "plus", children: t("fields.createdAt") }),
+      /* @__PURE__ */ jsx(Text, { size: "small", leading: "compact", children: new Date(payout.created_at).toLocaleDateString(void 0, {
+        year: "numeric",
+        month: "long",
+        day: "numeric",
+        hour: "2-digit",
+        minute: "2-digit"
+      }) })
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "text-ui-fg-subtle grid grid-cols-2 items-center px-6 py-4", children: [
+      /* @__PURE__ */ jsx(Text, { size: "small", leading: "compact", weight: "plus", children: t("fields.updatedAt") }),
+      /* @__PURE__ */ jsx(Text, { size: "small", leading: "compact", children: new Date(payout.updated_at).toLocaleDateString(void 0, {
+        year: "numeric",
+        month: "long",
+        day: "numeric",
+        hour: "2-digit",
+        minute: "2-digit"
+      }) })
+    ] })
+  ] });
+};
+
+// src/pages/payouts/payout-detail/payout-detail.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var Root = ({ children }) => {
+  const { id } = useParams();
+  const { payout, isLoading, isError, error } = usePayout(id);
+  if (isLoading || !payout) {
+    return /* @__PURE__ */ jsx2(SingleColumnPageSkeleton, { sections: 1 });
+  }
+  if (isError) {
+    throw error;
+  }
+  return Children.count(children) > 0 ? /* @__PURE__ */ jsx2(SingleColumnPage, { data: payout, showJSON: true, showMetadata: true, children }) : /* @__PURE__ */ jsx2(SingleColumnPage, { data: payout, showJSON: true, showMetadata: true, children: /* @__PURE__ */ jsx2(PayoutGeneralSection, { payout }) });
+};
+var PayoutDetailPage = Object.assign(Root, {
+  GeneralSection: PayoutGeneralSection
+});
+
+export {
+  PayoutDetailPage
+};

package/dist/chunk-6IJMSVC6.js

@@ -0,0 +1,16 @@
+// src/pages/price-lists/common/constants.ts
+var PriceListStatus = /* @__PURE__ */ ((PriceListStatus2) => {
+  PriceListStatus2["ACTIVE"] = "active";
+  PriceListStatus2["DRAFT"] = "draft";
+  return PriceListStatus2;
+})(PriceListStatus || {});
+var PriceListType = /* @__PURE__ */ ((PriceListType2) => {
+  PriceListType2["SALE"] = "sale";
+  PriceListType2["OVERRIDE"] = "override";
+  return PriceListType2;
+})(PriceListType || {});
+
+export {
+  PriceListStatus,
+  PriceListType
+};

package/dist/chunk-6S72GJRI.js

@@ -0,0 +1,142 @@
+import {
+  useProductTags
+} from "./chunk-YAMNPEPW.js";
+import {
+  useProductTypes
+} from "./chunk-EWFOFSF7.js";
+import {
+  useSellers
+} from "./chunk-HPQG3PEA.js";
+import {
+  useSalesChannels
+} from "./chunk-QUTZUW55.js";
+
+// src/hooks/table/filters/use-product-table-filters.tsx
+import { useTranslation } from "react-i18next";
+var useProductTableFilters = (exclude) => {
+  const { t } = useTranslation();
+  const isProductTypeExcluded = exclude?.includes("product_types");
+  const { product_types } = useProductTypes(
+    {
+      limit: 1e3,
+      offset: 0
+    },
+    {
+      enabled: !isProductTypeExcluded
+    }
+  );
+  const isProductTagExcluded = exclude?.includes("product_tags");
+  const { product_tags } = useProductTags({
+    limit: 1e3,
+    offset: 0
+  });
+  const { sellers } = useSellers({
+    limit: 1e3,
+    fields: "id,name"
+  });
+  const isSalesChannelExcluded = exclude?.includes("sales_channel_id");
+  const { sales_channels } = useSalesChannels(
+    {
+      limit: 1e3,
+      fields: "id,name"
+    },
+    {
+      enabled: !isSalesChannelExcluded
+    }
+  );
+  let filters = [];
+  if (product_types && !isProductTypeExcluded) {
+    const typeFilter = {
+      key: "type_id",
+      label: t("fields.type"),
+      type: "select",
+      multiple: true,
+      searchable: true,
+      options: product_types.map((t2) => ({
+        label: t2.value,
+        value: t2.id
+      }))
+    };
+    filters = [...filters, typeFilter];
+  }
+  if (product_tags && !isProductTagExcluded) {
+    const tagFilter = {
+      key: "tag_id",
+      label: t("fields.tag"),
+      type: "select",
+      multiple: true,
+      searchable: true,
+      options: product_tags.map((t2) => ({
+        label: t2.value,
+        value: t2.id
+      }))
+    };
+    filters = [...filters, tagFilter];
+  }
+  if (sales_channels) {
+    const salesChannelFilter = {
+      key: "sales_channel_id",
+      label: t("fields.salesChannel"),
+      type: "select",
+      multiple: true,
+      searchable: true,
+      options: sales_channels.map((s) => ({
+        label: s.name,
+        value: s.id
+      }))
+    };
+    filters = [...filters, salesChannelFilter];
+  }
+  const statusFilter = {
+    key: "status",
+    label: t("fields.status"),
+    type: "select",
+    multiple: true,
+    options: [
+      {
+        label: t("products.productStatus.draft"),
+        value: "draft"
+      },
+      {
+        label: t("products.productStatus.proposed"),
+        value: "proposed"
+      },
+      {
+        label: t("products.productStatus.published"),
+        value: "published"
+      },
+      {
+        label: t("products.productStatus.rejected"),
+        value: "rejected"
+      }
+    ]
+  };
+  const dateFilters = [
+    { label: t("fields.createdAt"), key: "created_at" },
+    { label: t("fields.updatedAt"), key: "updated_at" }
+  ].map((f) => ({
+    key: f.key,
+    label: f.label,
+    type: "date"
+  }));
+  if (sellers) {
+    const sellerFilter = {
+      key: "seller_id",
+      label: t("sellers.domain"),
+      type: "select",
+      multiple: true,
+      searchable: true,
+      options: sellers.map((s) => ({
+        label: s.name,
+        value: s.id
+      }))
+    };
+    filters = [...filters, sellerFilter];
+  }
+  filters = [...filters, statusFilter, ...dateFilters];
+  return filters;
+};
+
+export {
+  useProductTableFilters
+};

package/dist/chunk-77R2QD4O.js

@@ -0,0 +1,337 @@
+import {
+  optionalFloat,
+  optionalInt
+} from "./chunk-UXD3VNBO.js";
+import {
+  castNumber
+} from "./chunk-SMQT3ZNO.js";
+import {
+  i18n
+} from "./chunk-NYWESQ6J.js";
+import {
+  FileUpload
+} from "./chunk-TN4TIT7O.js";
+import {
+  Form
+} from "./chunk-3QSRE5LS.js";
+
+// src/pages/products/product-create/constants.ts
+import { z } from "zod";
+
+// src/pages/products/product-create/utils.ts
+var normalizeProductFormValues = (values) => {
+  const thumbnail = values.media?.find((media) => media.isThumbnail)?.url;
+  const images = values.media?.filter((media) => !media.isThumbnail).map((media) => ({ url: media.url }));
+  return {
+    status: values.status,
+    is_giftcard: false,
+    ...values.seller_id ? { additional_data: { seller_id: values.seller_id } } : {},
+    tags: values?.tags?.length ? values.tags?.map((tag) => ({ id: tag })) : void 0,
+    sales_channels: values?.sales_channels?.length ? values.sales_channels?.map((sc) => ({ id: sc.id })) : void 0,
+    images,
+    collection_id: values.collection_id || void 0,
+    shipping_profile_id: values.shipping_profile_id || void 0,
+    categories: values.categories.map((id) => ({ id })),
+    type_id: values.type_id || void 0,
+    handle: values.handle?.trim(),
+    origin_country: values.origin_country || void 0,
+    material: values.material || void 0,
+    mid_code: values.mid_code || void 0,
+    hs_code: values.hs_code || void 0,
+    thumbnail,
+    title: values.title.trim(),
+    subtitle: values.subtitle?.trim(),
+    description: values.description?.trim(),
+    discountable: values.discountable,
+    width: values.width ? parseFloat(values.width) : void 0,
+    length: values.length ? parseFloat(values.length) : void 0,
+    height: values.height ? parseFloat(values.height) : void 0,
+    weight: values.weight ? parseFloat(values.weight) : void 0,
+    options: values.options.filter((o) => o.title),
+    // clean temp. values
+    variants: normalizeVariants(
+      values.variants.filter((variant) => variant.should_create),
+      values.regionsCurrencyMap
+    )
+  };
+};
+var normalizeVariants = (variants, regionsCurrencyMap) => {
+  return variants.map((variant) => ({
+    title: variant.title || Object.values(variant.options || {}).join(" / "),
+    options: variant.options,
+    sku: variant.sku || void 0,
+    manage_inventory: !!variant.manage_inventory,
+    allow_backorder: !!variant.allow_backorder,
+    variant_rank: variant.variant_rank,
+    inventory_items: variant.inventory.map((i) => {
+      const quantity = i.required_quantity ? castNumber(i.required_quantity) : null;
+      if (!i.inventory_item_id || !quantity) {
+        return false;
+      }
+      return {
+        ...i,
+        required_quantity: quantity
+      };
+    }).filter(
+      (item) => item !== false
+    ),
+    prices: Object.entries(variant.prices || {}).map(([key, value]) => {
+      if (value === "" || value === void 0) {
+        return void 0;
+      }
+      if (key.startsWith("reg_")) {
+        return {
+          currency_code: regionsCurrencyMap[key],
+          amount: castNumber(value),
+          rules: { region_id: key }
+        };
+      } else {
+        return {
+          currency_code: key,
+          amount: castNumber(value)
+        };
+      }
+    }).filter((v) => !!v)
+  }));
+};
+var decorateVariantsWithDefaultValues = (variants) => {
+  return variants.map((variant) => ({
+    ...variant,
+    title: variant.title || "",
+    sku: variant.sku || "",
+    manage_inventory: variant.manage_inventory || false,
+    allow_backorder: variant.allow_backorder || false,
+    inventory_kit: variant.inventory_kit || false
+  }));
+};
+
+// src/pages/products/product-create/constants.ts
+var MediaSchema = z.object({
+  id: z.string().optional(),
+  url: z.string(),
+  isThumbnail: z.boolean(),
+  file: z.any().nullable()
+  // File
+});
+var ProductCreateVariantSchema = z.object({
+  should_create: z.boolean(),
+  is_default: z.boolean().optional(),
+  title: z.string(),
+  upc: z.string().optional(),
+  ean: z.string().optional(),
+  barcode: z.string().optional(),
+  mid_code: z.string().optional(),
+  hs_code: z.string().optional(),
+  width: optionalInt,
+  height: optionalInt,
+  length: optionalInt,
+  weight: optionalInt,
+  material: z.string().optional(),
+  origin_country: z.string().optional(),
+  sku: z.string().optional(),
+  manage_inventory: z.boolean().optional(),
+  allow_backorder: z.boolean().optional(),
+  inventory_kit: z.boolean().optional(),
+  options: z.record(z.string(), z.string()),
+  variant_rank: z.number(),
+  prices: z.record(z.string(), optionalFloat).optional(),
+  inventory: z.array(
+    z.object({
+      inventory_item_id: z.string(),
+      required_quantity: optionalInt
+    })
+  ).optional()
+});
+var ProductCreateOptionSchema = z.object({
+  title: z.string(),
+  values: z.array(z.string()).min(1)
+});
+var ProductCreateSchema = z.object({
+  title: z.string().min(1),
+  subtitle: z.string().optional(),
+  handle: z.string().optional(),
+  description: z.string().optional(),
+  discountable: z.boolean(),
+  type_id: z.string().optional(),
+  collection_id: z.string().optional(),
+  shipping_profile_id: z.string().optional(),
+  categories: z.array(z.string()),
+  tags: z.array(z.string()).optional(),
+  seller_id: z.string().optional(),
+  sales_channels: z.array(
+    z.object({
+      id: z.string(),
+      name: z.string()
+    })
+  ).optional(),
+  origin_country: z.string().optional(),
+  material: z.string().optional(),
+  width: z.string().optional(),
+  length: z.string().optional(),
+  height: z.string().optional(),
+  weight: z.string().optional(),
+  mid_code: z.string().optional(),
+  hs_code: z.string().optional(),
+  options: z.array(ProductCreateOptionSchema).min(1),
+  enable_variants: z.boolean(),
+  variants: z.array(ProductCreateVariantSchema).min(1),
+  media: z.array(MediaSchema).optional()
+}).superRefine((data, ctx) => {
+  if (data.variants.every((v) => !v.should_create)) {
+    return ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["variants"],
+      message: "invalid_length"
+    });
+  }
+  const skus = /* @__PURE__ */ new Set();
+  data.variants.forEach((v, index) => {
+    if (v.sku) {
+      if (skus.has(v.sku)) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: [`variants.${index}.sku`],
+          message: i18n.t("products.create.errors.uniqueSku")
+        });
+      }
+      skus.add(v.sku);
+    }
+  });
+});
+var EditProductMediaSchema = z.object({
+  media: z.array(MediaSchema)
+});
+var PRODUCT_CREATE_FORM_DEFAULTS = {
+  discountable: true,
+  tags: [],
+  sales_channels: [],
+  options: [
+    {
+      title: "Default option",
+      values: ["Default option value"]
+    }
+  ],
+  variants: decorateVariantsWithDefaultValues([
+    {
+      title: "Default variant",
+      should_create: true,
+      variant_rank: 0,
+      options: {
+        "Default option": "Default option value"
+      },
+      inventory: [{ inventory_item_id: "", required_quantity: "" }],
+      is_default: true
+    }
+  ]),
+  enable_variants: false,
+  media: [],
+  categories: [],
+  seller_id: "",
+  collection_id: "",
+  shipping_profile_id: "",
+  description: "",
+  handle: "",
+  height: "",
+  hs_code: "",
+  length: "",
+  material: "",
+  mid_code: "",
+  origin_country: "",
+  subtitle: "",
+  title: "",
+  type_id: "",
+  weight: "",
+  width: ""
+};
+
+// src/pages/products/common/components/upload-media-form-item/upload-media-form-item.tsx
+import { useCallback } from "react";
+import { useTranslation } from "react-i18next";
+import { jsx, jsxs } from "react/jsx-runtime";
+var SUPPORTED_FORMATS = [
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/webp",
+  "image/heic",
+  "image/svg+xml"
+];
+var SUPPORTED_FORMATS_FILE_EXTENSIONS = [
+  ".jpeg",
+  ".png",
+  ".gif",
+  ".webp",
+  ".heic",
+  ".svg"
+];
+var UploadMediaFormItem = ({
+  form,
+  append,
+  showHint = true
+}) => {
+  const { t } = useTranslation();
+  const hasInvalidFiles = useCallback(
+    (fileList) => {
+      const invalidFile = fileList.find(
+        (f) => !SUPPORTED_FORMATS.includes(f.file.type)
+      );
+      if (invalidFile) {
+        form.setError("media", {
+          type: "invalid_file",
+          message: t("products.media.invalidFileType", {
+            name: invalidFile.file.name,
+            types: SUPPORTED_FORMATS_FILE_EXTENSIONS.join(", ")
+          })
+        });
+        return true;
+      }
+      return false;
+    },
+    [form, t]
+  );
+  const onUploaded = useCallback(
+    (files) => {
+      form.clearErrors("media");
+      if (hasInvalidFiles(files)) {
+        return;
+      }
+      files.forEach((f) => append({ ...f, isThumbnail: false }));
+    },
+    [form, append, hasInvalidFiles]
+  );
+  return /* @__PURE__ */ jsx(
+    Form.Field,
+    {
+      control: form.control,
+      name: "media",
+      render: () => {
+        return /* @__PURE__ */ jsx(Form.Item, { children: /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-y-2", children: [
+          /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-y-1", children: [
+            /* @__PURE__ */ jsx(Form.Label, { optional: true, children: t("products.media.label") }),
+            showHint && /* @__PURE__ */ jsx(Form.Hint, { children: t("products.media.editHint") })
+          ] }),
+          /* @__PURE__ */ jsx(Form.Control, { children: /* @__PURE__ */ jsx(
+            FileUpload,
+            {
+              label: t("products.media.uploadImagesLabel"),
+              hint: t("products.media.uploadImagesHint"),
+              hasError: !!form.formState.errors.media,
+              formats: SUPPORTED_FORMATS,
+              onUploaded
+            }
+          ) }),
+          /* @__PURE__ */ jsx(Form.ErrorMessage, {})
+        ] }) });
+      }
+    }
+  );
+};
+
+export {
+  normalizeProductFormValues,
+  decorateVariantsWithDefaultValues,
+  ProductCreateSchema,
+  EditProductMediaSchema,
+  PRODUCT_CREATE_FORM_DEFAULTS,
+  UploadMediaFormItem
+};

package/dist/chunk-7AV5EJJ5.js

@@ -0,0 +1,29 @@
+// src/components/common/link-button/link-button.tsx
+import { clx } from "@medusajs/ui";
+import { Link } from "react-router-dom";
+import { jsx } from "react/jsx-runtime";
+var LinkButton = ({
+  className,
+  variant = "interactive",
+  ...props
+}) => {
+  return /* @__PURE__ */ jsx(
+    Link,
+    {
+      className: clx(
+        "transition-fg txt-compact-small-plus rounded-[4px] outline-none",
+        "focus-visible:shadow-borders-focus",
+        {
+          "text-ui-fg-interactive hover:text-ui-fg-interactive-hover": variant === "interactive",
+          "text-ui-fg-base hover:text-ui-fg-subtle": variant === "primary"
+        },
+        className
+      ),
+      ...props
+    }
+  );
+};
+
+export {
+  LinkButton
+};