medusa-dynamic-metadata 0.0.1

package/.medusa/server/src/admin/index.mjs

@@ -0,0 +1,1730 @@
+import { jsxs, jsx, Fragment } from "react/jsx-runtime";
+import { defineWidgetConfig } from "@medusajs/admin-sdk";
+import { useState, useRef, useEffect, useMemo } from "react";
+import { Container, Heading, Badge, Text, Skeleton, InlineTip, Button, Switch, Textarea, Input, toast } from "@medusajs/ui";
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+const METADATA_FIELD_TYPES = ["number", "text", "file", "bool"];
+const VALID_FIELD_TYPES = new Set(METADATA_FIELD_TYPES);
+const BOOLEAN_TRUES = /* @__PURE__ */ new Set(["true", "1", "yes", "y", "on"]);
+const BOOLEAN_FALSES = /* @__PURE__ */ new Set(["false", "0", "no", "n", "off"]);
+function normalizeMetadataDescriptors(input) {
+  if (!Array.isArray(input)) return [];
+  const seenKeys = /* @__PURE__ */ new Set();
+  return input.filter(
+    (item) => item && typeof item === "object"
+  ).map((item) => {
+    const key = normalizeKey(item.key);
+    const type = normalizeType(item.type);
+    const label = normalizeLabel(item.label);
+    const filterable = !!item.filterable;
+    return { key, type, label, filterable };
+  }).filter(({ key, type }) => key && type && !seenKeys.has(key)).map(({ key, type, label, filterable }) => {
+    seenKeys.add(key);
+    return {
+      key,
+      type,
+      ...label && { label },
+      ...filterable && { filterable: true }
+    };
+  });
+}
+function buildInitialFormState(descriptors, metadata) {
+  const base = metadata && typeof metadata === "object" ? metadata : {};
+  return descriptors.reduce((acc, descriptor) => {
+    acc[descriptor.key] = normalizeFormValue(descriptor, base[descriptor.key]);
+    return acc;
+  }, {});
+}
+function buildMetadataPayload({
+  descriptors,
+  values,
+  originalMetadata
+}) {
+  const base = originalMetadata && typeof originalMetadata === "object" ? { ...originalMetadata } : {};
+  descriptors.forEach((descriptor) => {
+    const coerced = coerceMetadataValue(descriptor, values[descriptor.key]);
+    if (coerced === void 0) {
+      delete base[descriptor.key];
+    } else {
+      base[descriptor.key] = coerced;
+    }
+  });
+  return base;
+}
+function hasMetadataChanges({
+  descriptors,
+  values,
+  originalMetadata
+}) {
+  const next = buildMetadataPayload({ descriptors, values, originalMetadata });
+  const prev = originalMetadata && typeof originalMetadata === "object" ? originalMetadata : {};
+  return descriptors.some(({ key }) => !isDeepEqual(prev[key], next[key]));
+}
+function validateValueForDescriptor(descriptor, value) {
+  if (descriptor.type === "number") {
+    if (value == null || value === "") return void 0;
+    const num = typeof value === "number" ? value : Number(String(value).trim());
+    return isNaN(num) ? "Enter a valid number" : void 0;
+  }
+  if (descriptor.type === "file") {
+    if (!value) return void 0;
+    try {
+      new URL(String(value).trim());
+      return void 0;
+    } catch {
+      return "Enter a valid URL";
+    }
+  }
+  return void 0;
+}
+function normalizeFormValue(descriptor, currentValue) {
+  if (descriptor.type === "bool") return Boolean(currentValue);
+  if ((descriptor.type === "number" || descriptor.type === "text") && typeof currentValue === "number") {
+    return currentValue.toString();
+  }
+  if (typeof currentValue === "string" || typeof currentValue === "number") {
+    return String(currentValue);
+  }
+  return "";
+}
+function coerceMetadataValue(descriptor, value) {
+  if (value == null || value === "") return void 0;
+  if (descriptor.type === "bool") {
+    if (typeof value === "boolean") return value;
+    if (typeof value === "number") return value !== 0;
+    const normalized = String(value).trim().toLowerCase();
+    if (!normalized) return void 0;
+    if (BOOLEAN_TRUES.has(normalized)) return true;
+    if (BOOLEAN_FALSES.has(normalized)) return false;
+    return Boolean(value);
+  }
+  if (descriptor.type === "number") {
+    const num = typeof value === "number" ? value : Number(String(value).trim());
+    return isNaN(num) ? void 0 : num;
+  }
+  const trimmed = String(value).trim();
+  if (!trimmed) return void 0;
+  return trimmed;
+}
+function normalizeKey(value) {
+  return typeof value === "string" ? value.trim() || void 0 : void 0;
+}
+function normalizeType(value) {
+  if (typeof value !== "string") return void 0;
+  const type = value.trim().toLowerCase();
+  return VALID_FIELD_TYPES.has(type) ? type : void 0;
+}
+function normalizeLabel(value) {
+  return typeof value === "string" ? value.trim() || void 0 : void 0;
+}
+function isDeepEqual(a, b) {
+  if (a === b) return true;
+  if (!a || !b || typeof a !== "object" || typeof b !== "object") return false;
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  if (aKeys.length !== bKeys.length) return false;
+  return aKeys.every(
+    (key) => isDeepEqual(a[key], b[key])
+  );
+}
+const CONFIG_ENDPOINT = "/admin/metadata-config";
+const QUERY_KEY = ["medusa-dynamic-metadata", "metadata-config"];
+function useMetadataConfig({ entity }) {
+  return useQuery({
+    queryKey: [...QUERY_KEY, entity],
+    queryFn: async () => {
+      const response = await fetch(`${CONFIG_ENDPOINT}?entity=${entity}`, {
+        credentials: "include"
+      });
+      if (!response.ok) {
+        throw new Error("Unable to load metadata configuration");
+      }
+      const payload = await response.json();
+      return normalizeMetadataDescriptors(payload.metadataDescriptors);
+    },
+    staleTime: 5 * 60 * 1e3
+  });
+}
+const DEFAULT_ENTITY_MAPPINGS = {
+  products: {
+    widgetZone: "product.details.after",
+    apiEndpoint: "/admin/products/{id}",
+    responseKey: "product"
+  },
+  orders: {
+    widgetZone: "order.details.after",
+    apiEndpoint: "/admin/orders/{id}",
+    responseKey: "order"
+  },
+  categories: {
+    widgetZone: "product_category.details.after",
+    apiEndpoint: "/admin/product-categories/{id}",
+    responseKey: "product_category"
+  },
+  collections: {
+    widgetZone: "product_collection.details.after",
+    apiEndpoint: "/admin/collections/{id}",
+    responseKey: "collection"
+  },
+  customers: {
+    widgetZone: "customer.details.after",
+    apiEndpoint: "/admin/customers/{id}",
+    responseKey: "customer"
+  },
+  regions: {
+    widgetZone: "region.details.after",
+    apiEndpoint: "/admin/regions/{id}",
+    responseKey: "region"
+  },
+  sales_channels: {
+    widgetZone: "sales_channel.details.after",
+    apiEndpoint: "/admin/sales-channels/{id}",
+    responseKey: "sales_channel"
+  },
+  stores: {
+    widgetZone: "store.details.after",
+    apiEndpoint: "/admin/stores/{id}",
+    responseKey: "store"
+  },
+  promotions: {
+    widgetZone: "promotion.details.after",
+    apiEndpoint: "/admin/promotions/{id}",
+    responseKey: "promotion"
+  },
+  campaigns: {
+    widgetZone: "campaign.details.after",
+    apiEndpoint: "/admin/campaigns/{id}",
+    responseKey: "campaign"
+  },
+  price_lists: {
+    widgetZone: "price_list.details.after",
+    apiEndpoint: "/admin/price-lists/{id}",
+    responseKey: "price_list"
+  },
+  shipping_profiles: {
+    widgetZone: "shipping_profile.details.after",
+    apiEndpoint: "/admin/shipping-profiles/{id}",
+    responseKey: "shipping_profile"
+  },
+  return_reasons: {
+    widgetZone: "return_reason.details.after",
+    apiEndpoint: "/admin/return-reasons/{id}",
+    responseKey: "return_reason"
+  },
+  inventory_items: {
+    widgetZone: "inventory_item.details.after",
+    apiEndpoint: "/admin/inventory-items/{id}",
+    responseKey: "inventory_item"
+  },
+  product_variants: {
+    widgetZone: "product_variant.details.after",
+    apiEndpoint: "/admin/product-variants/{id}",
+    responseKey: "product_variant"
+  },
+  account_holders: {
+    widgetZone: "account_holder.details.after",
+    apiEndpoint: "/admin/account-holders/{id}",
+    responseKey: "account_holder"
+  },
+  captures: {
+    widgetZone: "capture.details.after",
+    apiEndpoint: "/admin/captures/{id}",
+    responseKey: "capture"
+  },
+  carts: {
+    widgetZone: "cart.details.after",
+    apiEndpoint: "/admin/carts/{id}",
+    responseKey: "cart"
+  },
+  cart_addresses: {
+    widgetZone: "cart_address.details.after",
+    apiEndpoint: "/admin/cart-addresses/{id}",
+    responseKey: "cart_address"
+  },
+  cart_line_items: {
+    widgetZone: "cart_line_item.details.after",
+    apiEndpoint: "/admin/cart-line-items/{id}",
+    responseKey: "cart_line_item"
+  },
+  cart_line_item_adjustments: {
+    widgetZone: "cart_line_item_adjustment.details.after",
+    apiEndpoint: "/admin/cart-line-item-adjustments/{id}",
+    responseKey: "cart_line_item_adjustment"
+  },
+  cart_line_item_tax_lines: {
+    widgetZone: "cart_line_item_tax_line.details.after",
+    apiEndpoint: "/admin/cart-line-item-tax-lines/{id}",
+    responseKey: "cart_line_item_tax_line"
+  },
+  cart_shipping_methods: {
+    widgetZone: "cart_shipping_method.details.after",
+    apiEndpoint: "/admin/cart-shipping-methods/{id}",
+    responseKey: "cart_shipping_method"
+  },
+  cart_shipping_method_adjustments: {
+    widgetZone: "cart_shipping_method_adjustment.details.after",
+    apiEndpoint: "/admin/cart-shipping-method-adjustments/{id}",
+    responseKey: "cart_shipping_method_adjustment"
+  },
+  cart_shipping_method_tax_lines: {
+    widgetZone: "cart_shipping_method_tax_line.details.after",
+    apiEndpoint: "/admin/cart-shipping-method-tax-lines/{id}",
+    responseKey: "cart_shipping_method_tax_line"
+  },
+  contact_email_subscriptions: {
+    widgetZone: "contact_email_subscription.details.after",
+    apiEndpoint: "/admin/contact-email-subscriptions/{id}",
+    responseKey: "contact_email_subscription"
+  },
+  contact_requests: {
+    widgetZone: "contact_request.details.after",
+    apiEndpoint: "/admin/contact-requests/{id}",
+    responseKey: "contact_request"
+  },
+  credit_lines: {
+    widgetZone: "credit_line.details.after",
+    apiEndpoint: "/admin/credit-lines/{id}",
+    responseKey: "credit_line"
+  },
+  customer_addresses: {
+    widgetZone: "customer_address.details.after",
+    apiEndpoint: "/admin/customer-addresses/{id}",
+    responseKey: "customer_address"
+  },
+  customer_groups: {
+    widgetZone: "customer_group.details.after",
+    apiEndpoint: "/admin/customer-groups/{id}",
+    responseKey: "customer_group"
+  },
+  customer_group_customers: {
+    widgetZone: "customer_group_customer.details.after",
+    apiEndpoint: "/admin/customer-group-customers/{id}",
+    responseKey: "customer_group_customer"
+  },
+  fulfillments: {
+    widgetZone: "fulfillment.details.after",
+    apiEndpoint: "/admin/fulfillments/{id}",
+    responseKey: "fulfillment"
+  },
+  fulfillment_addresses: {
+    widgetZone: "fulfillment_address.details.after",
+    apiEndpoint: "/admin/fulfillment-addresses/{id}",
+    responseKey: "fulfillment_address"
+  },
+  fulfillment_sets: {
+    widgetZone: "fulfillment_set.details.after",
+    apiEndpoint: "/admin/fulfillment-sets/{id}",
+    responseKey: "fulfillment_set"
+  },
+  geo_zones: {
+    widgetZone: "geo_zone.details.after",
+    apiEndpoint: "/admin/geo-zones/{id}",
+    responseKey: "geo_zone"
+  },
+  images: {
+    widgetZone: "image.details.after",
+    apiEndpoint: "/admin/images/{id}",
+    responseKey: "image"
+  },
+  inventory_levels: {
+    widgetZone: "inventory_level.details.after",
+    apiEndpoint: "/admin/inventory-levels/{id}",
+    responseKey: "inventory_level"
+  },
+  invites: {
+    widgetZone: "invite.details.after",
+    apiEndpoint: "/admin/invites/{id}",
+    responseKey: "invite"
+  },
+  order_addresses: {
+    widgetZone: "order_address.details.after",
+    apiEndpoint: "/admin/order-addresses/{id}",
+    responseKey: "order_address"
+  },
+  order_changes: {
+    widgetZone: "order_change.details.after",
+    apiEndpoint: "/admin/order-changes/{id}",
+    responseKey: "order_change"
+  },
+  order_claims: {
+    widgetZone: "order_claim.details.after",
+    apiEndpoint: "/admin/order-claims/{id}",
+    responseKey: "order_claim"
+  },
+  order_claim_items: {
+    widgetZone: "order_claim_item.details.after",
+    apiEndpoint: "/admin/order-claim-items/{id}",
+    responseKey: "order_claim_item"
+  },
+  order_claim_item_images: {
+    widgetZone: "order_claim_item_image.details.after",
+    apiEndpoint: "/admin/order-claim-item-images/{id}",
+    responseKey: "order_claim_item_image"
+  },
+  order_credit_lines: {
+    widgetZone: "order_credit_line.details.after",
+    apiEndpoint: "/admin/order-credit-lines/{id}",
+    responseKey: "order_credit_line"
+  },
+  order_exchanges: {
+    widgetZone: "order_exchange.details.after",
+    apiEndpoint: "/admin/order-exchanges/{id}",
+    responseKey: "order_exchange"
+  },
+  order_exchange_items: {
+    widgetZone: "order_exchange_item.details.after",
+    apiEndpoint: "/admin/order-exchange-items/{id}",
+    responseKey: "order_exchange_item"
+  },
+  order_items: {
+    widgetZone: "order_item.details.after",
+    apiEndpoint: "/admin/order-items/{id}",
+    responseKey: "order_item"
+  },
+  order_line_items: {
+    widgetZone: "order_line_item.details.after",
+    apiEndpoint: "/admin/order-line-items/{id}",
+    responseKey: "order_line_item"
+  },
+  order_shipping_methods: {
+    widgetZone: "order_shipping_method.details.after",
+    apiEndpoint: "/admin/order-shipping-methods/{id}",
+    responseKey: "order_shipping_method"
+  },
+  payments: {
+    widgetZone: "payment.details.after",
+    apiEndpoint: "/admin/payments/{id}",
+    responseKey: "payment"
+  },
+  payment_collections: {
+    widgetZone: "payment_collection.details.after",
+    apiEndpoint: "/admin/payment-collections/{id}",
+    responseKey: "payment_collection"
+  },
+  payment_sessions: {
+    widgetZone: "payment_session.details.after",
+    apiEndpoint: "/admin/payment-sessions/{id}",
+    responseKey: "payment_session"
+  },
+  product_options: {
+    widgetZone: "product_option.details.after",
+    apiEndpoint: "/admin/product-options/{id}",
+    responseKey: "product_option"
+  },
+  product_option_values: {
+    widgetZone: "product_option_value.details.after",
+    apiEndpoint: "/admin/product-option-values/{id}",
+    responseKey: "product_option_value"
+  },
+  product_tags: {
+    widgetZone: "product_tag.details.after",
+    apiEndpoint: "/admin/product-tags/{id}",
+    responseKey: "product_tag"
+  },
+  product_types: {
+    widgetZone: "product_type.details.after",
+    apiEndpoint: "/admin/product-types/{id}",
+    responseKey: "product_type"
+  },
+  refunds: {
+    widgetZone: "refund.details.after",
+    apiEndpoint: "/admin/refunds/{id}",
+    responseKey: "refund"
+  },
+  refund_reasons: {
+    widgetZone: "refund_reason.details.after",
+    apiEndpoint: "/admin/refund-reasons/{id}",
+    responseKey: "refund_reason"
+  },
+  region_countries: {
+    widgetZone: "region_country.details.after",
+    apiEndpoint: "/admin/region-countries/{id}",
+    responseKey: "region_country"
+  },
+  reservation_items: {
+    widgetZone: "reservation_item.details.after",
+    apiEndpoint: "/admin/reservation-items/{id}",
+    responseKey: "reservation_item"
+  },
+  returns: {
+    widgetZone: "return.details.after",
+    apiEndpoint: "/admin/returns/{id}",
+    responseKey: "return"
+  },
+  return_items: {
+    widgetZone: "return_item.details.after",
+    apiEndpoint: "/admin/return-items/{id}",
+    responseKey: "return_item"
+  },
+  service_zones: {
+    widgetZone: "service_zone.details.after",
+    apiEndpoint: "/admin/service-zones/{id}",
+    responseKey: "service_zone"
+  },
+  shipping_options: {
+    widgetZone: "shipping_option.details.after",
+    apiEndpoint: "/admin/shipping-options/{id}",
+    responseKey: "shipping_option"
+  },
+  stock_locations: {
+    widgetZone: "stock_location.details.after",
+    apiEndpoint: "/admin/stock-locations/{id}",
+    responseKey: "stock_location"
+  },
+  stock_location_addresses: {
+    widgetZone: "stock_location_address.details.after",
+    apiEndpoint: "/admin/stock-location-addresses/{id}",
+    responseKey: "stock_location_address"
+  },
+  tax_rates: {
+    widgetZone: "tax_rate.details.after",
+    apiEndpoint: "/admin/tax-rates/{id}",
+    responseKey: "tax_rate"
+  },
+  tax_rate_rules: {
+    widgetZone: "tax_rate_rule.details.after",
+    apiEndpoint: "/admin/tax-rate-rules/{id}",
+    responseKey: "tax_rate_rule"
+  },
+  tax_regions: {
+    widgetZone: "tax_region.details.after",
+    apiEndpoint: "/admin/tax-regions/{id}",
+    responseKey: "tax_region"
+  },
+  users: {
+    widgetZone: "user.details.after",
+    apiEndpoint: "/admin/users/{id}",
+    responseKey: "user"
+  }
+};
+let customMappings = {};
+function getEntityMapping(entityType) {
+  return customMappings[entityType] || DEFAULT_ENTITY_MAPPINGS[entityType];
+}
+function getApiEndpoint(entityType) {
+  const mapping = getEntityMapping(entityType);
+  return mapping == null ? void 0 : mapping.apiEndpoint;
+}
+function getResponseKey(entityType) {
+  const mapping = getEntityMapping(entityType);
+  return mapping == null ? void 0 : mapping.responseKey;
+}
+function resolveApiEndpoint(entityType, entityId) {
+  const endpoint = getApiEndpoint(entityType);
+  if (!endpoint) return void 0;
+  return endpoint.replace("{id}", entityId);
+}
+const CONFIG_DOCS_URL = "https://docs.medusajs.com/admin/extension-points/widgets";
+const MetadataTableWidget = ({
+  data,
+  entityType,
+  queryKey = []
+}) => {
+  const { data: descriptors = [], isPending, isError } = useMetadataConfig({
+    entity: entityType
+  });
+  const entityId = (data == null ? void 0 : data.id) ?? void 0;
+  const [baselineMetadata, setBaselineMetadata] = useState(
+    (data == null ? void 0 : data.metadata) ?? {}
+  );
+  const queryClient = useQueryClient();
+  const previousEntityIdRef = useRef(entityId);
+  const isInitializedRef = useRef(false);
+  const dataRef = useRef(data);
+  const descriptorsRef = useRef(descriptors);
+  useEffect(() => {
+    dataRef.current = data;
+    descriptorsRef.current = descriptors;
+  }, [data, descriptors]);
+  useEffect(() => {
+    var _a;
+    if (previousEntityIdRef.current === entityId && isInitializedRef.current) {
+      return;
+    }
+    const entityIdChanged = previousEntityIdRef.current !== entityId;
+    if (entityIdChanged || !isInitializedRef.current) {
+      const currentMetadata = (data == null ? void 0 : data.metadata) ?? ((_a = dataRef.current) == null ? void 0 : _a.metadata) ?? {};
+      const currentDescriptors = descriptorsRef.current.length > 0 ? descriptorsRef.current : descriptors;
+      if (currentDescriptors.length === 0) {
+        return;
+      }
+      previousEntityIdRef.current = entityId;
+      setBaselineMetadata(currentMetadata);
+      const newInitialState = buildInitialFormState(
+        currentDescriptors,
+        currentMetadata
+      );
+      setValues(newInitialState);
+      isInitializedRef.current = true;
+    }
+  }, [entityId]);
+  const metadataStringRef = useRef("");
+  useEffect(() => {
+    const hasEntityData = !!data;
+    const descriptorsLoaded = descriptors.length > 0;
+    const sameEntity = previousEntityIdRef.current === entityId;
+    const notInitialized = !isInitializedRef.current;
+    const currentMetadata = (data == null ? void 0 : data.metadata) ?? {};
+    const currentMetadataString = JSON.stringify(currentMetadata);
+    const metadataChanged = currentMetadataString !== metadataStringRef.current;
+    if (hasEntityData && descriptorsLoaded && sameEntity && (notInitialized || metadataChanged)) {
+      const newInitialState = buildInitialFormState(descriptors, currentMetadata);
+      setBaselineMetadata(currentMetadata);
+      setValues(newInitialState);
+      metadataStringRef.current = currentMetadataString;
+      isInitializedRef.current = true;
+    }
+  }, [data, descriptors.length, entityId]);
+  const initialState = useMemo(
+    () => buildInitialFormState(descriptors, baselineMetadata),
+    [descriptors, baselineMetadata]
+  );
+  const [values, setValues] = useState({});
+  const [isSaving, setIsSaving] = useState(false);
+  const errors = useMemo(() => {
+    return descriptors.reduce((acc, descriptor) => {
+      const error = validateValueForDescriptor(descriptor, values[descriptor.key]);
+      if (error) {
+        acc[descriptor.key] = error;
+      }
+      return acc;
+    }, {});
+  }, [descriptors, values]);
+  const hasErrors = Object.keys(errors).length > 0;
+  const isDirty = useMemo(() => {
+    return hasMetadataChanges({
+      descriptors,
+      values,
+      originalMetadata: baselineMetadata
+    });
+  }, [descriptors, values, baselineMetadata]);
+  const handleStringChange = (key, nextValue) => {
+    setValues((prev) => ({
+      ...prev,
+      [key]: nextValue
+    }));
+  };
+  const handleBooleanChange = (key, nextValue) => {
+    setValues((prev) => ({
+      ...prev,
+      [key]: nextValue
+    }));
+  };
+  const handleReset = () => {
+    setValues(initialState);
+  };
+  const handleSubmit = async () => {
+    if (!(data == null ? void 0 : data.id) || !descriptors.length) {
+      return;
+    }
+    setIsSaving(true);
+    try {
+      const metadataPayload = buildMetadataPayload({
+        descriptors,
+        values,
+        originalMetadata: baselineMetadata
+      });
+      const apiEndpoint = resolveApiEndpoint(entityType, data.id);
+      if (!apiEndpoint) {
+        throw new Error(`No API endpoint configured for entity type: ${entityType}`);
+      }
+      const response = await fetch(apiEndpoint, {
+        method: "POST",
+        credentials: "include",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          metadata: metadataPayload
+        })
+      });
+      if (!response.ok) {
+        const payload = await response.json().catch(() => null);
+        throw new Error((payload == null ? void 0 : payload.message) ?? "Unable to save metadata");
+      }
+      const responseKey = getResponseKey(entityType) || entityType;
+      const updated = await response.json();
+      const entity = updated[responseKey] || updated;
+      const nextMetadata = entity == null ? void 0 : entity.metadata;
+      setBaselineMetadata(nextMetadata);
+      setValues(buildInitialFormState(descriptors, nextMetadata));
+      toast.success("Metadata saved");
+      if (queryKey.length > 0) {
+        await queryClient.invalidateQueries({
+          queryKey
+        });
+        if (data.id) {
+          queryClient.refetchQueries({
+            queryKey: [...queryKey, data.id]
+          }).catch(() => {
+          });
+        }
+      }
+    } catch (error) {
+      toast.error(error instanceof Error ? error.message : "Save failed");
+    } finally {
+      setIsSaving(false);
+    }
+  };
+  return /* @__PURE__ */ jsxs(Container, { className: "flex flex-col gap-y-4", children: [
+    /* @__PURE__ */ jsxs("header", { className: "flex flex-col gap-y-1", children: [
+      /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-x-3", children: [
+        /* @__PURE__ */ jsx(Heading, { level: "h2", children: "Metadata" }),
+        /* @__PURE__ */ jsx(Badge, { size: "2xsmall", rounded: "full", children: descriptors.length })
+      ] }),
+      /* @__PURE__ */ jsx(Text, { className: "text-ui-fg-subtle", children: "Structured metadata mapped to the keys you configured in the plugin options." })
+    ] }),
+    isPending || !isInitializedRef.current || Object.keys(values).length === 0 ? /* @__PURE__ */ jsx(Skeleton, { className: "h-[160px] w-full" }) : isError ? /* @__PURE__ */ jsxs(InlineTip, { variant: "error", label: "Configuration unavailable", children: [
+      "Unable to load metadata configuration for this plugin. Confirm that the plugin is registered with options in ",
+      /* @__PURE__ */ jsx("code", { children: "medusa-config.ts" }),
+      "."
+    ] }) : !descriptors.length ? /* @__PURE__ */ jsxs(InlineTip, { variant: "info", label: "No configured metadata keys", children: [
+      "Provide metadata descriptors for ",
+      /* @__PURE__ */ jsx("code", { children: entityType }),
+      " in the plugin options to control which keys show up here.",
+      " ",
+      /* @__PURE__ */ jsx(
+        "a",
+        {
+          className: "text-ui-fg-interactive underline",
+          href: CONFIG_DOCS_URL,
+          target: "_blank",
+          rel: "noreferrer",
+          children: "Learn how to configure it."
+        }
+      )
+    ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx("div", { className: "overflow-hidden rounded-lg border border-ui-border-base", children: /* @__PURE__ */ jsxs("table", { className: "min-w-full divide-y divide-ui-border-base", children: [
+        /* @__PURE__ */ jsx("thead", { className: "bg-ui-bg-subtle", children: /* @__PURE__ */ jsxs("tr", { children: [
+          /* @__PURE__ */ jsx(
+            "th",
+            {
+              scope: "col",
+              className: "txt-compact-xsmall-plus text-left uppercase tracking-wide text-ui-fg-muted px-4 py-3",
+              children: "Label"
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            "th",
+            {
+              scope: "col",
+              className: "txt-compact-xsmall-plus text-left uppercase tracking-wide text-ui-fg-muted px-4 py-3",
+              children: "Value"
+            }
+          )
+        ] }) }),
+        /* @__PURE__ */ jsx("tbody", { className: "divide-y divide-ui-border-subtle bg-ui-bg-base", children: descriptors.map((descriptor) => {
+          const value = values[descriptor.key];
+          const error = errors[descriptor.key];
+          return /* @__PURE__ */ jsxs("tr", { children: [
+            /* @__PURE__ */ jsx(
+              "th",
+              {
+                scope: "row",
+                className: "txt-compact-medium text-ui-fg-base align-top px-4 py-4",
+                children: /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-y-1", children: [
+                  /* @__PURE__ */ jsx("span", { children: descriptor.label ?? descriptor.key }),
+                  /* @__PURE__ */ jsx("span", { className: "txt-compact-xsmall-plus text-ui-fg-muted uppercase tracking-wide", children: descriptor.type })
+                ] })
+              }
+            ),
+            /* @__PURE__ */ jsx("td", { className: "align-top px-4 py-4", children: /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-y-2", children: [
+              /* @__PURE__ */ jsx(
+                ValueField,
+                {
+                  descriptor,
+                  value,
+                  onStringChange: handleStringChange,
+                  onBooleanChange: handleBooleanChange
+                }
+              ),
+              error && /* @__PURE__ */ jsx(Text, { className: "txt-compact-small text-ui-fg-error", children: error })
+            ] }) })
+          ] }, descriptor.key);
+        }) })
+      ] }) }),
+      /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-y-3 border-t border-ui-border-subtle pt-3 md:flex-row md:items-center md:justify-between", children: [
+        /* @__PURE__ */ jsx(Text, { className: "text-ui-fg-muted", children: "Changes are stored on the entity metadata object. Clearing a field removes the corresponding key on save." }),
+        /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-x-2", children: [
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              variant: "secondary",
+              size: "small",
+              disabled: !isDirty || isSaving,
+              onClick: handleReset,
+              children: "Reset"
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              size: "small",
+              onClick: handleSubmit,
+              disabled: !isDirty || hasErrors || isSaving,
+              isLoading: isSaving,
+              children: "Save metadata"
+            }
+          )
+        ] })
+      ] })
+    ] })
+  ] });
+};
+const ValueField = ({
+  descriptor,
+  value,
+  onStringChange,
+  onBooleanChange
+}) => {
+  const fileInputRef = useRef(null);
+  const [isUploading, setIsUploading] = useState(false);
+  const handleFileUpload = async (event) => {
+    var _a;
+    const file = (_a = event.target.files) == null ? void 0 : _a[0];
+    if (!file) {
+      return;
+    }
+    setIsUploading(true);
+    try {
+      const formData = new FormData();
+      formData.append("files", file);
+      const response = await fetch("/admin/uploads", {
+        method: "POST",
+        credentials: "include",
+        body: formData
+      });
+      if (!response.ok) {
+        const payload = await response.json().catch(() => null);
+        throw new Error((payload == null ? void 0 : payload.message) ?? "File upload failed");
+      }
+      const result = await response.json();
+      if (result.files && result.files.length > 0) {
+        const uploadedFile = result.files[0];
+        const fileUrl = uploadedFile.url || uploadedFile.key;
+        if (fileUrl) {
+          onStringChange(descriptor.key, fileUrl);
+          toast.success("File uploaded successfully");
+        } else {
+          throw new Error("File upload succeeded but no URL returned");
+        }
+      } else {
+        throw new Error("File upload failed - no files returned");
+      }
+    } catch (error) {
+      toast.error(
+        error instanceof Error ? error.message : "Failed to upload file"
+      );
+    } finally {
+      setIsUploading(false);
+      if (fileInputRef.current) {
+        fileInputRef.current.value = "";
+      }
+    }
+  };
+  if (descriptor.type === "bool") {
+    return /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-x-2", children: [
+      /* @__PURE__ */ jsx(
+        Switch,
+        {
+          checked: Boolean(value),
+          onCheckedChange: (checked) => onBooleanChange(descriptor.key, Boolean(checked)),
+          "aria-label": `Toggle ${descriptor.label ?? descriptor.key}`
+        }
+      ),
+      /* @__PURE__ */ jsx(Text, { className: "txt-compact-small text-ui-fg-muted", children: Boolean(value) ? "True" : "False" })
+    ] });
+  }
+  if (descriptor.type === "text") {
+    return /* @__PURE__ */ jsx(
+      Textarea,
+      {
+        value: value ?? "",
+        placeholder: "Enter text",
+        rows: 3,
+        onChange: (event) => onStringChange(descriptor.key, event.target.value)
+      }
+    );
+  }
+  if (descriptor.type === "number") {
+    return /* @__PURE__ */ jsx(
+      Input,
+      {
+        type: "text",
+        inputMode: "decimal",
+        placeholder: "0.00",
+        value: value ?? "",
+        onChange: (event) => onStringChange(descriptor.key, event.target.value)
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-y-2", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-x-2", children: [
+      /* @__PURE__ */ jsx(
+        Input,
+        {
+          type: "url",
+          placeholder: "https://example.com/file",
+          value: value ?? "",
+          onChange: (event) => onStringChange(descriptor.key, event.target.value),
+          className: "flex-1"
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "input",
+        {
+          ref: fileInputRef,
+          type: "file",
+          className: "hidden",
+          onChange: handleFileUpload,
+          disabled: isUploading,
+          "aria-label": `Upload file for ${descriptor.label ?? descriptor.key}`
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        Button,
+        {
+          type: "button",
+          variant: "secondary",
+          size: "small",
+          onClick: () => {
+            var _a;
+            return (_a = fileInputRef.current) == null ? void 0 : _a.click();
+          },
+          disabled: isUploading,
+          isLoading: isUploading,
+          children: isUploading ? "Uploading..." : "Upload"
+        }
+      )
+    ] }),
+    typeof value === "string" && value && /* @__PURE__ */ jsx(
+      "a",
+      {
+        className: "txt-compact-small-plus text-ui-fg-interactive underline",
+        href: value,
+        target: "_blank",
+        rel: "noreferrer",
+        children: "View file"
+      }
+    )
+  ] });
+};
+const ZONE_PATTERNS = [
+  // Product zones
+  { pattern: /^product\.details\./, entityType: "products" },
+  { pattern: /^product\./, entityType: "products" },
+  // Order zones
+  { pattern: /^order\.details\./, entityType: "orders" },
+  { pattern: /^order\./, entityType: "orders" },
+  // Category zones
+  { pattern: /^product_category\.details\./, entityType: "categories" },
+  { pattern: /^product_category\./, entityType: "categories" },
+  { pattern: /^category\.details\./, entityType: "categories" },
+  { pattern: /^category\./, entityType: "categories" },
+  // Collection zones
+  { pattern: /^product_collection\.details\./, entityType: "collections" },
+  { pattern: /^product_collection\./, entityType: "collections" },
+  { pattern: /^collection\.details\./, entityType: "collections" },
+  { pattern: /^collection\./, entityType: "collections" },
+  // Customer zones
+  { pattern: /^customer\.details\./, entityType: "customers" },
+  { pattern: /^customer\./, entityType: "customers" },
+  // Region zones
+  { pattern: /^region\.details\./, entityType: "regions" },
+  { pattern: /^region\./, entityType: "regions" },
+  // Sales Channel zones
+  { pattern: /^sales_channel\.details\./, entityType: "sales_channels" },
+  { pattern: /^sales_channel\./, entityType: "sales_channels" },
+  // Store zones
+  { pattern: /^store\.details\./, entityType: "stores" },
+  { pattern: /^store\./, entityType: "stores" },
+  // Promotion zones
+  { pattern: /^promotion\.details\./, entityType: "promotions" },
+  { pattern: /^promotion\./, entityType: "promotions" },
+  // Campaign zones
+  { pattern: /^campaign\.details\./, entityType: "campaigns" },
+  { pattern: /^campaign\./, entityType: "campaigns" },
+  // Price List zones
+  { pattern: /^price_list\.details\./, entityType: "price_lists" },
+  { pattern: /^price_list\./, entityType: "price_lists" },
+  // Shipping Profile zones
+  { pattern: /^shipping_profile\.details\./, entityType: "shipping_profiles" },
+  { pattern: /^shipping_profile\./, entityType: "shipping_profiles" },
+  // Return Reason zones
+  { pattern: /^return_reason\.details\./, entityType: "return_reasons" },
+  { pattern: /^return_reason\./, entityType: "return_reasons" },
+  // Inventory Item zones
+  { pattern: /^inventory_item\.details\./, entityType: "inventory_items" },
+  { pattern: /^inventory_item\./, entityType: "inventory_items" },
+  // Product Variant zones
+  { pattern: /^product_variant\.details\./, entityType: "product_variants" },
+  { pattern: /^product_variant\./, entityType: "product_variants" },
+  // Account Holder zones
+  { pattern: /^account_holder\.details\./, entityType: "account_holders" },
+  { pattern: /^account_holder\./, entityType: "account_holders" },
+  // Capture zones
+  { pattern: /^capture\.details\./, entityType: "captures" },
+  { pattern: /^capture\./, entityType: "captures" },
+  // Cart zones
+  { pattern: /^cart\.details\./, entityType: "carts" },
+  { pattern: /^cart\./, entityType: "carts" },
+  // Cart Address zones
+  { pattern: /^cart_address\.details\./, entityType: "cart_addresses" },
+  { pattern: /^cart_address\./, entityType: "cart_addresses" },
+  // Cart Line Item zones
+  { pattern: /^cart_line_item\.details\./, entityType: "cart_line_items" },
+  { pattern: /^cart_line_item\./, entityType: "cart_line_items" },
+  // Cart Line Item Adjustment zones
+  { pattern: /^cart_line_item_adjustment\.details\./, entityType: "cart_line_item_adjustments" },
+  { pattern: /^cart_line_item_adjustment\./, entityType: "cart_line_item_adjustments" },
+  // Cart Line Item Tax Line zones
+  { pattern: /^cart_line_item_tax_line\.details\./, entityType: "cart_line_item_tax_lines" },
+  { pattern: /^cart_line_item_tax_line\./, entityType: "cart_line_item_tax_lines" },
+  // Cart Shipping Method zones
+  { pattern: /^cart_shipping_method\.details\./, entityType: "cart_shipping_methods" },
+  { pattern: /^cart_shipping_method\./, entityType: "cart_shipping_methods" },
+  // Cart Shipping Method Adjustment zones
+  { pattern: /^cart_shipping_method_adjustment\.details\./, entityType: "cart_shipping_method_adjustments" },
+  { pattern: /^cart_shipping_method_adjustment\./, entityType: "cart_shipping_method_adjustments" },
+  // Cart Shipping Method Tax Line zones
+  { pattern: /^cart_shipping_method_tax_line\.details\./, entityType: "cart_shipping_method_tax_lines" },
+  { pattern: /^cart_shipping_method_tax_line\./, entityType: "cart_shipping_method_tax_lines" },
+  // Contact Email Subscription zones
+  { pattern: /^contact_email_subscription\.details\./, entityType: "contact_email_subscriptions" },
+  { pattern: /^contact_email_subscription\./, entityType: "contact_email_subscriptions" },
+  // Contact Request zones
+  { pattern: /^contact_request\.details\./, entityType: "contact_requests" },
+  { pattern: /^contact_request\./, entityType: "contact_requests" },
+  // Credit Line zones
+  { pattern: /^credit_line\.details\./, entityType: "credit_lines" },
+  { pattern: /^credit_line\./, entityType: "credit_lines" },
+  // Customer Address zones
+  { pattern: /^customer_address\.details\./, entityType: "customer_addresses" },
+  { pattern: /^customer_address\./, entityType: "customer_addresses" },
+  // Customer Group zones
+  { pattern: /^customer_group\.details\./, entityType: "customer_groups" },
+  { pattern: /^customer_group\./, entityType: "customer_groups" },
+  // Customer Group Customer zones
+  { pattern: /^customer_group_customer\.details\./, entityType: "customer_group_customers" },
+  { pattern: /^customer_group_customer\./, entityType: "customer_group_customers" },
+  // Fulfillment zones
+  { pattern: /^fulfillment\.details\./, entityType: "fulfillments" },
+  { pattern: /^fulfillment\./, entityType: "fulfillments" },
+  // Fulfillment Address zones
+  { pattern: /^fulfillment_address\.details\./, entityType: "fulfillment_addresses" },
+  { pattern: /^fulfillment_address\./, entityType: "fulfillment_addresses" },
+  // Fulfillment Set zones
+  { pattern: /^fulfillment_set\.details\./, entityType: "fulfillment_sets" },
+  { pattern: /^fulfillment_set\./, entityType: "fulfillment_sets" },
+  // Geo Zone zones
+  { pattern: /^geo_zone\.details\./, entityType: "geo_zones" },
+  { pattern: /^geo_zone\./, entityType: "geo_zones" },
+  // Image zones
+  { pattern: /^image\.details\./, entityType: "images" },
+  { pattern: /^image\./, entityType: "images" },
+  // Inventory Level zones
+  { pattern: /^inventory_level\.details\./, entityType: "inventory_levels" },
+  { pattern: /^inventory_level\./, entityType: "inventory_levels" },
+  // Invite zones
+  { pattern: /^invite\.details\./, entityType: "invites" },
+  { pattern: /^invite\./, entityType: "invites" },
+  // Order Address zones
+  { pattern: /^order_address\.details\./, entityType: "order_addresses" },
+  { pattern: /^order_address\./, entityType: "order_addresses" },
+  // Order Change zones
+  { pattern: /^order_change\.details\./, entityType: "order_changes" },
+  { pattern: /^order_change\./, entityType: "order_changes" },
+  // Order Claim zones
+  { pattern: /^order_claim\.details\./, entityType: "order_claims" },
+  { pattern: /^order_claim\./, entityType: "order_claims" },
+  // Order Claim Item zones
+  { pattern: /^order_claim_item\.details\./, entityType: "order_claim_items" },
+  { pattern: /^order_claim_item\./, entityType: "order_claim_items" },
+  // Order Claim Item Image zones
+  { pattern: /^order_claim_item_image\.details\./, entityType: "order_claim_item_images" },
+  { pattern: /^order_claim_item_image\./, entityType: "order_claim_item_images" },
+  // Order Credit Line zones
+  { pattern: /^order_credit_line\.details\./, entityType: "order_credit_lines" },
+  { pattern: /^order_credit_line\./, entityType: "order_credit_lines" },
+  // Order Exchange zones
+  { pattern: /^order_exchange\.details\./, entityType: "order_exchanges" },
+  { pattern: /^order_exchange\./, entityType: "order_exchanges" },
+  // Order Exchange Item zones
+  { pattern: /^order_exchange_item\.details\./, entityType: "order_exchange_items" },
+  { pattern: /^order_exchange_item\./, entityType: "order_exchange_items" },
+  // Order Item zones
+  { pattern: /^order_item\.details\./, entityType: "order_items" },
+  { pattern: /^order_item\./, entityType: "order_items" },
+  // Order Line Item zones
+  { pattern: /^order_line_item\.details\./, entityType: "order_line_items" },
+  { pattern: /^order_line_item\./, entityType: "order_line_items" },
+  // Order Shipping Method zones
+  { pattern: /^order_shipping_method\.details\./, entityType: "order_shipping_methods" },
+  { pattern: /^order_shipping_method\./, entityType: "order_shipping_methods" },
+  // Payment zones
+  { pattern: /^payment\.details\./, entityType: "payments" },
+  { pattern: /^payment\./, entityType: "payments" },
+  // Payment Collection zones
+  { pattern: /^payment_collection\.details\./, entityType: "payment_collections" },
+  { pattern: /^payment_collection\./, entityType: "payment_collections" },
+  // Payment Session zones
+  { pattern: /^payment_session\.details\./, entityType: "payment_sessions" },
+  { pattern: /^payment_session\./, entityType: "payment_sessions" },
+  // Product Option zones
+  { pattern: /^product_option\.details\./, entityType: "product_options" },
+  { pattern: /^product_option\./, entityType: "product_options" },
+  // Product Option Value zones
+  { pattern: /^product_option_value\.details\./, entityType: "product_option_values" },
+  { pattern: /^product_option_value\./, entityType: "product_option_values" },
+  // Product Tag zones
+  { pattern: /^product_tag\.details\./, entityType: "product_tags" },
+  { pattern: /^product_tag\./, entityType: "product_tags" },
+  // Product Type zones
+  { pattern: /^product_type\.details\./, entityType: "product_types" },
+  { pattern: /^product_type\./, entityType: "product_types" },
+  // Refund zones
+  { pattern: /^refund\.details\./, entityType: "refunds" },
+  { pattern: /^refund\./, entityType: "refunds" },
+  // Refund Reason zones
+  { pattern: /^refund_reason\.details\./, entityType: "refund_reasons" },
+  { pattern: /^refund_reason\./, entityType: "refund_reasons" },
+  // Region Country zones
+  { pattern: /^region_country\.details\./, entityType: "region_countries" },
+  { pattern: /^region_country\./, entityType: "region_countries" },
+  // Reservation Item zones
+  { pattern: /^reservation_item\.details\./, entityType: "reservation_items" },
+  { pattern: /^reservation_item\./, entityType: "reservation_items" },
+  // Return zones
+  { pattern: /^return\.details\./, entityType: "returns" },
+  { pattern: /^return\./, entityType: "returns" },
+  // Return Item zones
+  { pattern: /^return_item\.details\./, entityType: "return_items" },
+  { pattern: /^return_item\./, entityType: "return_items" },
+  // Service Zone zones
+  { pattern: /^service_zone\.details\./, entityType: "service_zones" },
+  { pattern: /^service_zone\./, entityType: "service_zones" },
+  // Shipping Option zones
+  { pattern: /^shipping_option\.details\./, entityType: "shipping_options" },
+  { pattern: /^shipping_option\./, entityType: "shipping_options" },
+  // Stock Location zones
+  { pattern: /^stock_location\.details\./, entityType: "stock_locations" },
+  { pattern: /^stock_location\./, entityType: "stock_locations" },
+  // Stock Location Address zones
+  { pattern: /^stock_location_address\.details\./, entityType: "stock_location_addresses" },
+  { pattern: /^stock_location_address\./, entityType: "stock_location_addresses" },
+  // Tax Rate zones
+  { pattern: /^tax_rate\.details\./, entityType: "tax_rates" },
+  { pattern: /^tax_rate\./, entityType: "tax_rates" },
+  // Tax Rate Rule zones
+  { pattern: /^tax_rate_rule\.details\./, entityType: "tax_rate_rules" },
+  { pattern: /^tax_rate_rule\./, entityType: "tax_rate_rules" },
+  // Tax Region zones
+  { pattern: /^tax_region\.details\./, entityType: "tax_regions" },
+  { pattern: /^tax_region\./, entityType: "tax_regions" },
+  // User zones
+  { pattern: /^user\.details\./, entityType: "users" },
+  { pattern: /^user\./, entityType: "users" },
+  // Generic pattern: {entity}.details.{position}
+  { pattern: /^(\w+)\.details\./, entityType: "" }
+  // Will extract from match
+];
+let customZoneMappings = {};
+function resolveEntityTypeFromZone(zone) {
+  if (customZoneMappings[zone]) {
+    return customZoneMappings[zone];
+  }
+  const entityTypes = [
+    "products",
+    "orders",
+    "categories",
+    "collections",
+    "customers",
+    "regions",
+    "sales_channels",
+    "stores",
+    "promotions",
+    "campaigns",
+    "price_lists",
+    "shipping_profiles",
+    "return_reasons",
+    "inventory_items",
+    "product_variants",
+    "account_holders",
+    "captures",
+    "carts",
+    "cart_addresses",
+    "cart_line_items",
+    "cart_line_item_adjustments",
+    "cart_line_item_tax_lines",
+    "cart_shipping_methods",
+    "cart_shipping_method_adjustments",
+    "cart_shipping_method_tax_lines",
+    "contact_email_subscriptions",
+    "contact_requests",
+    "credit_lines",
+    "customer_addresses",
+    "customer_groups",
+    "customer_group_customers",
+    "fulfillments",
+    "fulfillment_addresses",
+    "fulfillment_sets",
+    "geo_zones",
+    "images",
+    "inventory_levels",
+    "invites",
+    "order_addresses",
+    "order_changes",
+    "order_claims",
+    "order_claim_items",
+    "order_claim_item_images",
+    "order_credit_lines",
+    "order_exchanges",
+    "order_exchange_items",
+    "order_items",
+    "order_line_items",
+    "order_shipping_methods",
+    "payments",
+    "payment_collections",
+    "payment_sessions",
+    "product_options",
+    "product_option_values",
+    "product_tags",
+    "product_types",
+    "refunds",
+    "refund_reasons",
+    "region_countries",
+    "reservation_items",
+    "returns",
+    "return_items",
+    "service_zones",
+    "shipping_options",
+    "stock_locations",
+    "stock_location_addresses",
+    "tax_rates",
+    "tax_rate_rules",
+    "tax_regions",
+    "users"
+  ];
+  for (const entityType of entityTypes) {
+    const mapping = getEntityMapping(entityType);
+    if ((mapping == null ? void 0 : mapping.widgetZone) === zone) {
+      return entityType;
+    }
+  }
+  for (const { pattern, entityType } of ZONE_PATTERNS) {
+    const match = zone.match(pattern);
+    if (match) {
+      if (entityType === "" && match[1]) {
+        const singular = match[1];
+        return `${singular}s`;
+      }
+      return entityType;
+    }
+  }
+  const parts = zone.split(".");
+  if (parts.length > 0) {
+    const firstPart = parts[0];
+    if (firstPart && !firstPart.endsWith("s")) {
+      return `${firstPart}s`;
+    }
+    return firstPart;
+  }
+  return void 0;
+}
+const ENTITY_DETECTION_PATTERNS = [
+  // Products: typically have handle, title, description
+  {
+    patterns: ["handle", "title", "description", "subtitle"],
+    entityType: "products"
+  },
+  // Orders: typically have display_id, status, email
+  {
+    patterns: ["display_id", "status", "email", "currency_code"],
+    entityType: "orders"
+  },
+  // Categories: typically have name, handle, parent_category_id
+  {
+    patterns: ["name", "handle", "parent_category_id", "category_children"],
+    entityType: "categories"
+  },
+  // Collections: typically have title, handle
+  {
+    patterns: ["title", "handle", "products"],
+    entityType: "collections"
+  },
+  // Customers: typically have email, first_name, last_name
+  {
+    patterns: ["email", "first_name", "last_name", "phone"],
+    entityType: "customers"
+  },
+  // Regions: typically have name, currency_code
+  {
+    patterns: ["name", "currency_code", "countries"],
+    entityType: "regions"
+  },
+  // Sales Channels: typically have name, description
+  {
+    patterns: ["name", "description", "is_default"],
+    entityType: "sales_channels"
+  },
+  // Stores: typically have name, default_currency_code
+  {
+    patterns: ["name", "default_currency_code", "default_region_id"],
+    entityType: "stores"
+  },
+  // Promotions: typically have code, type, is_automatic
+  {
+    patterns: ["code", "type", "is_automatic", "status"],
+    entityType: "promotions"
+  },
+  // Campaigns: typically have name, campaign_identifier
+  {
+    patterns: ["name", "campaign_identifier", "budget"],
+    entityType: "campaigns"
+  },
+  // Price Lists: typically have name, type, status
+  {
+    patterns: ["name", "type", "status", "prices"],
+    entityType: "price_lists"
+  },
+  // Shipping Profiles: typically have name, type
+  {
+    patterns: ["name", "type", "shipping_options"],
+    entityType: "shipping_profiles"
+  },
+  // Return Reasons: typically have label, value
+  {
+    patterns: ["label", "value", "description"],
+    entityType: "return_reasons"
+  },
+  // Inventory Items: typically have sku, requires_shipping
+  {
+    patterns: ["sku", "requires_shipping", "hs_code"],
+    entityType: "inventory_items"
+  },
+  // Product Variants: typically have sku, title, inventory_quantity
+  {
+    patterns: ["sku", "title", "inventory_quantity", "manage_inventory"],
+    entityType: "product_variants"
+  },
+  // Carts: typically have email, region_id, currency_code
+  {
+    patterns: ["email", "region_id", "currency_code", "items"],
+    entityType: "carts"
+  },
+  // Payments: typically have amount, currency_code, provider_id
+  {
+    patterns: ["amount", "currency_code", "provider_id", "status"],
+    entityType: "payments"
+  },
+  // Fulfillments: typically have location_id, provider_id, shipped_at
+  {
+    patterns: ["location_id", "provider_id", "shipped_at", "delivered_at"],
+    entityType: "fulfillments"
+  },
+  // Returns: typically have order_id, status, items
+  {
+    patterns: ["order_id", "status", "items", "return_reason"],
+    entityType: "returns"
+  },
+  // Refunds: typically have amount, currency_code, reason
+  {
+    patterns: ["amount", "currency_code", "reason", "payment_id"],
+    entityType: "refunds"
+  },
+  // Customer Groups: typically have name, customers
+  {
+    patterns: ["name", "customers", "created_at"],
+    entityType: "customer_groups"
+  },
+  // Shipping Options: typically have name, price_type, service_zone_id
+  {
+    patterns: ["name", "price_type", "service_zone_id", "shipping_profile_id"],
+    entityType: "shipping_options"
+  },
+  // Tax Rates: typically have rate, code, name
+  {
+    patterns: ["rate", "code", "name", "region_id"],
+    entityType: "tax_rates"
+  },
+  // Users: typically have email, first_name, last_name
+  {
+    patterns: ["email", "first_name", "last_name", "role"],
+    entityType: "users"
+  }
+];
+function detectEntityTypeFromData(data) {
+  if (!data || typeof data !== "object") {
+    return void 0;
+  }
+  const dataKeys = Object.keys(data);
+  const scores = {};
+  for (const { patterns, entityType } of ENTITY_DETECTION_PATTERNS) {
+    const matchCount = patterns.filter((pattern) => dataKeys.includes(pattern)).length;
+    if (matchCount > 0) {
+      scores[entityType] = matchCount;
+    }
+  }
+  const sortedScores = Object.entries(scores).sort((a, b) => b[1] - a[1]);
+  if (sortedScores.length > 0 && sortedScores[0][1] > 0) {
+    return sortedScores[0][0];
+  }
+  return void 0;
+}
+function resolveQueryKey(entityType) {
+  const queryKeyMap = {
+    products: ["products"],
+    orders: ["orders"],
+    categories: ["product-categories"],
+    collections: ["collections"],
+    customers: ["customers"],
+    regions: ["regions"],
+    sales_channels: ["sales-channels"],
+    stores: ["stores"],
+    promotions: ["promotions"],
+    campaigns: ["campaigns"],
+    price_lists: ["price-lists"],
+    shipping_profiles: ["shipping-profiles"],
+    return_reasons: ["return-reasons"],
+    inventory_items: ["inventory-items"],
+    product_variants: ["product-variants"],
+    account_holders: ["account-holders"],
+    captures: ["captures"],
+    carts: ["carts"],
+    cart_addresses: ["cart-addresses"],
+    cart_line_items: ["cart-line-items"],
+    cart_line_item_adjustments: ["cart-line-item-adjustments"],
+    cart_line_item_tax_lines: ["cart-line-item-tax-lines"],
+    cart_shipping_methods: ["cart-shipping-methods"],
+    cart_shipping_method_adjustments: ["cart-shipping-method-adjustments"],
+    cart_shipping_method_tax_lines: ["cart-shipping-method-tax-lines"],
+    contact_email_subscriptions: ["contact-email-subscriptions"],
+    contact_requests: ["contact-requests"],
+    credit_lines: ["credit-lines"],
+    customer_addresses: ["customer-addresses"],
+    customer_groups: ["customer-groups"],
+    customer_group_customers: ["customer-group-customers"],
+    fulfillments: ["fulfillments"],
+    fulfillment_addresses: ["fulfillment-addresses"],
+    fulfillment_sets: ["fulfillment-sets"],
+    geo_zones: ["geo-zones"],
+    images: ["images"],
+    inventory_levels: ["inventory-levels"],
+    invites: ["invites"],
+    order_addresses: ["order-addresses"],
+    order_changes: ["order-changes"],
+    order_claims: ["order-claims"],
+    order_claim_items: ["order-claim-items"],
+    order_claim_item_images: ["order-claim-item-images"],
+    order_credit_lines: ["order-credit-lines"],
+    order_exchanges: ["order-exchanges"],
+    order_exchange_items: ["order-exchange-items"],
+    order_items: ["order-items"],
+    order_line_items: ["order-line-items"],
+    order_shipping_methods: ["order-shipping-methods"],
+    payments: ["payments"],
+    payment_collections: ["payment-collections"],
+    payment_sessions: ["payment-sessions"],
+    product_options: ["product-options"],
+    product_option_values: ["product-option-values"],
+    product_tags: ["product-tags"],
+    product_types: ["product-types"],
+    refunds: ["refunds"],
+    refund_reasons: ["refund-reasons"],
+    region_countries: ["region-countries"],
+    reservation_items: ["reservation-items"],
+    returns: ["returns"],
+    return_items: ["return-items"],
+    service_zones: ["service-zones"],
+    shipping_options: ["shipping-options"],
+    stock_locations: ["stock-locations"],
+    stock_location_addresses: ["stock-location-addresses"],
+    tax_rates: ["tax-rates"],
+    tax_rate_rules: ["tax-rate-rules"],
+    tax_regions: ["tax-regions"],
+    users: ["users"]
+  };
+  return queryKeyMap[entityType] || [entityType];
+}
+const UniversalMetadataWidget = ({
+  data,
+  zone
+}) => {
+  const entityType = useMemo(() => {
+    if (zone) {
+      const zoneResolved = resolveEntityTypeFromZone(zone);
+      if (zoneResolved) {
+        return zoneResolved;
+      }
+    }
+    if (data) {
+      const dataDetected = detectEntityTypeFromData(data);
+      if (dataDetected) {
+        return dataDetected;
+      }
+    }
+    console.warn(
+      "[UniversalMetadataWidget] Could not detect entity type. Using default: products",
+      { zone, dataKeys: data ? Object.keys(data) : [] }
+    );
+    return "products";
+  }, [zone, data]);
+  const { data: descriptors = [], isPending } = useMetadataConfig({
+    entity: entityType
+  });
+  if (!isPending && descriptors.length === 0) {
+    return null;
+  }
+  const queryKey = useMemo(() => {
+    return resolveQueryKey(entityType);
+  }, [entityType]);
+  return /* @__PURE__ */ jsx(
+    MetadataTableWidget,
+    {
+      data,
+      entityType,
+      queryKey
+    }
+  );
+};
+const Widget$d = ({ data }) => {
+  return /* @__PURE__ */ jsx(UniversalMetadataWidget, { data, zone: "campaign.details.after" });
+};
+defineWidgetConfig({
+  zone: "campaign.details.after"
+});
+const Widget$c = ({ data }) => {
+  return /* @__PURE__ */ jsx(UniversalMetadataWidget, { data, zone: "product_category.details.after" });
+};
+defineWidgetConfig({
+  zone: "product_category.details.after"
+});
+const Widget$b = ({ data }) => {
+  return /* @__PURE__ */ jsx(UniversalMetadataWidget, { data, zone: "product_collection.details.after" });
+};
+defineWidgetConfig({
+  zone: "product_collection.details.after"
+});
+const Widget$a = ({ data }) => {
+  return /* @__PURE__ */ jsx(UniversalMetadataWidget, { data, zone: "customer.details.after" });
+};
+defineWidgetConfig({
+  zone: "customer.details.after"
+});
+const GenericMetadataTableWidget = ({ data }) => {
+  return /* @__PURE__ */ jsx(
+    UniversalMetadataWidget,
+    {
+      data,
+      zone: "product.details.after"
+    }
+  );
+};
+defineWidgetConfig({
+  zone: "product.details.after"
+  // TODO: Replace with your entity's zone (e.g., "customer.details.after")
+});
+const HideDefaultMetadataWidget = () => {
+  useEffect(() => {
+    const hideMetadataSection = () => {
+      const headings = document.querySelectorAll("h2");
+      headings.forEach((heading) => {
+        var _a;
+        if (((_a = heading.textContent) == null ? void 0 : _a.trim()) === "Metadata") {
+          let container = heading.parentElement;
+          while (container && container !== document.body) {
+            const hasContainerClass = container.classList.toString().includes("Container");
+            const isInSidebar = container.closest('[class*="Sidebar"]') || container.closest('[class*="sidebar"]');
+            if (hasContainerClass || isInSidebar) {
+              const editLink = container.querySelector('a[href*="metadata/edit"]');
+              const badge = container.querySelector('div[class*="Badge"]');
+              if (editLink && badge) {
+                container.style.display = "none";
+                container.setAttribute("data-metadata-hidden", "true");
+                return;
+              }
+            }
+            container = container.parentElement;
+          }
+        }
+      });
+    };
+    const runHide = () => {
+      setTimeout(hideMetadataSection, 100);
+    };
+    runHide();
+    const observer = new MutationObserver(() => {
+      const alreadyHidden = document.querySelector('[data-metadata-hidden="true"]');
+      if (!alreadyHidden) {
+        runHide();
+      }
+    });
+    observer.observe(document.body, {
+      childList: true,
+      subtree: true
+    });
+    return () => {
+      observer.disconnect();
+      const hidden = document.querySelector('[data-metadata-hidden="true"]');
+      if (hidden) {
+        hidden.style.display = "";
+        hidden.removeAttribute("data-metadata-hidden");
+      }
+    };
+  }, []);
+  return null;
+};
+const ProductHideDefaultMetadata = () => {
+  return /* @__PURE__ */ jsx(HideDefaultMetadataWidget, {});
+};
+defineWidgetConfig({
+  zone: "product.details.side.before"
+});
+const Widget$9 = ({ data }) => {
+  return /* @__PURE__ */ jsx(UniversalMetadataWidget, { data, zone: "inventory_item.details.after" });
+};
+defineWidgetConfig({
+  zone: "inventory_item.details.after"
+});
+const Widget$8 = ({ data }) => {
+  return /* @__PURE__ */ jsx(UniversalMetadataWidget, { data, zone: "order.details.after" });
+};
+defineWidgetConfig({
+  zone: "order.details.after"
+});
+const Widget$7 = ({ data }) => {
+  return /* @__PURE__ */ jsx(UniversalMetadataWidget, { data, zone: "price_list.details.after" });
+};
+defineWidgetConfig({
+  zone: "price_list.details.after"
+});
+const Widget$6 = ({ data }) => {
+  return /* @__PURE__ */ jsx(UniversalMetadataWidget, { data, zone: "product_variant.details.after" });
+};
+defineWidgetConfig({
+  zone: "product_variant.details.after"
+});
+const Widget$5 = ({ data }) => {
+  return /* @__PURE__ */ jsx(UniversalMetadataWidget, { data, zone: "product.details.after" });
+};
+defineWidgetConfig({
+  zone: "product.details.after"
+});
+const Widget$4 = ({ data }) => {
+  return /* @__PURE__ */ jsx(UniversalMetadataWidget, { data, zone: "promotion.details.after" });
+};
+defineWidgetConfig({
+  zone: "promotion.details.after"
+});
+const Widget$3 = ({ data }) => {
+  return /* @__PURE__ */ jsx(UniversalMetadataWidget, { data, zone: "region.details.after" });
+};
+defineWidgetConfig({
+  zone: "region.details.after"
+});
+const Widget$2 = ({ data }) => {
+  return /* @__PURE__ */ jsx(UniversalMetadataWidget, { data, zone: "sales_channel.details.after" });
+};
+defineWidgetConfig({
+  zone: "sales_channel.details.after"
+});
+const Widget$1 = ({ data }) => {
+  return /* @__PURE__ */ jsx(UniversalMetadataWidget, { data, zone: "shipping_profile.details.after" });
+};
+defineWidgetConfig({
+  zone: "shipping_profile.details.after"
+});
+const Widget = ({ data }) => {
+  return /* @__PURE__ */ jsx(UniversalMetadataWidget, { data, zone: "store.details.after" });
+};
+defineWidgetConfig({
+  zone: "store.details.after"
+});
+const widgetModule = { widgets: [
+  {
+    Component: Widget$d,
+    zone: ["campaign.details.after"]
+  },
+  {
+    Component: Widget$c,
+    zone: ["product_category.details.after"]
+  },
+  {
+    Component: Widget$b,
+    zone: ["product_collection.details.after"]
+  },
+  {
+    Component: Widget$a,
+    zone: ["customer.details.after"]
+  },
+  {
+    Component: GenericMetadataTableWidget,
+    zone: ["product.details.after"]
+  },
+  {
+    Component: ProductHideDefaultMetadata,
+    zone: ["product.details.side.before"]
+  },
+  {
+    Component: Widget$9,
+    zone: ["inventory_item.details.after"]
+  },
+  {
+    Component: Widget$8,
+    zone: ["order.details.after"]
+  },
+  {
+    Component: Widget$7,
+    zone: ["price_list.details.after"]
+  },
+  {
+    Component: Widget$6,
+    zone: ["product_variant.details.after"]
+  },
+  {
+    Component: Widget$5,
+    zone: ["product.details.after"]
+  },
+  {
+    Component: Widget$4,
+    zone: ["promotion.details.after"]
+  },
+  {
+    Component: Widget$3,
+    zone: ["region.details.after"]
+  },
+  {
+    Component: Widget$2,
+    zone: ["sales_channel.details.after"]
+  },
+  {
+    Component: Widget$1,
+    zone: ["shipping_profile.details.after"]
+  },
+  {
+    Component: Widget,
+    zone: ["store.details.after"]
+  }
+] };
+const routeModule = {
+  routes: []
+};
+const menuItemModule = {
+  menuItems: []
+};
+const formModule = { customFields: {} };
+const displayModule = {
+  displays: {}
+};
+const i18nModule = { resources: {} };
+const plugin = {
+  widgetModule,
+  routeModule,
+  menuItemModule,
+  formModule,
+  displayModule,
+  i18nModule
+};
+export {
+  plugin as default
+};