@mercurjs/admin 2.1.2-canary.5 → 2.2.0-canary.1

package/dist/chunk-EREXPX6I.js

@@ -0,0 +1,348 @@
+import {
+  optionalFloat,
+  optionalInt
+} from "./chunk-UXD3VNBO.js";
+import {
+  i18n
+} from "./chunk-637OFDFC.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 }));
+  const { variantAttributes, productAttributes, attributeValues } = normalizeFormAttributes(values.attributes ?? []);
+  return {
+    is_giftcard: false,
+    status: values.status,
+    tags: values?.tags?.length ? values.tags?.map((tag) => ({ id: tag })) : void 0,
+    images,
+    collection_id: values.collection_id || void 0,
+    categories: values.category_id ? [{ id: values.category_id }] : void 0,
+    type_id: values.type_id || void 0,
+    seller_ids: values.seller_ids?.length ? values.seller_ids : 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,
+    variant_attributes: variantAttributes.length ? variantAttributes : void 0,
+    product_attributes: productAttributes.length ? productAttributes : void 0,
+    attribute_values: Object.keys(attributeValues).length ? attributeValues : void 0,
+    variants: normalizeVariants(
+      values.variants.filter((variant) => variant.should_create),
+      values.regionsCurrencyMap
+    )
+  };
+};
+var normalizeVariants = (variants, _regionsCurrencyMap) => {
+  return variants.map((variant) => {
+    const attrVals = variant.attribute_values;
+    const hasAttrVals = attrVals && Object.keys(attrVals).length > 0;
+    return {
+      title: variant.title || (hasAttrVals ? Object.values(attrVals).join(" / ") : "Default variant"),
+      attribute_values: hasAttrVals ? attrVals : void 0,
+      sku: variant.sku || void 0,
+      variant_rank: variant.variant_rank
+    };
+  });
+};
+var normalizeFormAttributes = (attributes) => {
+  const variantAttributes = [];
+  const productAttributes = [];
+  const attributeValues = {};
+  for (const attr of attributes) {
+    if (attr.use_for_variants) {
+      if (attr.attribute_id) {
+        const valueNames = Array.isArray(attr.values) ? attr.values : attr.values ? [attr.values] : [];
+        const nameToId = new Map(
+          (attr.available_values ?? []).map((v) => [v.name, v.id])
+        );
+        const valueIds = valueNames.map((name) => nameToId.get(name)).filter(Boolean);
+        variantAttributes.push({
+          attribute_id: attr.attribute_id,
+          value_ids: valueIds.length ? valueIds : void 0
+        });
+      } else if (attr.is_custom && attr.title) {
+        variantAttributes.push({
+          name: attr.title,
+          type: attr.type ?? "multi_select",
+          values: Array.isArray(attr.values) ? attr.values : attr.values ? [attr.values] : [],
+          is_variant_axis: true
+        });
+      }
+    } else {
+      const key = attr.title;
+      if (!key) continue;
+      if (attr.is_custom) {
+        const vals = Array.isArray(attr.values) ? attr.values : attr.values ? [attr.values] : [];
+        if (vals.length) {
+          productAttributes.push({
+            name: attr.title,
+            type: attr.type ?? "text",
+            values: vals,
+            is_variant_axis: false
+          });
+        }
+      } else if (attr.attribute_id) {
+        const vals = Array.isArray(attr.values) ? attr.values : attr.values ? [attr.values] : [];
+        if (!vals.length || vals.every((v) => !v)) continue;
+        const type = attr.type;
+        const hasPresetValues = type === "single_select" || type === "multi_select";
+        if (hasPresetValues) {
+          const nameToId = new Map(
+            (attr.available_values ?? []).map((v) => [v.name, v.id])
+          );
+          const valueIds = vals.map((name) => nameToId.get(name)).filter(Boolean);
+          if (valueIds.length) {
+            productAttributes.push({
+              attribute_id: attr.attribute_id,
+              value_ids: valueIds
+            });
+          }
+        } else {
+          productAttributes.push({
+            attribute_id: attr.attribute_id,
+            values: vals
+          });
+        }
+      }
+    }
+  }
+  return { variantAttributes, productAttributes, attributeValues };
+};
+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
+  }));
+};
+var getPermutations = (data) => {
+  if (data.length === 0) return [];
+  if (data.length === 1) {
+    return data[0].values.map((value) => ({ [data[0].title]: value }));
+  }
+  const [first, ...rest] = data;
+  return first.values.flatMap(
+    (value) => getPermutations(rest).map((perm) => ({ [first.title]: value, ...perm }))
+  );
+};
+var generateVariantsFromAttributes = (attributes, currentVariants) => {
+  const variantAxes = attributes.filter((attr) => attr.use_for_variants).map((attr) => ({
+    title: attr.title,
+    values: Array.isArray(attr.values) ? attr.values : attr.values ? [attr.values] : []
+  })).filter((axis) => axis.title && axis.values.length > 0);
+  if (variantAxes.length === 0) {
+    const hasDefault = currentVariants.some((v) => v.is_default);
+    if (hasDefault && currentVariants.length > 0) {
+      return currentVariants;
+    }
+    return decorateVariantsWithDefaultValues([
+      {
+        title: "Default variant",
+        should_create: true,
+        variant_rank: 0,
+        attribute_values: {},
+        inventory: [{ inventory_item_id: "", required_quantity: "" }],
+        is_default: true
+      }
+    ]);
+  }
+  const permutations = getPermutations(variantAxes);
+  const newVariants = currentVariants.reduce((acc, variant) => {
+    const attrVals = variant.attribute_values;
+    if (!attrVals || Object.keys(attrVals).length === 0) return acc;
+    const match = permutations.find(
+      (perm) => Object.keys(attrVals).every((key) => attrVals[key] === perm[key])
+    );
+    if (match) {
+      acc.push({
+        ...variant,
+        title: Object.values(match).join(" / "),
+        attribute_values: match,
+        is_default: false
+      });
+    }
+    return acc;
+  }, []);
+  const usedSet = new Set(
+    newVariants.map((v) => JSON.stringify(v.attribute_values))
+  );
+  for (const perm of permutations) {
+    if (!usedSet.has(JSON.stringify(perm))) {
+      newVariants.push({
+        title: Object.values(perm).join(" / "),
+        attribute_values: perm,
+        should_create: true,
+        variant_rank: newVariants.length,
+        inventory: [{ inventory_item_id: "", required_quantity: "" }]
+      });
+    }
+  }
+  return newVariants;
+};
+
+// 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(),
+  attribute_values: z.record(z.string(), z.string()).optional(),
+  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 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(),
+  category_id: z.string().min(1),
+  seller_ids: z.array(z.string()).optional(),
+  tags: z.array(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(),
+  attributes: z.array(z.object({
+    attribute_id: z.string().optional(),
+    title: z.string().min(1),
+    values: z.union([z.string(), z.array(z.string())]).optional(),
+    is_custom: z.boolean(),
+    is_required: z.boolean().optional(),
+    use_for_variants: z.boolean(),
+    type: z.string().optional(),
+    available_values: z.array(z.object({
+      id: z.string(),
+      name: z.string()
+    })).optional()
+  })).optional(),
+  variants: z.array(ProductCreateVariantSchema).min(1),
+  media: z.array(MediaSchema).optional()
+}).superRefine((data, ctx) => {
+  data.attributes?.forEach((attr, index) => {
+    if (!attr.is_required) return;
+    const isEmpty = attr.values === void 0 || attr.values === "" || Array.isArray(attr.values) && attr.values.length === 0;
+    if (isEmpty) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: [`attributes.${index}.values`],
+        message: i18n.t("products.create.errors.requiredAttribute")
+      });
+    }
+  });
+  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,
+  seller_ids: [],
+  tags: [],
+  variants: decorateVariantsWithDefaultValues([
+    {
+      title: "Default variant",
+      should_create: true,
+      variant_rank: 0,
+      attribute_values: {},
+      inventory: [{ inventory_item_id: "", required_quantity: "" }],
+      is_default: true
+    }
+  ]),
+  attributes: [],
+  media: [],
+  category_id: "",
+  collection_id: "",
+  description: "",
+  handle: "",
+  height: "",
+  hs_code: "",
+  length: "",
+  material: "",
+  mid_code: "",
+  origin_country: "",
+  subtitle: "",
+  title: "",
+  type_id: "",
+  weight: "",
+  width: ""
+};
+
+export {
+  normalizeProductFormValues,
+  decorateVariantsWithDefaultValues,
+  generateVariantsFromAttributes,
+  MediaSchema,
+  ProductCreateSchema,
+  EditProductMediaSchema,
+  PRODUCT_CREATE_FORM_DEFAULTS
+};

