medusa-profile-shipping 0.1.0

package/README.md

@@ -0,0 +1,117 @@
+# medusa-profile-shipping
+
+Profile-grouped shipping selection for Medusa v2 storefronts.
+
+Medusa requires **one shipping method per shipping profile** in the cart:
+core validates coverage at "Place Order", and its add-shipping-method
+workflow replaces same-profile methods while keeping the rest. The stock
+Next.js starter renders a single flat option list, so a mixed cart (a
+regulated item on an "FFL" profile plus a t-shirt on the default profile)
+can never be completed through it — the buyer picks one method, and
+completion rejects with *"the cart items require shipping profiles that are
+not satisfied"*.
+
+This package turns that into a per-profile selection: group the cart's items
+by shipping profile, show each group the options that can actually fulfill
+it, and require one pick per group before continuing to payment.
+
+Zero runtime dependencies. Structurally typed (no `@medusajs/*` version
+coupling): pass any objects shaped like a Medusa cart and its shipping
+options. React is an optional peer, only for the `/react` hook.
+
+## Install
+
+```bash
+npm install medusa-profile-shipping
+```
+
+## Data prerequisites
+
+Fetch with these fields so the grouping has data (both are plain Medusa
+store-API field selections):
+
+```ts
+// cart:
+"items.product.shipping_profile.id,items.product.shipping_profile.name,+shipping_methods.shipping_option_id"
+// shipping options:
+"+shipping_profile_id"
+```
+
+## Helpers (framework-agnostic)
+
+```ts
+import {
+  groupCartByShippingProfile,
+  optionsForProfileGroup,
+  selectionsFromCart,
+  allGroupsCovered,
+  groupKey,
+} from "medusa-profile-shipping"
+
+const groups = groupCartByShippingProfile(cart)
+// [{ profileId: "sp_nfa", profileName: "NFA", itemTitles: ["Suppressor"] },
+//  { profileId: "sp_default", profileName: "Other", itemTitles: ["Shirt"] }]
+
+const nfaOptions = optionsForProfileGroup(shippingOptions, groups[0])
+const selections = selectionsFromCart(cart, shippingOptions)
+const readyForPayment = allGroupsCovered(groups, selections)
+```
+
+Missing data fails open: items without profile data form one group that sees
+every option, and option lists without `shipping_profile_id` are never
+filtered. Medusa's completion validation remains the backstop.
+
+## React hook (headless)
+
+```tsx
+import { useProfileShipping } from "medusa-profile-shipping/react"
+
+const { groups, optionsFor, selections, select, covered, saving, error, groupKey } =
+  useProfileShipping({
+    cart,
+    options: shippingOptions,
+    // your server action / API call; Medusa keeps other profiles' methods
+    setShippingMethod: (optionId) =>
+      sdk.store.cart.addShippingMethod(cart.id, { option_id: optionId }),
+  })
+
+return (
+  <>
+    {groups.map((group) => (
+      <fieldset key={groupKey(group)}>
+        {groups.length > 1 && (
+          <legend>
+            {group.profileName} — {group.itemTitles.join(", ")}
+          </legend>
+        )}
+        {optionsFor(group).map((option) => (
+          <label key={option.id}>
+            <input
+              type="radio"
+              checked={selections[groupKey(group)] === option.id}
+              onChange={() => select(group, option.id)}
+            />
+            {option.name}
+          </label>
+        ))}
+      </fieldset>
+    ))}
+    <button disabled={!covered || saving}>Continue to payment</button>
+  </>
+)
+```
+
+`select()` is optimistic with rollback, `covered` gates the continue button,
+and single-profile carts produce one group — render it without the legend
+and the step looks identical to stock.
+
+## Why this isn't a Medusa (backend) plugin
+
+There is nothing to install server-side: Medusa core already validates
+profile coverage at completion and manages one-method-per-profile on the
+cart. The entire gap is storefront UI, which backend plugins cannot ship.
+This package is the reusable piece of that UI logic.
+
+## License
+
+MIT

