@mercurjs/vendor 2.0.0-canary.0

package/dist/chunk-XRNDVICA.js

@@ -0,0 +1,85 @@
+import {
+  castNumber
+} from "./chunk-SMQT3ZNO.js";
+
+// src/pages/price-lists/common/utils.ts
+import { json } from "react-router-dom";
+var getValues = (priceList) => {
+  const startsAt = priceList.starts_at;
+  const endsAt = priceList.ends_at;
+  const isExpired = endsAt ? new Date(endsAt) < /* @__PURE__ */ new Date() : false;
+  const isScheduled = startsAt ? new Date(startsAt) > /* @__PURE__ */ new Date() : false;
+  const isDraft = priceList.status === "draft" /* DRAFT */;
+  return {
+    isExpired,
+    isScheduled,
+    isDraft
+  };
+};
+var getPriceListStatus = (t, priceList) => {
+  const { isExpired, isScheduled, isDraft } = getValues(priceList);
+  let text = t("priceLists.fields.status.options.active");
+  let color = "green";
+  let status = "active" /* ACTIVE */;
+  if (isDraft) {
+    color = "grey";
+    text = t("priceLists.fields.status.options.draft");
+    status = "draft" /* DRAFT */;
+  }
+  if (isExpired) {
+    color = "red";
+    text = t("priceLists.fields.status.options.expired");
+    status = "expired" /* EXPIRED */;
+  }
+  if (isScheduled) {
+    color = "orange";
+    text = t("priceLists.fields.status.options.scheduled");
+    status = "scheduled" /* SCHEDULED */;
+  }
+  return {
+    color,
+    text,
+    status
+  };
+};
+var isProductRow = (row) => {
+  return "variants" in row;
+};
+var extractPricesFromVariants = (variantId, variant, regions) => {
+  const extractPriceDetails = (price, priceType, id) => {
+    const currencyCode = priceType === "currency" ? id : regions.find((r) => r.id === id)?.currency_code;
+    if (!currencyCode) {
+      throw json({ message: "Currency code not found" }, 400);
+    }
+    return {
+      amount: castNumber(price.amount),
+      ...priceType === "region" ? { rules: { region_id: id } } : {},
+      currency_code: currencyCode,
+      variant_id: variantId
+    };
+  };
+  const currencyPrices = Object.entries(variant.currency_prices || {}).flatMap(
+    ([currencyCode, currencyPrice]) => {
+      return currencyPrice?.amount ? [extractPriceDetails(currencyPrice, "currency", currencyCode)] : [];
+    }
+  );
+  const regionPrices = Object.entries(variant.region_prices || {}).flatMap(
+    ([regionId, regionPrice]) => {
+      return regionPrice?.amount ? [extractPriceDetails(regionPrice, "region", regionId)] : [];
+    }
+  );
+  return [...currencyPrices, ...regionPrices];
+};
+var exctractPricesFromProducts = (products, regions) => {
+  return Object.values(products).flatMap(
+    ({ variants }) => Object.entries(variants).flatMap(
+      ([variantId, variant]) => extractPricesFromVariants(variantId, variant, regions)
+    )
+  );
+};
+
+export {
+  getPriceListStatus,
+  isProductRow,
+  exctractPricesFromProducts
+};

package/dist/chunk-XXZJISPX.js

