@mercurjs/vendor 2.0.0-canary.0

package/dist/chunk-PLSJ74T2.js

@@ -0,0 +1,298 @@
+import {
+  useProductTableColumns
+} from "./chunk-GC33DBKG.js";
+import {
+  useProductTableQuery
+} from "./chunk-4MFMCZEJ.js";
+import {
+  useProductTableFilters
+} from "./chunk-WA3IVAUC.js";
+import {
+  _DataTable,
+  useDataTable
+} from "./chunk-WHTS4G5K.js";
+import {
+  SingleColumnPage
+} from "./chunk-RM5RSDYP.js";
+import {
+  ActionMenu
+} from "./chunk-BDGZ4EQO.js";
+import {
+  useBulkDeleteProducts,
+  useDeleteProduct,
+  useProducts
+} from "./chunk-WPFTRRWV.js";
+
+// src/pages/products/product-list-page.tsx
+import { Children as Children3 } from "react";
+
+// src/pages/products/_components/product-list-table/product-list-table.tsx
+import { Children as Children2 } from "react";
+import { Container } from "@medusajs/ui";
+import { Outlet } from "react-router-dom";
+
+// src/pages/products/_components/product-list-table/product-list-header.tsx
+import { Children } from "react";
+import { useTranslation } from "react-i18next";
+import { Link } from "react-router-dom";
+import { Button, Heading } from "@medusajs/ui";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var ProductListTitle = () => {
+  const { t } = useTranslation();
+  return /* @__PURE__ */ jsx(Heading, { level: "h2", children: t("products.domain") });
+};
+var ProductListCreateButton = () => {
+  const { t } = useTranslation();
+  return /* @__PURE__ */ jsx(Button, { size: "small", variant: "primary", asChild: true, children: /* @__PURE__ */ jsx(Link, { to: "create", children: t("actions.create") }) });
+};
+var ProductListActions = ({ children }) => {
+  return /* @__PURE__ */ jsx("div", { className: "flex items-center justify-center gap-x-2", children: Children.count(children) > 0 ? children : /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsx(ProductListCreateButton, {}) }) });
+};
+var ProductListHeader = ({ children }) => {
+  return /* @__PURE__ */ jsx("div", { className: "flex items-center justify-between px-6 py-4", children: Children.count(children) > 0 ? children : /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(ProductListTitle, {}),
+    /* @__PURE__ */ jsx(ProductListActions, {})
+  ] }) });
+};
+
+// src/pages/products/_components/product-list-table/product-list-data-table.tsx
+import { Checkbox, toast, usePrompt } from "@medusajs/ui";
+import { keepPreviousData } from "@tanstack/react-query";
+import {
+  createColumnHelper
+} from "@tanstack/react-table";
+import { useMemo, useState } from "react";
+import { useTranslation as useTranslation2 } from "react-i18next";
+import { Trash } from "@medusajs/icons";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var PAGE_SIZE = 10;
+var ProductListDataTable = () => {
+  const { t } = useTranslation2();
+  const [rowSelection, setRowSelection] = useState({});
+  const updater = (newSelection) => {
+    const update = typeof newSelection === "function" ? newSelection(rowSelection) : newSelection;
+    setRowSelection(update);
+  };
+  const { searchParams, raw } = useProductTableQuery({
+    pageSize: PAGE_SIZE
+  });
+  const { products, count, isLoading, isError, error } = useProducts(
+    searchParams,
+    {
+      placeholderData: keepPreviousData
+    }
+  );
+  const filters = useProductTableFilters();
+  const columns = useColumns();
+  const { table } = useDataTable({
+    data: products,
+    columns,
+    count,
+    enablePagination: true,
+    enableRowSelection: true,
+    pageSize: PAGE_SIZE,
+    getRowId: (row) => row?.id || "",
+    rowSelection: {
+      state: rowSelection,
+      updater
+    }
+  });
+  const { mutateAsync } = useBulkDeleteProducts();
+  const prompt = usePrompt();
+  const handleDelete = async () => {
+    const keys = Object.keys(rowSelection);
+    if (keys.length === 0) {
+      return;
+    }
+    const res = await prompt({
+      title: t("products.bulkDelete.title"),
+      description: t("products.bulkDelete.description", {
+        count: keys.length
+      }),
+      confirmText: t("actions.delete"),
+      cancelText: t("actions.cancel")
+    });
+    if (!res) {
+      return;
+    }
+    await mutateAsync(keys, {
+      onSuccess: () => {
+        setRowSelection({});
+        toast.success(
+          t("products.bulkDelete.success", {
+            count: keys.length
+          })
+        );
+      },
+      onError: (error2) => {
+        toast.error(t("products.bulkDelete.error"), {
+          description: error2.message
+        });
+      }
+    });
+  };
+  if (isError) {
+    throw error;
+  }
+  return /* @__PURE__ */ jsx2(
+    _DataTable,
+    {
+      table,
+      columns,
+      count,
+      pageSize: PAGE_SIZE,
+      filters,
+      search: true,
+      pagination: true,
+      isLoading,
+      queryObject: raw,
+      navigateTo: (row) => `${row.original.id}`,
+      orderBy: [
+        { key: "title", label: t("fields.title") },
+        {
+          key: "created_at",
+          label: t("fields.createdAt")
+        },
+        {
+          key: "updated_at",
+          label: t("fields.updatedAt")
+        }
+      ],
+      commands: [
+        {
+          action: handleDelete,
+          label: t("actions.delete"),
+          shortcut: "d"
+        }
+      ],
+      noRecords: {
+        title: t("products.list.noRecordsTitle"),
+        message: t("products.list.noRecordsMessage"),
+        action: {
+          to: "/products/create",
+          label: t("actions.add")
+        }
+      }
+    }
+  );
+};
+var ProductActions = ({ product }) => {
+  const { t } = useTranslation2();
+  const prompt = usePrompt();
+  const { mutateAsync } = useDeleteProduct(product.id);
+  const handleDelete = async () => {
+    const res = await prompt({
+      title: t("general.areYouSure"),
+      description: t("products.deleteWarning", {
+        title: product.title
+      }),
+      confirmText: t("actions.delete"),
+      cancelText: t("actions.cancel")
+    });
+    if (!res) {
+      return;
+    }
+    await mutateAsync(void 0, {
+      onSuccess: () => {
+        toast.success(t("products.toasts.delete.success.header"), {
+          description: t("products.toasts.delete.success.description", {
+            title: product.title
+          })
+        });
+      },
+      onError: (e) => {
+        toast.error(t("products.toasts.delete.error.header"), {
+          description: e.message
+        });
+      }
+    });
+  };
+  return /* @__PURE__ */ jsx2(
+    ActionMenu,
+    {
+      groups: [
+        {
+          actions: [
+            {
+              icon: /* @__PURE__ */ jsx2(Trash, {}),
+              label: t("actions.delete"),
+              onClick: handleDelete
+            }
+          ]
+        }
+      ]
+    }
+  );
+};
+var columnHelper = createColumnHelper();
+var useColumns = () => {
+  const { t } = useTranslation2();
+  const base = useProductTableColumns();
+  const columns = useMemo(
+    () => [
+      columnHelper.display({
+        id: "select",
+        header: ({ table }) => {
+          return /* @__PURE__ */ jsx2(
+            Checkbox,
+            {
+              checked: table.getIsSomePageRowsSelected() ? "indeterminate" : table.getIsAllPageRowsSelected(),
+              onCheckedChange: (value) => table.toggleAllPageRowsSelected(!!value)
+            }
+          );
+        },
+        cell: ({ row }) => {
+          return /* @__PURE__ */ jsx2(
+            Checkbox,
+            {
+              checked: row.getIsSelected(),
+              onCheckedChange: (value) => row.toggleSelected(!!value),
+              onClick: (e) => {
+                e.stopPropagation();
+              }
+            }
+          );
+        }
+      }),
+      ...base,
+      columnHelper.display({
+        id: "actions",
+        cell: ({ row }) => {
+          return /* @__PURE__ */ jsx2(ProductActions, { product: row.original });
+        }
+      })
+    ],
+    [base, t]
+  );
+  return columns;
+};
+
+// src/pages/products/_components/product-list-table/product-list-table.tsx
+import { Fragment as Fragment2, jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var ProductListTable = ({ children }) => {
+  return /* @__PURE__ */ jsxs2(Container, { className: "divide-y p-0", children: [
+    Children2.count(children) > 0 ? children : /* @__PURE__ */ jsxs2(Fragment2, { children: [
+      /* @__PURE__ */ jsx3(ProductListHeader, {}),
+      /* @__PURE__ */ jsx3(ProductListDataTable, {})
+    ] }),
+    /* @__PURE__ */ jsx3(Outlet, {})
+  ] });
+};
+
+// src/pages/products/product-list-page.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+var Root = ({ children }) => {
+  return /* @__PURE__ */ jsx4(SingleColumnPage, { children: Children3.count(children) > 0 ? children : /* @__PURE__ */ jsx4(ProductListTable, {}) });
+};
+var ProductListPage = Object.assign(Root, {
+  Table: ProductListTable,
+  Header: ProductListHeader,
+  HeaderTitle: ProductListTitle,
+  HeaderActions: ProductListActions,
+  HeaderCreateButton: ProductListCreateButton,
+  DataTable: ProductListDataTable
+});
+
+export {
+  ProductListPage
+};