package/dist/chunk-QNKJOATD.mjs

@@ -0,0 +1,54 @@
+// src/index.ts
+var NO_PROFILE_KEY = "__no_profile__";
+function groupKey(group) {
+  return group.profileId ?? NO_PROFILE_KEY;
+}
+function groupCartByShippingProfile(cart) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const item of cart.items ?? []) {
+    const profile = item.product?.shipping_profile;
+    const key = profile?.id ?? NO_PROFILE_KEY;
+    const title = item.product_title ?? item.title ?? "Item";
+    const existing = groups.get(key);
+    if (existing) {
+      if (!existing.itemTitles.includes(title)) existing.itemTitles.push(title);
+    } else {
+      groups.set(key, {
+        profileId: profile?.id ?? null,
+        profileName: profile?.name ?? "Other items",
+        itemTitles: [title]
+      });
+    }
+  }
+  return Array.from(groups.values());
+}
+function optionsForProfileGroup(options, group) {
+  if (!group.profileId) return options;
+  if (!options.some((o) => o.shipping_profile_id)) return options;
+  return options.filter((o) => o.shipping_profile_id === group.profileId);
+}
+function selectionsFromCart(cart, options) {
+  const optionProfile = new Map(
+    options.map((o) => [o.id, o.shipping_profile_id ?? null])
+  );
+  const out = {};
+  for (const method of cart.shipping_methods ?? []) {
+    const optionId = method.shipping_option_id;
+    if (!optionId) continue;
+    const profileId = optionProfile.get(optionId);
+    out[profileId ?? NO_PROFILE_KEY] = optionId;
+  }
+  return out;
+}
+function allGroupsCovered(groups, selections) {
+  return groups.every((g) => !!selections[groupKey(g)]);
+}
+
+export {
+  NO_PROFILE_KEY,
+  groupKey,
+  groupCartByShippingProfile,
+  optionsForProfileGroup,
+  selectionsFromCart,
+  allGroupsCovered
+};

package/dist/index.d.mts

@@ -0,0 +1,60 @@
+/**
+ * medusa-profile-shipping — profile-grouped shipping selection for Medusa v2
+ * storefronts.
+ *
+ * Medusa requires one shipping method per shipping profile present in the
+ * cart: core validates coverage at completion, and its add-shipping-method
+ * workflow replaces same-profile methods while keeping the rest. Stock
+ * storefronts render a single flat option list, so mixed-profile carts (a
+ * regulated item plus an accessory, say) cannot be completed through them.
+ *
+ * These helpers are structurally typed and dependency-free: pass any objects
+ * shaped like a Medusa cart and its shipping options (HttpTypes.StoreCart and
+ * StoreCartShippingOption satisfy them). Fetch shipping options with
+ * `fields=+shipping_profile_id` and the cart with
+ * `items.product.shipping_profile.id` / `.name` so the grouping has data.
+ */
+type ProfileShippingCartItem = {
+    title?: string | null;
+    product_title?: string | null;
+    product?: {
+        shipping_profile?: {
+            id?: string | null;
+            name?: string | null;
+        } | null;
+    } | null;
+};
+type ProfileShippingCart = {
+    items?: ProfileShippingCartItem[] | null;
+    shipping_methods?: {
+        shipping_option_id?: string | null;
+    }[] | null;
+};
+type ProfileShippingOption = {
+    id: string;
+    shipping_profile_id?: string | null;
+};
+type ShippingProfileGroup = {
+    /** null when the cart items carried no profile data (options unfiltered). */
+    profileId: string | null;
+    profileName: string;
+    itemTitles: string[];
+};
+/** Key used in selection maps for items without profile data. */
+declare const NO_PROFILE_KEY = "__no_profile__";
+/** Selection-map key for a group. */
+declare function groupKey(group: ShippingProfileGroup): string;
+/** Unique shipping-profile groups across the cart's items, stable order. */
+declare function groupCartByShippingProfile(cart: ProfileShippingCart): ShippingProfileGroup[];
+/**
+ * The options that can fulfill a group. Unfiltered when the group or the
+ * option list carries no profile data — never hide everything on missing
+ * fields; Medusa's completion validation remains the backstop.
+ */
+declare function optionsForProfileGroup<T extends ProfileShippingOption>(options: T[], group: ShippingProfileGroup): T[];
+/** profileId (or NO_PROFILE_KEY) -> selected option id, from saved methods. */
+declare function selectionsFromCart(cart: ProfileShippingCart, options: ProfileShippingOption[]): Record<string, string>;
+/** True when every profile group has a selected method. */
+declare function allGroupsCovered(groups: ShippingProfileGroup[], selections: Record<string, string>): boolean;
+
+export { NO_PROFILE_KEY, type ProfileShippingCart, type ProfileShippingCartItem, type ProfileShippingOption, type ShippingProfileGroup, allGroupsCovered, groupCartByShippingProfile, groupKey, optionsForProfileGroup, selectionsFromCart };