@@ -0,0 +1,48 @@
+import {
+  StatusCell
+} from "./chunk-DB6ANJBO.js";
+import {
+  i18n
+} from "./chunk-QUNDGPF7.js";
+
+// src/lib/promotions.ts
+var promotionStatusMap = {
+  ["ACTIVE" /* ACTIVE */]: ["green", i18n.t("statuses.active")],
+  ["INACTIVE" /* INACTIVE */]: ["red", i18n.t("statuses.inactive")],
+  ["DRAFT" /* DRAFT */]: ["grey", i18n.t("statuses.draft")],
+  ["SCHEDULED" /* SCHEDULED */]: [
+    "orange",
+    `${i18n.t("promotions.fields.campaign")} ${i18n.t("statuses.scheduled")?.toLowerCase()}`
+  ],
+  ["EXPIRED" /* EXPIRED */]: [
+    "red",
+    `${i18n.t("promotions.fields.campaign")} ${i18n.t("statuses.expired")?.toLowerCase()}`
+  ]
+};
+var getPromotionStatus = (promotion) => {
+  const date = /* @__PURE__ */ new Date();
+  const campaign = promotion.campaign;
+  if (!campaign) {
+    return promotionStatusMap[promotion.status.toUpperCase()];
+  }
+  if (campaign.starts_at && new Date(campaign.starts_at) > date) {
+    return promotionStatusMap["SCHEDULED" /* SCHEDULED */];
+  }
+  const campaignBudget = campaign.budget;
+  const overBudget = campaignBudget && campaignBudget.limit && campaignBudget.used > campaignBudget.limit;
+  if (campaign.ends_at && new Date(campaign.ends_at) < date || overBudget) {
+    return promotionStatusMap["EXPIRED" /* EXPIRED */];
+  }
+  return promotionStatusMap[promotion.status.toUpperCase()];
+};
+
+// src/components/table/table-cells/promotion/status-cell/status-cell.tsx
+import { jsx } from "react/jsx-runtime";
+var StatusCell2 = ({ promotion }) => {
+  const [color, text] = getPromotionStatus(promotion);
+  return /* @__PURE__ */ jsx(StatusCell, { color, children: text });
+};
+
+export {
+  StatusCell2 as StatusCell
+};

package/dist/chunk-Y224F4UU.js

@@ -0,0 +1,81 @@
+// src/lib/client/client.ts
+import { createClient } from "@mercurjs/client";
+import config from "virtual:mercur/config";
+var backendUrl = config.backendUrl ?? "http://localhost:9000";
+var sdk = createClient({
+  baseUrl: backendUrl,
+  fetchOptions: {
+    credentials: "include"
+  }
+});
+var fetchQuery = async (url, {
+  method,
+  body,
+  query,
+  headers
+}) => {
+  const params = Object.entries(query || {}).reduce((acc, [key, value]) => {
+    if (value !== null && value !== void 0 && value !== "") {
+      if (Array.isArray(value)) {
+        const arrayParams = value.map(
+          (item) => `${encodeURIComponent(key)}[]=${encodeURIComponent(item)}`
+        ).join("&");
+        if (acc) {
+          acc += "&" + arrayParams;
+        } else {
+          acc = arrayParams;
+        }
+      } else {
+        const separator = acc ? "&" : "";
+        const serializedValue = typeof value === "object" ? JSON.stringify(value) : value;
+        acc += `${separator}${encodeURIComponent(key)}=${encodeURIComponent(serializedValue)}`;
+      }
+    }
+    return acc;
+  }, "");
+  const response = await fetch(
+    `${backendUrl}${url}${params ? `?${params}` : ""}`,
+    {
+      method,
+      credentials: "include",
+      headers: {
+        "Content-Type": "application/json",
+        ...headers
+      },
+      body: body ? JSON.stringify(body) : null
+    }
+  );
+  if (!response.ok) {
+    const errorData = await response.json();
+    if (response.status === 401) {
+      window.location.href = "/login?reason=Unauthorized";
+      return;
+    }
+    const error = new Error(errorData.message || "Server error");
+    error.status = response.status;
+    throw error;
+  }
+  return response.json();
+};
+var uploadFilesQuery = async (files) => {
+  const formData = new FormData();
+  for (const { file } of files) {
+    formData.append("files", file);
+  }
+  const response = await fetch(`${backendUrl}/vendor/uploads`, {
+    method: "POST",
+    credentials: "include",
+    body: formData
+  });
+  if (!response.ok) {
+    return null;
+  }
+  return response.json();
+};
+
+export {
+  backendUrl,
+  sdk,
+  fetchQuery,
+  uploadFilesQuery
+};