package/dist/{chunk-BJFFCELF.js → chunk-FB7DDNCA.js}

@@ -1,18 +1,15 @@
 import {
   CreateCampaignFormFields
-} from "./chunk-GU4T2RAQ.js";
+} from "./chunk-WQFFCK3R.js";
 import {
   useComboboxData
-} from "./chunk-AEFDAU3Y.js";
+} from "./chunk-5KGMGL4N.js";
 import {
   Combobox
 } from "./chunk-AW77UWCZ.js";
 import {
   KeyboundForm
 } from "./chunk-U2ZFCAPX.js";
-import {
-  useDocumentDirection
-} from "./chunk-Y7QKP6QU.js";
 import {
   RouteDrawer,
   useRouteModal
@@ -24,6 +21,9 @@ import {
   useCampaign,
   useUpdatePromotion
 } from "./chunk-ZN7LWXVC.js";
+import {
+  useDocumentDirection
+} from "./chunk-Y7QKP6QU.js";
 import {
   sdk
 } from "./chunk-ZBWL72TB.js";

package/dist/{chunk-JJYOI5PR.js → chunk-FFNSWUDC.js}

@@ -1,19 +1,16 @@
-import {
-  _DataTable,
-  useDataTable
-} from "./chunk-KLVTWJ4M.js";
-import {
-  SingleColumnPage
-} from "./chunk-XIZLPYEE.js";
-import {
-  ActionMenu
-} from "./chunk-BDGZ4EQO.js";
 import {
   useCustomerGroupTableFilters
 } from "./chunk-CMHI2RPL.js";
 import {
   useCustomerGroupTableQuery
 } from "./chunk-VKOE5J66.js";
+import {
+  _DataTable,
+  useDataTable
+} from "./chunk-NQEXDLYH.js";
+import {
+  SingleColumnPage
+} from "./chunk-H6MYB7GB.js";
 import {
   useDate
 } from "./chunk-UZWFZMOX.js";
@@ -21,6 +18,9 @@ import {
   useCustomerGroups,
   useDeleteCustomerGroupLazy
 } from "./chunk-PRBE5CM3.js";
+import {
+  ActionMenu
+} from "./chunk-BDGZ4EQO.js";
 
 // src/pages/customer-groups/customer-group-list/customer-group-list.tsx
 import { Children as Children2 } from "react";

package/dist/{chunk-YKDEE7ZL.js → chunk-FTAR3BDS.js}

@@ -1,6 +1,6 @@
 import {
   salesChannelsQueryKeys
-} from "./chunk-DL2ZIXBO.js";
+} from "./chunk-S5BJ5CMF.js";
 import {
   queryClient
 } from "./chunk-RHKRREUU.js";