package/dist/index.d.ts

@@ -0,0 +1,60 @@
+/**
+ * medusa-profile-shipping — profile-grouped shipping selection for Medusa v2
+ * storefronts.
+ *
+ * Medusa requires one shipping method per shipping profile present in the
+ * cart: core validates coverage at completion, and its add-shipping-method
+ * workflow replaces same-profile methods while keeping the rest. Stock
+ * storefronts render a single flat option list, so mixed-profile carts (a
+ * regulated item plus an accessory, say) cannot be completed through them.
+ *
+ * These helpers are structurally typed and dependency-free: pass any objects
+ * shaped like a Medusa cart and its shipping options (HttpTypes.StoreCart and
+ * StoreCartShippingOption satisfy them). Fetch shipping options with
+ * `fields=+shipping_profile_id` and the cart with
+ * `items.product.shipping_profile.id` / `.name` so the grouping has data.
+ */
+type ProfileShippingCartItem = {
+    title?: string | null;
+    product_title?: string | null;
+    product?: {
+        shipping_profile?: {
+            id?: string | null;
+            name?: string | null;
+        } | null;
+    } | null;
+};
+type ProfileShippingCart = {
+    items?: ProfileShippingCartItem[] | null;
+    shipping_methods?: {
+        shipping_option_id?: string | null;
+    }[] | null;
+};
+type ProfileShippingOption = {
+    id: string;
+    shipping_profile_id?: string | null;
+};
+type ShippingProfileGroup = {
+    /** null when the cart items carried no profile data (options unfiltered). */
+    profileId: string | null;
+    profileName: string;
+    itemTitles: string[];
+};
+/** Key used in selection maps for items without profile data. */
+declare const NO_PROFILE_KEY = "__no_profile__";
+/** Selection-map key for a group. */
+declare function groupKey(group: ShippingProfileGroup): string;
+/** Unique shipping-profile groups across the cart's items, stable order. */
+declare function groupCartByShippingProfile(cart: ProfileShippingCart): ShippingProfileGroup[];
+/**
+ * The options that can fulfill a group. Unfiltered when the group or the
+ * option list carries no profile data — never hide everything on missing
+ * fields; Medusa's completion validation remains the backstop.
+ */
+declare function optionsForProfileGroup<T extends ProfileShippingOption>(options: T[], group: ShippingProfileGroup): T[];
+/** profileId (or NO_PROFILE_KEY) -> selected option id, from saved methods. */
+declare function selectionsFromCart(cart: ProfileShippingCart, options: ProfileShippingOption[]): Record<string, string>;
+/** True when every profile group has a selected method. */
+declare function allGroupsCovered(groups: ShippingProfileGroup[], selections: Record<string, string>): boolean;
+
+export { NO_PROFILE_KEY, type ProfileShippingCart, type ProfileShippingCartItem, type ProfileShippingOption, type ShippingProfileGroup, allGroupsCovered, groupCartByShippingProfile, groupKey, optionsForProfileGroup, selectionsFromCart };

package/dist/index.js