package/dist/chunk-Y3FR5JC7.js

@@ -0,0 +1,437 @@
+import {
+  useQueryParams
+} from "./chunk-THHRRYRS.js";
+import {
+  ActionMenu
+} from "./chunk-BDGZ4EQO.js";
+import {
+  useDate
+} from "./chunk-CFETU5BI.js";
+
+// src/components/data-table/data-table.tsx
+import {
+  DataTable as UiDataTable,
+  useDataTable,
+  Heading,
+  Text,
+  Button
+} from "@medusajs/ui";
+import React, { useCallback, useMemo } from "react";
+import { useTranslation } from "react-i18next";
+import { Link, useNavigate, useSearchParams } from "react-router-dom";
+import { jsx, jsxs } from "react/jsx-runtime";
+var DataTable = ({
+  data = [],
+  columns,
+  filters,
+  commands,
+  action,
+  actions,
+  actionMenu,
+  getRowId,
+  rowCount = 0,
+  enablePagination = true,
+  enableSearch = true,
+  autoFocusSearch = false,
+  enableFilterMenu,
+  rowHref,
+  heading,
+  headingLevel = "h1",
+  subHeading,
+  prefix,
+  pageSize = 10,
+  emptyState,
+  rowSelection,
+  isLoading = false,
+  layout = "auto",
+  enableColumnVisibility = false,
+  initialColumnVisibility = {},
+  onColumnVisibilityChange,
+  columnOrder,
+  onColumnOrderChange,
+  enableViewSelector = false,
+  entity,
+  currentColumns,
+  filterBarContent
+}) => {
+  const { t } = useTranslation();
+  const enableFiltering = filters && filters.length > 0;
+  const showFilterMenu = enableFilterMenu !== void 0 ? enableFilterMenu : enableFiltering;
+  const enableCommands = commands && commands.length > 0;
+  const enableSorting = columns.some((column) => column.enableSorting);
+  const [columnVisibility, setColumnVisibility] = React.useState(initialColumnVisibility);
+  React.useEffect(() => {
+    const currentKeys = Object.keys(columnVisibility).sort();
+    const newKeys = Object.keys(initialColumnVisibility).sort();
+    const hasChanged = currentKeys.length !== newKeys.length || currentKeys.some((key, index) => key !== newKeys[index]) || Object.entries(initialColumnVisibility).some(
+      ([key, value]) => columnVisibility[key] !== value
+    );
+    if (hasChanged) {
+      setColumnVisibility(initialColumnVisibility);
+    }
+  }, [initialColumnVisibility]);
+  const handleColumnVisibilityChange = React.useCallback(
+    (visibility) => {
+      setColumnVisibility(visibility);
+      onColumnVisibilityChange?.(visibility);
+    },
+    [onColumnVisibilityChange]
+  );
+  const filterIds = useMemo(() => filters?.map((f) => f.id) ?? [], [filters]);
+  const prefixedFilterIds = filterIds.map((id) => getQueryParamKey(id, prefix));
+  const { offset, order, q, ...filterParams } = useQueryParams(
+    [
+      ...filterIds,
+      ...enableSorting ? ["order"] : [],
+      ...enableSearch ? ["q"] : [],
+      ...enablePagination ? ["offset"] : []
+    ],
+    prefix
+  );
+  const [_, setSearchParams] = useSearchParams();
+  const search = useMemo(() => {
+    return q ?? "";
+  }, [q]);
+  const handleSearchChange = (value) => {
+    setSearchParams((prev) => {
+      if (value) {
+        prev.set(getQueryParamKey("q", prefix), value);
+      } else {
+        prev.delete(getQueryParamKey("q", prefix));
+      }
+      return prev;
+    });
+  };
+  const pagination = useMemo(() => {
+    return offset ? parsePaginationState(offset, pageSize) : { pageIndex: 0, pageSize };
+  }, [offset, pageSize]);
+  const handlePaginationChange = (value) => {
+    setSearchParams((prev) => {
+      if (value.pageIndex === 0) {
+        prev.delete(getQueryParamKey("offset", prefix));
+      } else {
+        prev.set(
+          getQueryParamKey("offset", prefix),
+          transformPaginationState(value).toString()
+        );
+      }
+      return prev;
+    });
+  };
+  const filtering = useMemo(
+    () => parseFilterState(filterIds, filterParams),
+    [filterIds, filterParams]
+  );
+  const handleFilteringChange = (value) => {
+    setSearchParams((prev) => {
+      Array.from(prev.keys()).forEach((key) => {
+        if (prefixedFilterIds.includes(key)) {
+          const unprefixedKey = prefix ? key.replace(`${prefix}_`, "") : key;
+          if (!(unprefixedKey in value)) {
+            prev.delete(key);
+          }
+        }
+      });
+      Object.entries(value).forEach(([key, filter]) => {
+        const prefixedKey = getQueryParamKey(key, prefix);
+        if (filter !== void 0) {
+          prev.set(prefixedKey, JSON.stringify(filter));
+        } else {
+          prev.delete(prefixedKey);
+        }
+      });
+      return prev;
+    });
+  };
+  const sorting = useMemo(() => {
+    return order ? parseSortingState(order) : null;
+  }, [order]);
+  const currentConfiguration = useMemo(
+    () => ({
+      filters: filtering,
+      sorting,
+      search
+    }),
+    [filtering, sorting, search]
+  );
+  const handleSortingChange = (value) => {
+    setSearchParams((prev) => {
+      if (value) {
+        const valueToStore = transformSortingState(value);
+        prev.set(getQueryParamKey("order", prefix), valueToStore);
+      } else {
+        prev.delete(getQueryParamKey("order", prefix));
+      }
+      return prev;
+    });
+  };
+  const { pagination: paginationTranslations, toolbar: toolbarTranslations } = useDataTableTranslations();
+  const navigate = useNavigate();
+  const onRowClick = useCallback(
+    (event, row) => {
+      if (!rowHref) {
+        return;
+      }
+      const href = rowHref(row);
+      const basePath = "/";
+      const hrefWithBasePath = `${basePath === "/" ? "" : basePath}${href}`;
+      if (event.metaKey || event.ctrlKey || event.button === 1) {
+        window.open(hrefWithBasePath, "_blank", "noreferrer");
+        return;
+      }
+      if (event.shiftKey) {
+        window.open(hrefWithBasePath, void 0, "noreferrer");
+        return;
+      }
+      navigate(href);
+    },
+    [navigate, rowHref]
+  );
+  const instance = useDataTable({
+    data,
+    columns,
+    filters,
+    commands,
+    rowCount,
+    getRowId,
+    onRowClick: rowHref ? onRowClick : void 0,
+    pagination: enablePagination ? {
+      state: pagination,
+      onPaginationChange: handlePaginationChange
+    } : void 0,
+    filtering: enableFiltering ? {
+      state: filtering,
+      onFilteringChange: handleFilteringChange
+    } : void 0,
+    sorting: enableSorting ? {
+      state: sorting,
+      onSortingChange: handleSortingChange
+    } : void 0,
+    search: enableSearch ? {
+      state: search,
+      onSearchChange: handleSearchChange
+    } : void 0,
+    rowSelection,
+    isLoading,
+    columnVisibility: enableColumnVisibility ? {
+      state: columnVisibility,
+      onColumnVisibilityChange: handleColumnVisibilityChange
+    } : void 0,
+    columnOrder: columnOrder && onColumnOrderChange ? {
+      state: columnOrder,
+      onColumnOrderChange
+    } : void 0
+  });
+  const shouldRenderHeading = heading || subHeading;
+  return /* @__PURE__ */ jsxs(
+    UiDataTable,
+    {
+      instance,
+      className: layout === "fill" ? "h-full [&_tr]:last-of-type:!border-b" : void 0,
+      children: [
+        /* @__PURE__ */ jsx(
+          UiDataTable.Toolbar,
+          {
+            className: "flex flex-col items-start justify-between gap-2 md:flex-row md:items-center",
+            translations: toolbarTranslations,
+            filterBarContent,
+            children: /* @__PURE__ */ jsxs("div", { className: "flex w-full items-center justify-between gap-2", children: [
+              /* @__PURE__ */ jsx("div", { className: "flex items-center gap-x-4", children: shouldRenderHeading && /* @__PURE__ */ jsxs("div", { children: [
+                heading && /* @__PURE__ */ jsx(Heading, { level: headingLevel, children: heading }),
+                subHeading && /* @__PURE__ */ jsx(Text, { size: "small", className: "text-ui-fg-subtle", children: subHeading })
+              ] }) }),
+              /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-x-2", children: [
+                showFilterMenu && /* @__PURE__ */ jsx(UiDataTable.FilterMenu, {}),
+                enableSorting && /* @__PURE__ */ jsx(UiDataTable.SortingMenu, {}),
+                enableSearch && /* @__PURE__ */ jsx("div", { className: "w-full md:w-auto", children: /* @__PURE__ */ jsx(
+                  UiDataTable.Search,
+                  {
+                    placeholder: t("filters.searchLabel"),
+                    autoFocus: autoFocusSearch
+                  }
+                ) }),
+                actionMenu && /* @__PURE__ */ jsx(ActionMenu, { variant: "primary", ...actionMenu }),
+                actions && actions.length > 0 && /* @__PURE__ */ jsx(DataTableActions, { actions }),
+                !actions && action && /* @__PURE__ */ jsx(DataTableAction, { ...action })
+              ] })
+            ] })
+          }
+        ),
+        /* @__PURE__ */ jsx(UiDataTable.Table, { emptyState }),
+        enablePagination && /* @__PURE__ */ jsx(UiDataTable.Pagination, { translations: paginationTranslations }),
+        enableCommands && /* @__PURE__ */ jsx(
+          UiDataTable.CommandBar,
+          {
+            selectedLabel: (count) => `${count} selected`
+          }
+        )
+      ]
+    }
+  );
+};
+function transformSortingState(value) {
+  return value.desc ? `-${value.id}` : value.id;
+}
+function parseSortingState(value) {
+  return value.startsWith("-") ? { id: value.slice(1), desc: true } : { id: value, desc: false };
+}
+function transformPaginationState(value) {
+  return value.pageIndex * value.pageSize;
+}
+function parsePaginationState(value, pageSize) {
+  const offset = parseInt(value);
+  return {
+    pageIndex: Math.floor(offset / pageSize),
+    pageSize
+  };
+}
+function parseFilterState(filterIds, value) {
+  if (!value) {
+    return {};
+  }
+  const filters = {};
+  for (const id of filterIds) {
+    const filterValue = value[id];
+    if (filterValue !== void 0) {
+      filters[id] = JSON.parse(filterValue);
+    }
+  }
+  return filters;
+}
+function getQueryParamKey(key, prefix) {
+  return prefix ? `${prefix}_${key}` : key;
+}
+var useDataTableTranslations = () => {
+  const { t } = useTranslation();
+  const paginationTranslations = {
+    of: t("general.of"),
+    results: t("general.results"),
+    pages: t("general.pages"),
+    prev: t("general.prev"),
+    next: t("general.next")
+  };
+  const toolbarTranslations = {
+    clearAll: t("actions.clearAll"),
+    sort: t("filters.sortLabel"),
+    columns: "Columns"
+  };
+  return {
+    pagination: paginationTranslations,
+    toolbar: toolbarTranslations
+  };
+};
+var DataTableAction = ({
+  label,
+  disabled,
+  ...props
+}) => {
+  const buttonProps = {
+    size: "small",
+    disabled: disabled ?? false,
+    type: "button",
+    variant: "secondary"
+  };
+  if ("to" in props) {
+    return /* @__PURE__ */ jsx(Button, { ...buttonProps, asChild: true, children: /* @__PURE__ */ jsx(Link, { to: props.to, children: label }) });
+  }
+  return /* @__PURE__ */ jsx(Button, { ...buttonProps, onClick: props.onClick, children: label });
+};
+var DataTableActions = ({ actions }) => {
+  return /* @__PURE__ */ jsx("div", { className: "flex items-center gap-x-2", children: actions.map((action, index) => /* @__PURE__ */ jsx(DataTableAction, { ...action }, index)) });
+};
+
+// src/components/data-table/helpers/general/use-data-table-date-filters.tsx
+import { createDataTableFilterHelper } from "@medusajs/ui";
+import { subDays, subMonths } from "date-fns";
+import { useMemo as useMemo2 } from "react";
+import { useTranslation as useTranslation2 } from "react-i18next";
+var filterHelper = createDataTableFilterHelper();
+var useDateFilterOptions = () => {
+  const { t } = useTranslation2();
+  const today = useMemo2(() => {
+    const date = /* @__PURE__ */ new Date();
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }, []);
+  return useMemo2(() => {
+    return [
+      {
+        label: t("filters.date.today"),
+        value: {
+          $gte: today.toISOString()
+        }
+      },
+      {
+        label: t("filters.date.lastSevenDays"),
+        value: {
+          $gte: subDays(today, 7).toISOString()
+          // 7 days ago
+        }
+      },
+      {
+        label: t("filters.date.lastThirtyDays"),
+        value: {
+          $gte: subDays(today, 30).toISOString()
+          // 30 days ago
+        }
+      },
+      {
+        label: t("filters.date.lastNinetyDays"),
+        value: {
+          $gte: subDays(today, 90).toISOString()
+          // 90 days ago
+        }
+      },
+      {
+        label: t("filters.date.lastTwelveMonths"),
+        value: {
+          $gte: subMonths(today, 12).toISOString()
+          // 12 months ago
+        }
+      }
+    ];
+  }, [today, t]);
+};
+var useDataTableDateFilters = (disableRangeOption) => {
+  const { t } = useTranslation2();
+  const { getFullDate } = useDate();
+  const dateFilterOptions = useDateFilterOptions();
+  const rangeOptions = useMemo2(() => {
+    if (disableRangeOption) {
+      return {
+        disableRangeOption: true
+      };
+    }
+    return {
+      rangeOptionStartLabel: t("filters.date.starting"),
+      rangeOptionEndLabel: t("filters.date.ending"),
+      rangeOptionLabel: t("filters.date.custom"),
+      options: dateFilterOptions
+    };
+  }, [disableRangeOption, t, dateFilterOptions]);
+  return useMemo2(() => {
+    return [
+      filterHelper.accessor("created_at", {
+        type: "date",
+        label: t("fields.createdAt"),
+        format: "date",
+        formatDateValue: (date) => getFullDate({ date }),
+        options: dateFilterOptions,
+        ...rangeOptions
+      }),
+      filterHelper.accessor("updated_at", {
+        type: "date",
+        label: t("fields.updatedAt"),
+        format: "date",
+        formatDateValue: (date) => getFullDate({ date }),
+        options: dateFilterOptions,
+        ...rangeOptions
+      })
+    ];
+  }, [t, dateFilterOptions, getFullDate, rangeOptions]);
+};
+
+export {
+  DataTable,
+  useDataTableDateFilters
+};