package/dist/chunk-PVZBDWLK.js

@@ -0,0 +1,41 @@
+import {
+  useQueryParams
+} from "./chunk-THHRRYRS.js";
+
+// src/hooks/table/query/use-customer-table-query.tsx
+var useCustomerTableQuery = ({
+  prefix,
+  pageSize = 20
+}) => {
+  const queryObject = useQueryParams(
+    [
+      "offset",
+      "q",
+      "has_account",
+      "groups",
+      "order",
+      "created_at",
+      "updated_at"
+    ],
+    prefix
+  );
+  const { offset, groups, created_at, updated_at, has_account, q, order } = queryObject;
+  const searchParams = {
+    limit: pageSize,
+    offset: offset ? Number(offset) : 0,
+    groups: groups?.split(","),
+    has_account: has_account ? has_account === "true" : void 0,
+    order,
+    created_at: created_at ? JSON.parse(created_at) : void 0,
+    updated_at: updated_at ? JSON.parse(updated_at) : void 0,
+    q
+  };
+  return {
+    searchParams,
+    raw: queryObject
+  };
+};
+
+export {
+  useCustomerTableQuery
+};

package/dist/chunk-PWZKFTJS.js

@@ -0,0 +1,247 @@
+import {
+  PriceListUpdateProductsSchema,
+  usePriceListGridColumns
+} from "./chunk-TTFCO5HU.js";
+import {
+  isProductRow
+} from "./chunk-XRNDVICA.js";
+import {
+  DataGrid
+} from "./chunk-ZZ7VKT2S.js";
+import {
+  castNumber
+} from "./chunk-SMQT3ZNO.js";
+import {
+  KeyboundForm
+} from "./chunk-U2ZFCAPX.js";
+import {
+  RouteFocusModal,
+  useRouteModal
+} from "./chunk-3CK6OINO.js";
+import {
+  useBatchPriceListPrices
+} from "./chunk-RE7YXVFG.js";
+
+// src/pages/price-lists/[id]/products/[variant_id]/edit/price-list-prices-edit-form/price-list-prices-edit-form.tsx
+import { zodResolver } from "@hookform/resolvers/zod";
+import { Button, toast } from "@medusajs/ui";
+import { useRef } from "react";
+import { useForm } from "react-hook-form";
+import { useTranslation } from "react-i18next";
+import { z } from "zod";
+import { jsx, jsxs } from "react/jsx-runtime";
+var PricingProductPricesSchema = z.object({
+  products: PriceListUpdateProductsSchema
+});
+var PriceListPricesEditForm = ({
+  priceList,
+  products,
+  regions,
+  currencies,
+  pricePreferences
+}) => {
+  const { t } = useTranslation();
+  const { handleSuccess, setCloseOnEscape } = useRouteModal();
+  const initialValue = useRef(initRecord(priceList, products));
+  const form = useForm({
+    defaultValues: {
+      products: initialValue.current
+    },
+    resolver: zodResolver(PricingProductPricesSchema)
+  });
+  const { mutateAsync, isPending } = useBatchPriceListPrices(priceList.id);
+  const handleSubmit = form.handleSubmit(async (values) => {
+    const { products: products2 } = values;
+    const { pricesToDelete, pricesToCreate, pricesToUpdate } = sortPrices(
+      products2,
+      initialValue.current,
+      regions
+    );
+    mutateAsync(
+      {
+        delete: pricesToDelete,
+        update: pricesToUpdate,
+        create: pricesToCreate
+      },
+      {
+        onSuccess: () => {
+          toast.success(t("priceLists.products.edit.successToast"));
+          handleSuccess();
+        },
+        onError: (error) => {
+          toast.error(error.message);
+        }
+      }
+    );
+  });
+  const columns = usePriceListGridColumns({
+    currencies,
+    regions,
+    pricePreferences
+  });
+  return /* @__PURE__ */ jsx(RouteFocusModal.Form, { form, children: /* @__PURE__ */ jsxs(KeyboundForm, { onSubmit: handleSubmit, className: "flex size-full flex-col", children: [
+    /* @__PURE__ */ jsx(RouteFocusModal.Header, {}),
+    /* @__PURE__ */ jsx(RouteFocusModal.Body, { className: "flex flex-col overflow-hidden", children: /* @__PURE__ */ jsx(
+      DataGrid,
+      {
+        columns,
+        data: products,
+        getSubRows: (row) => {
+          if (isProductRow(row) && row.variants) {
+            return row.variants;
+          }
+        },
+        state: form,
+        onEditingChange: (editing) => setCloseOnEscape(!editing)
+      }
+    ) }),
+    /* @__PURE__ */ jsx(RouteFocusModal.Footer, { children: /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-end gap-x-2", children: [
+      /* @__PURE__ */ jsx(RouteFocusModal.Close, { asChild: true, children: /* @__PURE__ */ jsx(Button, { size: "small", variant: "secondary", children: t("actions.cancel") }) }),
+      /* @__PURE__ */ jsx(Button, { size: "small", type: "submit", isLoading: isPending, children: t("actions.save") })
+    ] }) })
+  ] }) });
+};
+function initRecord(priceList, products) {
+  const record = {};
+  const variantPrices = priceList.prices?.reduce((variants, price) => {
+    const variantObject = variants[price.variant_id] || {};
+    const isRegionPrice = !!price.rules?.region_id;
+    if (isRegionPrice) {
+      const regionId = price.rules.region_id;
+      variantObject.region_prices = {
+        ...variantObject.region_prices,
+        [regionId]: {
+          amount: price.amount.toString(),
+          id: price.id
+        }
+      };
+    } else {
+      variantObject.currency_prices = {
+        ...variantObject.currency_prices,
+        [price.currency_code]: {
+          amount: price.amount.toString(),
+          id: price.id
+        }
+      };
+    }
+    variants[price.variant_id] = variantObject;
+    return variants;
+  }, {});
+  for (const product of products) {
+    record[product.id] = {
+      variants: product.variants?.reduce((variants, variant) => {
+        const prices = variantPrices[variant.id] || {};
+        variants[variant.id] = prices;
+        return variants;
+      }, {}) || {}
+    };
+  }
+  return record;
+}
+function convertToPriceArray(data, regions) {
+  const prices = [];
+  const regionCurrencyMap = regions.reduce(
+    (map, region) => {
+      map[region.id] = region.currency_code;
+      return map;
+    },
+    {}
+  );
+  for (const [_productId, product] of Object.entries(data || {})) {
+    const { variants } = product || {};
+    for (const [variantId, variant] of Object.entries(variants || {})) {
+      const { currency_prices: currencyPrices, region_prices: regionPrices } = variant || {};
+      for (const [currencyCode, currencyPrice] of Object.entries(
+        currencyPrices || {}
+      )) {
+        if (currencyPrice?.amount !== "" && typeof currencyPrice?.amount !== "undefined") {
+          prices.push({
+            variantId,
+            currencyCode,
+            amount: castNumber(currencyPrice.amount),
+            id: currencyPrice.id
+          });
+        }
+      }
+      for (const [regionId, regionPrice] of Object.entries(
+        regionPrices || {}
+      )) {
+        if (regionPrice?.amount !== "" && typeof regionPrice?.amount !== "undefined") {
+          prices.push({
+            variantId,
+            regionId,
+            currencyCode: regionCurrencyMap[regionId],
+            amount: castNumber(regionPrice.amount),
+            id: regionPrice.id
+          });
+        }
+      }
+    }
+  }
+  return prices;
+}
+function createMapKey(obj) {
+  return `${obj.variantId}-${obj.currencyCode}-${obj.regionId || "none"}-${obj.id || "none"}`;
+}
+function comparePrices(initialPrices, newPrices) {
+  const pricesToUpdate = [];
+  const pricesToCreate = [];
+  const pricesToDelete = [];
+  const initialPriceMap = initialPrices.reduce(
+    (map, price) => {
+      map[createMapKey(price)] = price;
+      return map;
+    },
+    {}
+  );
+  const newPriceMap = newPrices.reduce(
+    (map, price) => {
+      map[createMapKey(price)] = price;
+      return map;
+    },
+    {}
+  );
+  const keys = /* @__PURE__ */ new Set([
+    ...Object.keys(initialPriceMap),
+    ...Object.keys(newPriceMap)
+  ]);
+  for (const key of keys) {
+    const initialPrice = initialPriceMap[key];
+    const newPrice = newPriceMap[key];
+    if (initialPrice && newPrice) {
+      if (isNaN(newPrice.amount) && newPrice.id) {
+        pricesToDelete.push(newPrice.id);
+      }
+      if (initialPrice.amount !== newPrice.amount && newPrice.id) {
+        pricesToUpdate.push({
+          id: newPrice.id,
+          variant_id: newPrice.variantId,
+          currency_code: newPrice.currencyCode,
+          rules: newPrice.regionId ? { region_id: newPrice.regionId } : void 0,
+          amount: newPrice.amount
+        });
+      }
+    }
+    if (!initialPrice && newPrice) {
+      pricesToCreate.push({
+        variant_id: newPrice.variantId,
+        currency_code: newPrice.currencyCode,
+        rules: newPrice.regionId ? { region_id: newPrice.regionId } : void 0,
+        amount: newPrice.amount
+      });
+    }
+    if (initialPrice && !newPrice && initialPrice.id) {
+      pricesToDelete.push(initialPrice.id);
+    }
+  }
+  return { pricesToDelete, pricesToCreate, pricesToUpdate };
+}
+function sortPrices(data, initialValue, regions) {
+  const initialPrices = convertToPriceArray(initialValue, regions);
+  const newPrices = convertToPriceArray(data, regions);
+  return comparePrices(initialPrices, newPrices);
+}
+
+export {
+  PriceListPricesEditForm
+};