@@ -0,0 +1,83 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  NO_PROFILE_KEY: () => NO_PROFILE_KEY,
+  allGroupsCovered: () => allGroupsCovered,
+  groupCartByShippingProfile: () => groupCartByShippingProfile,
+  groupKey: () => groupKey,
+  optionsForProfileGroup: () => optionsForProfileGroup,
+  selectionsFromCart: () => selectionsFromCart
+});
+module.exports = __toCommonJS(index_exports);
+var NO_PROFILE_KEY = "__no_profile__";
+function groupKey(group) {
+  return group.profileId ?? NO_PROFILE_KEY;
+}
+function groupCartByShippingProfile(cart) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const item of cart.items ?? []) {
+    const profile = item.product?.shipping_profile;
+    const key = profile?.id ?? NO_PROFILE_KEY;
+    const title = item.product_title ?? item.title ?? "Item";
+    const existing = groups.get(key);
+    if (existing) {
+      if (!existing.itemTitles.includes(title)) existing.itemTitles.push(title);
+    } else {
+      groups.set(key, {
+        profileId: profile?.id ?? null,
+        profileName: profile?.name ?? "Other items",
+        itemTitles: [title]
+      });
+    }
+  }
+  return Array.from(groups.values());
+}
+function optionsForProfileGroup(options, group) {
+  if (!group.profileId) return options;
+  if (!options.some((o) => o.shipping_profile_id)) return options;
+  return options.filter((o) => o.shipping_profile_id === group.profileId);
+}
+function selectionsFromCart(cart, options) {
+  const optionProfile = new Map(
+    options.map((o) => [o.id, o.shipping_profile_id ?? null])
+  );
+  const out = {};
+  for (const method of cart.shipping_methods ?? []) {
+    const optionId = method.shipping_option_id;
+    if (!optionId) continue;
+    const profileId = optionProfile.get(optionId);
+    out[profileId ?? NO_PROFILE_KEY] = optionId;
+  }
+  return out;
+}
+function allGroupsCovered(groups, selections) {
+  return groups.every((g) => !!selections[groupKey(g)]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NO_PROFILE_KEY,
+  allGroupsCovered,
+  groupCartByShippingProfile,
+  groupKey,
+  optionsForProfileGroup,
+  selectionsFromCart
+});

package/dist/index.mjs

@@ -0,0 +1,16 @@
+import {
+  NO_PROFILE_KEY,
+  allGroupsCovered,
+  groupCartByShippingProfile,
+  groupKey,
+  optionsForProfileGroup,
+  selectionsFromCart
+} from "./chunk-QNKJOATD.mjs";
+export {
+  NO_PROFILE_KEY,
+  allGroupsCovered,
+  groupCartByShippingProfile,
+  groupKey,
+  optionsForProfileGroup,
+  selectionsFromCart
+};

package/dist/react.d.mts

@@ -0,0 +1,25 @@
+import { ProfileShippingOption, ProfileShippingCart, ShippingProfileGroup, groupKey } from './index.mjs';
+
+type UseProfileShippingArgs<TOption extends ProfileShippingOption> = {
+    cart: ProfileShippingCart;
+    options: TOption[];
+    /** Persist one selection (Medusa replaces same-profile methods, keeps others). */
+    setShippingMethod: (optionId: string) => Promise<unknown>;
+};
+type UseProfileShippingResult<TOption extends ProfileShippingOption> = {
+    groups: ShippingProfileGroup[];
+    /** Options that can fulfill the given group. */
+    optionsFor: (group: ShippingProfileGroup) => TOption[];
+    /** group key -> selected option id */
+    selections: Record<string, string>;
+    /** Select an option for a group; optimistic with rollback on failure. */
+    select: (group: ShippingProfileGroup, optionId: string) => Promise<void>;
+    /** Every group has a method — safe to continue to payment. */
+    covered: boolean;
+    saving: boolean;
+    error: string | null;
+    groupKey: typeof groupKey;
+};
+declare function useProfileShipping<TOption extends ProfileShippingOption>({ cart, options, setShippingMethod, }: UseProfileShippingArgs<TOption>): UseProfileShippingResult<TOption>;
+
+export { type UseProfileShippingArgs, type UseProfileShippingResult, useProfileShipping };