package/dist/{chunk-VXPWIJZV.js → chunk-G4PROEJI.js}

@@ -6,10 +6,6 @@ import {
 import {
   CountrySelect
 } from "./chunk-V74Y5NIV.js";
-import {
-  DataGrid,
-  createDataGridHelper
-} from "./chunk-72Q2T2FK.js";
 import {
   optionalInt
 } from "./chunk-UXD3VNBO.js";
@@ -21,6 +17,10 @@ import {
 import {
   SwitchBox
 } from "./chunk-2EME4AWX.js";
+import {
+  DataGrid,
+  createDataGridHelper
+} from "./chunk-V6OGMYAI.js";
 import {
   RouteFocusModal,
   useRouteModal
@@ -34,7 +34,7 @@ import {
 import {
   inventoryItemsQueryKeys,
   useCreateInventoryItem
-} from "./chunk-5CK6XEFV.js";
+} from "./chunk-2YYXP6XI.js";
 import {
   queryClient
 } from "./chunk-RHKRREUU.js";

package/dist/{chunk-OQMBWJPH.js → chunk-GKW445WA.js}

@@ -1,6 +1,6 @@
 import {
   ordersQueryKeys
-} from "./chunk-TAKEQAZZ.js";
+} from "./chunk-B3EEDC47.js";
 import {
   queryClient
 } from "./chunk-RHKRREUU.js";

package/dist/{chunk-LNAXUDW2.js → chunk-GLPS6QFG.js}

@@ -1,50 +1,76 @@
+import {
+  require_dist
+} from "./chunk-2MDGYHWN.js";
 import {
   useProductTags
-} from "./chunk-PBQ5M44A.js";
+} from "./chunk-AXTQMIIK.js";
 import {
   useProductTypes
 } from "./chunk-46M463BR.js";
 import {
-  useSellers
-} from "./chunk-LEG67A2R.js";
+  useCollections
+} from "./chunk-XZZTC7E5.js";
+import {
+  useProductCategories
+} from "./chunk-H5PYBIOZ.js";
 import {
-  useSalesChannels
-} from "./chunk-DL2ZIXBO.js";
+  __toESM
+} from "./chunk-NBMM2TZK.js";
 
 // src/hooks/table/filters/use-product-table-filters.tsx