package/dist/chunk-PXYDR7WQ.js

@@ -0,0 +1,48 @@
+import {
+  currencies
+} from "./chunk-IQPN4PZJ.js";
+
+// src/lib/money-amount-helpers.ts
+var getDecimalDigits = (currency) => {
+  return currencies[currency.toUpperCase()]?.decimal_digits ?? 0;
+};
+var getLocaleAmount = (amount, currencyCode) => {
+  const formatter = new Intl.NumberFormat([], {
+    style: "currency",
+    currencyDisplay: "narrowSymbol",
+    currency: currencyCode
+  });
+  return formatter.format(amount);
+};
+var getNativeSymbol = (currencyCode) => {
+  const formatted = new Intl.NumberFormat([], {
+    style: "currency",
+    currency: currencyCode,
+    currencyDisplay: "narrowSymbol"
+  }).format(0);
+  return formatted.replace(/\d/g, "").replace(/[.,]/g, "").trim();
+};
+var getStylizedAmount = (amount, currencyCode) => {
+  const symbol = getNativeSymbol(currencyCode);
+  const decimalDigits = getDecimalDigits(currencyCode);
+  const lessThanRoundingPrecission = isAmountLessThenRoundingError(
+    amount,
+    currencyCode
+  );
+  const total = amount.toLocaleString(void 0, {
+    minimumFractionDigits: decimalDigits,
+    maximumFractionDigits: decimalDigits,
+    signDisplay: lessThanRoundingPrecission ? "exceptZero" : "auto"
+  });
+  return `${symbol} ${total} ${currencyCode.toUpperCase()}`;
+};
+var isAmountLessThenRoundingError = (amount, currencyCode) => {
+  const decimalDigits = getDecimalDigits(currencyCode);
+  return Math.abs(amount) < 1 / 10 ** decimalDigits / 2;
+};
+
+export {
+  getLocaleAmount,
+  getStylizedAmount,
+  isAmountLessThenRoundingError
+};