package/dist/react.d.ts

@@ -0,0 +1,25 @@
+import { ProfileShippingOption, ProfileShippingCart, ShippingProfileGroup, groupKey } from './index.js';
+
+type UseProfileShippingArgs<TOption extends ProfileShippingOption> = {
+    cart: ProfileShippingCart;
+    options: TOption[];
+    /** Persist one selection (Medusa replaces same-profile methods, keeps others). */
+    setShippingMethod: (optionId: string) => Promise<unknown>;
+};
+type UseProfileShippingResult<TOption extends ProfileShippingOption> = {
+    groups: ShippingProfileGroup[];
+    /** Options that can fulfill the given group. */
+    optionsFor: (group: ShippingProfileGroup) => TOption[];
+    /** group key -> selected option id */
+    selections: Record<string, string>;
+    /** Select an option for a group; optimistic with rollback on failure. */
+    select: (group: ShippingProfileGroup, optionId: string) => Promise<void>;
+    /** Every group has a method — safe to continue to payment. */
+    covered: boolean;
+    saving: boolean;
+    error: string | null;
+    groupKey: typeof groupKey;
+};
+declare function useProfileShipping<TOption extends ProfileShippingOption>({ cart, options, setShippingMethod, }: UseProfileShippingArgs<TOption>): UseProfileShippingResult<TOption>;
+
+export { type UseProfileShippingArgs, type UseProfileShippingResult, useProfileShipping };

package/dist/react.js

@@ -0,0 +1,130 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/react.ts
+var react_exports = {};
+__export(react_exports, {
+  useProfileShipping: () => useProfileShipping
+});
+module.exports = __toCommonJS(react_exports);
+var import_react = require("react");
+
+// src/index.ts
+var NO_PROFILE_KEY = "__no_profile__";
+function groupKey(group) {
+  return group.profileId ?? NO_PROFILE_KEY;
+}
+function groupCartByShippingProfile(cart) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const item of cart.items ?? []) {
+    const profile = item.product?.shipping_profile;
+    const key = profile?.id ?? NO_PROFILE_KEY;
+    const title = item.product_title ?? item.title ?? "Item";
+    const existing = groups.get(key);
+    if (existing) {
+      if (!existing.itemTitles.includes(title)) existing.itemTitles.push(title);
+    } else {
+      groups.set(key, {
+        profileId: profile?.id ?? null,
+        profileName: profile?.name ?? "Other items",
+        itemTitles: [title]
+      });
+    }
+  }
+  return Array.from(groups.values());
+}
+function optionsForProfileGroup(options, group) {
+  if (!group.profileId) return options;
+  if (!options.some((o) => o.shipping_profile_id)) return options;
+  return options.filter((o) => o.shipping_profile_id === group.profileId);
+}
+function selectionsFromCart(cart, options) {
+  const optionProfile = new Map(
+    options.map((o) => [o.id, o.shipping_profile_id ?? null])
+  );
+  const out = {};
+  for (const method of cart.shipping_methods ?? []) {
+    const optionId = method.shipping_option_id;
+    if (!optionId) continue;
+    const profileId = optionProfile.get(optionId);
+    out[profileId ?? NO_PROFILE_KEY] = optionId;
+  }
+  return out;
+}
+function allGroupsCovered(groups, selections) {
+  return groups.every((g) => !!selections[groupKey(g)]);
+}
+
+// src/react.ts
+function useProfileShipping({
+  cart,
+  options,
+  setShippingMethod
+}) {
+  const groups = (0, import_react.useMemo)(() => groupCartByShippingProfile(cart), [cart]);
+  const [selections, setSelections] = (0, import_react.useState)(
+    () => selectionsFromCart(cart, options)
+  );
+  const [saving, setSaving] = (0, import_react.useState)(false);
+  const [error, setError] = (0, import_react.useState)(null);
+  (0, import_react.useEffect)(() => {
+    setSelections(selectionsFromCart(cart, options));
+  }, [cart.shipping_methods, options]);
+  const optionsFor = (0, import_react.useCallback)(
+    (group) => optionsForProfileGroup(options, group),
+    [options]
+  );
+  const select = (0, import_react.useCallback)(
+    async (group, optionId) => {
+      const key = groupKey(group);
+      const previous = selections[key];
+      setError(null);
+      setSaving(true);
+      setSelections((prev) => ({ ...prev, [key]: optionId }));
+      try {
+        await setShippingMethod(optionId);
+      } catch (e) {
+        setSelections((prev) => {
+          const next = { ...prev };
+          if (previous) next[key] = previous;
+          else delete next[key];
+          return next;
+        });
+        setError(e instanceof Error ? e.message : String(e));
+      } finally {
+        setSaving(false);
+      }
+    },
+    [selections, setShippingMethod]
+  );
+  return {
+    groups,
+    optionsFor,
+    selections,
+    select,
+    covered: allGroupsCovered(groups, selections),
+    saving,
+    error,
+    groupKey
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useProfileShipping
+});