+var import_types = __toESM(require_dist(), 1);
 import { useTranslation } from "react-i18next";
 var useProductTableFilters = (exclude) => {
   const { t } = useTranslation();
+  const isCategoryExcluded = exclude?.includes("categories");
+  const isCollectionExcluded = exclude?.includes("collections");
   const isProductTypeExcluded = exclude?.includes("product_types");
+  const isProductTagExcluded = exclude?.includes("product_tags");
   const { product_types } = useProductTypes(
-    {
-      limit: 1e3,
-      offset: 0
-    },
-    {
-      enabled: !isProductTypeExcluded
-    }
+    { 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
-    }
+  const { product_tags } = useProductTags(
+    { limit: 1e3, offset: 0 },
+    { enabled: !isProductTagExcluded }
+  );
+  const { product_categories } = useProductCategories(
+    { limit: 1e3, offset: 0, fields: "id,name" },
+    { enabled: !isCategoryExcluded }
+  );
+  const { collections } = useCollections(
+    { limit: 1e3, offset: 0 },
+    { enabled: !isCollectionExcluded }
   );
   let filters = [];
+  if (product_categories && !isCategoryExcluded) {
+    const categoryFilter = {
+      key: "category_id",
+      label: t("fields.category"),
+      type: "select",
+      multiple: true,
+      searchable: true,
+      options: product_categories.map((c) => ({
+        label: c.name,
+        value: c.id
+      }))
+    };
+    filters = [...filters, categoryFilter];
+  }
+  if (collections && !isCollectionExcluded) {
+    const collectionFilter = {
+      key: "collection_id",
+      label: t("fields.collection"),
+      type: "select",
+      multiple: true,
+      searchable: true,
+      options: collections.map((c) => ({
+        label: c.title,
+        value: c.id
+      }))
+    };
+    filters = [...filters, collectionFilter];
+  }
   if (product_types && !isProductTypeExcluded) {
     const typeFilter = {
       key: "type_id",
@@ -73,20 +99,6 @@ var useProductTableFilters = (exclude) => {
     };
     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"),
@@ -95,19 +107,23 @@ var useProductTableFilters = (exclude) => {
     options: [
       {
         label: t("products.productStatus.draft"),
-        value: "draft"
+        value: import_types.ProductStatus.DRAFT
       },
       {
         label: t("products.productStatus.proposed"),
-        value: "proposed"
+        value: import_types.ProductStatus.PROPOSED
       },
       {
         label: t("products.productStatus.published"),
-        value: "published"
+        value: import_types.ProductStatus.PUBLISHED
+      },
+      {
+        label: t("products.productStatus.requires_action"),
+        value: import_types.ProductStatus.REQUIRES_ACTION
       },
       {
         label: t("products.productStatus.rejected"),
-        value: "rejected"
+        value: import_types.ProductStatus.REJECTED
       }
     ]
   };
@@ -119,20 +135,6 @@ var useProductTableFilters = (exclude) => {
     label: f.label,
     type: "date"
   }));
-  if (sellers) {
-    const sellerFilter = {
-      key: "seller_id",
-      label: t("stores.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;
 };

package/dist/{chunk-3IN6MMKV.js → chunk-GNLPUGYK.js}

@@ -1,9 +1,9 @@
 import {
   returnsQueryKeys
-} from "./chunk-OQMBWJPH.js";
+} from "./chunk-GKW445WA.js";
 import {
   ordersQueryKeys
-} from "./chunk-TAKEQAZZ.js";
+} from "./chunk-B3EEDC47.js";
 import {
   queryClient
 } from "./chunk-RHKRREUU.js";

package/dist/{chunk-3UZVMGC6.js → chunk-GP4J42UD.js}

@@ -1,16 +1,16 @@
 import {
   SingleColumnPage
-} from "./chunk-XIZLPYEE.js";
+} from "./chunk-H6MYB7GB.js";
 import {
-  SingleColumnPageSkeleton
-} from "./chunk-INNFZYX2.js";
+  useDeleteUser,
+  useUser
+} from "./chunk-GKGLVDDV.js";
 import {
   ActionMenu
 } from "./chunk-BDGZ4EQO.js";
 import {
-  useDeleteUser,
-  useUser
-} from "./chunk-GKGLVDDV.js";
+  SingleColumnPageSkeleton
+} from "./chunk-INNFZYX2.js";
 
 // src/pages/users/user-detail/user-detail.tsx
 import { Children } from "react";