package/dist/react.mjs

@@ -0,0 +1,65 @@
+import {
+  allGroupsCovered,
+  groupCartByShippingProfile,
+  groupKey,
+  optionsForProfileGroup,
+  selectionsFromCart
+} from "./chunk-QNKJOATD.mjs";
+
+// src/react.ts
+import { useCallback, useEffect, useMemo, useState } from "react";
+function useProfileShipping({
+  cart,
+  options,
+  setShippingMethod
+}) {
+  const groups = useMemo(() => groupCartByShippingProfile(cart), [cart]);
+  const [selections, setSelections] = useState(
+    () => selectionsFromCart(cart, options)
+  );
+  const [saving, setSaving] = useState(false);
+  const [error, setError] = useState(null);
+  useEffect(() => {
+    setSelections(selectionsFromCart(cart, options));
+  }, [cart.shipping_methods, options]);
+  const optionsFor = useCallback(
+    (group) => optionsForProfileGroup(options, group),
+    [options]
+  );
+  const select = useCallback(
+    async (group, optionId) => {
+      const key = groupKey(group);
+      const previous = selections[key];
+      setError(null);
+      setSaving(true);
+      setSelections((prev) => ({ ...prev, [key]: optionId }));
+      try {
+        await setShippingMethod(optionId);
+      } catch (e) {
+        setSelections((prev) => {
+          const next = { ...prev };
+          if (previous) next[key] = previous;
+          else delete next[key];
+          return next;
+        });
+        setError(e instanceof Error ? e.message : String(e));
+      } finally {
+        setSaving(false);
+      }
+    },
+    [selections, setShippingMethod]
+  );
+  return {
+    groups,
+    optionsFor,
+    selections,
+    select,
+    covered: allGroupsCovered(groups, selections),
+    saving,
+    error,
+    groupKey
+  };
+}
+export {
+  useProfileShipping
+};

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "medusa-profile-shipping",
+  "version": "0.1.0",
+  "description": "Profile-grouped shipping selection for Medusa v2 storefronts — one shipping method per shipping profile, so mixed carts (regulated + regular items) can actually check out",
+  "license": "MIT",
+  "author": "Kael Broersma",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Kaelbroersma/medusa-profile-shipping.git"
+  },
+  "keywords": [
+    "medusa",
+    "medusa-v2",
+    "medusajs",
+    "shipping",
+    "shipping-profile",
+    "checkout",
+    "storefront",
+    "nextjs"
+  ],
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "default": "./dist/index.mjs"
+    },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "import": "./dist/react.mjs",
+      "require": "./dist/react.js",
+      "default": "./dist/react.mjs"
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "peerDependencies": {
+    "react": ">=18"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.2",
+    "react": "^18.2.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.6.3",
+    "vitest": "^2.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}