@open-mercato/core 0.9.0 → 0.9.1-develop.7459.1.99e3accd30

package/src/modules/planner/lib/availabilityMerge.ts

@@ -3,6 +3,7 @@ type AvailabilityKind = 'availability' | 'unavailability'
 export type AvailabilityRuleLike = {
   id?: string
   rrule: string
+  timezone?: string
   exdates?: string[]
   kind?: AvailabilityKind
   note?: string | null
@@ -28,6 +29,45 @@ type ParsedRule = {
 }
 
 const DAY_MS = 24 * 60 * 60 * 1000
+const timezoneFormatters = new Map<string, Intl.DateTimeFormat>()
+
+function zonedParts(instant: Date, timezone: string): { year: number; month: number; day: number; hour: number; minute: number; second: number } {
+  let formatter = timezoneFormatters.get(timezone)
+  if (!formatter) {
+    formatter = new Intl.DateTimeFormat('en-US', {
+      timeZone: timezone, year: 'numeric', month: '2-digit', day: '2-digit',
+      hour: '2-digit', minute: '2-digit', second: '2-digit', hourCycle: 'h23',
+    })
+    if (timezoneFormatters.size >= 64) timezoneFormatters.delete(timezoneFormatters.keys().next().value!)
+    timezoneFormatters.set(timezone, formatter)
+  }
+  const parts = formatter.formatToParts(instant)
+  const number = (kind: string) => Number(parts.find((part) => part.type === kind)?.value)
+  return { year: number('year'), month: number('month'), day: number('day'), hour: number('hour'), minute: number('minute'), second: number('second') }
+}
+
+function zonedWallToInstant(wall: Date, timezone: string): Date | null {
+  const target = wall.getTime()
+  let candidate = target
+  for (let attempt = 0; attempt < 4; attempt += 1) {
+    const parts = zonedParts(new Date(candidate), timezone)
+    const displayed = Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second)
+    const next = candidate + target - displayed
+    if (next === candidate) return new Date(candidate)
+    candidate = next
+  }
+  return null
+}
+
+function zonedStartOfDay(dayKey: string, timezone: string): Date | null {
+  return zonedWallToInstant(new Date(`${dayKey}T00:00:00Z`), timezone)
+}
+
+function dayKeyForRule(instant: Date, timezone?: string): string {
+  if (!timezone || timezone === 'UTC' || timezone === 'Etc/UTC' || timezone === 'Etc/GMT') return toDayKey(instant)
+  const parts = zonedParts(instant, timezone)
+  return `${parts.year}-${String(parts.month).padStart(2, '0')}-${String(parts.day).padStart(2, '0')}`
+}
 
 function parseRrule(rule: string): ParsedRule | null {
   const dtStartMatch = rule.match(/DTSTART[:=](\d{8}T\d{6}Z?)/)
@@ -77,10 +117,10 @@ function buildExdateSets(exdates?: string[]) {
   return { dateOnly, dateTime }
 }
 
-function shouldExcludeOccurrence(startAt: Date, exdates?: string[]): boolean {
+function shouldExcludeOccurrence(startAt: Date, exdates?: string[], timezone?: string): boolean {
   const { dateOnly, dateTime } = buildExdateSets(exdates)
   if (dateTime.has(startAt.getTime())) return true
-  const dayKey = startAt.toISOString().slice(0, 10)
+  const dayKey = dayKeyForRule(startAt, timezone)
   return dateOnly.has(dayKey)
 }
 
@@ -92,15 +132,47 @@ function startOfDay(value: Date): Date {
   return new Date(Date.UTC(value.getUTCFullYear(), value.getUTCMonth(), value.getUTCDate()))
 }
 
-function expandRule(rule: AvailabilityRuleLike, parsed: ParsedRule, range: AvailabilityRange): AvailabilityWindow[] {
+function expandZonedRule(rule: AvailabilityRuleLike, parsed: ParsedRule, range: AvailabilityRange, weeklyScheduleTemplate: boolean): AvailabilityWindow[] {
+  const timezone = rule.timezone!
+  const anchor = zonedParts(parsed.startAt, timezone)
+  const anchorWall = Date.UTC(anchor.year, anchor.month - 1, anchor.day, anchor.hour, anchor.minute, anchor.second)
+  const step = parsed.freq === 'WEEKLY' ? 7 * DAY_MS : DAY_MS
+  const duration = parsed.durationMinutes * 60000
+  const windows: AvailabilityWindow[] = []
+  const rangeAnchor = zonedParts(range.start, timezone)
+  const rangeStartWall = Date.UTC(rangeAnchor.year, rangeAnchor.month - 1, rangeAnchor.day, rangeAnchor.hour, rangeAnchor.minute, rangeAnchor.second)
+  const rangeOffset = Math.floor((rangeStartWall - duration - DAY_MS - anchorWall) / step)
+  const skipped = weeklyScheduleTemplate && parsed.freq === 'WEEKLY' && parsed.count === undefined ? rangeOffset : Math.max(0, rangeOffset)
+  let wall = new Date(anchorWall + skipped * step)
+  let remaining = (parsed.count ?? Number.POSITIVE_INFINITY) - skipped
+  while (wall.getTime() <= range.end.getTime() + DAY_MS && remaining > 0) {
+    const start = zonedWallToInstant(wall, timezone)
+    if (start && !shouldExcludeOccurrence(start, rule.exdates, timezone)) {
+      const end = new Date(start.getTime() + duration)
+      if (end > range.start && start < range.end) windows.push({ start, end, ruleId: rule.id })
+    }
+    wall = new Date(wall.getTime() + step)
+    remaining -= 1
+  }
+  return windows
+}
+
+function expandRule(rule: AvailabilityRuleLike, parsed: ParsedRule, range: AvailabilityRange, weeklyScheduleTemplate: boolean): AvailabilityWindow[] {
   const { startAt, durationMinutes, freq, count, repeat } = parsed
   if (repeat === 'once') {
-    if (shouldExcludeOccurrence(startAt, rule.exdates)) return []
-    const start = startOfDay(startAt)
-    const end = new Date(start.getTime() + DAY_MS)
+    if (shouldExcludeOccurrence(startAt, rule.exdates, rule.timezone)) return []
+    const dayKey = dayKeyForRule(startAt, rule.timezone)
+    const start = rule.timezone ? zonedStartOfDay(dayKey, rule.timezone) : startOfDay(startAt)
+    if (!start) return []
+    const nextDay = new Date(new Date(`${dayKey}T00:00:00Z`).getTime() + DAY_MS).toISOString().slice(0, 10)
+    const end = rule.timezone ? zonedStartOfDay(nextDay, rule.timezone) : new Date(start.getTime() + DAY_MS)
+    if (!end) return []
     if (end <= range.start || start >= range.end) return []
     return [{ start, end, ruleId: rule.id }]
   }
+  if (rule.timezone && !['UTC', 'Etc/UTC', 'Etc/GMT'].includes(rule.timezone)) {
+    return expandZonedRule(rule, parsed, range, weeklyScheduleTemplate)
+  }
   const durationMs = durationMinutes * 60000
   const windows: AvailabilityWindow[] = []
   const addWindow = (start: Date) => {
@@ -110,39 +182,24 @@ function expandRule(rule: AvailabilityRuleLike, parsed: ParsedRule, range: Avail
     windows.push({ start, end, ruleId: rule.id })
   }
 
-  if (freq === 'DAILY') {
-    let cursor = new Date(startAt)
-    let remaining = count ?? Number.POSITIVE_INFINITY
-    while (cursor < range.end && remaining > 0) {
-      addWindow(new Date(cursor))
-      cursor = new Date(cursor.getTime() + DAY_MS)
-      remaining -= 1
-    }
-    return windows
-  }
-
-  let cursor = new Date(startAt)
-  let remaining = count ?? Number.POSITIVE_INFINITY
-  if (cursor < range.start) {
-    const diffDays = Math.floor((range.start.getTime() - cursor.getTime()) / DAY_MS)
-    const weeksToAdd = Math.floor(diffDays / 7)
-    if (weeksToAdd > 0) {
-      cursor = new Date(cursor.getTime() + weeksToAdd * 7 * DAY_MS)
-    }
-  }
+  const step = freq === 'WEEKLY' ? 7 * DAY_MS : DAY_MS
+  const rangeOffset = Math.floor((range.start.getTime() - durationMs - startAt.getTime()) / step)
+  const skipped = weeklyScheduleTemplate && freq === 'WEEKLY' && count === undefined ? rangeOffset : Math.max(0, rangeOffset)
+  let cursor = new Date(startAt.getTime() + skipped * step)
+  let remaining = (count ?? Number.POSITIVE_INFINITY) - skipped
   while (cursor < range.end && remaining > 0) {
     addWindow(new Date(cursor))
-    cursor = new Date(cursor.getTime() + 7 * DAY_MS)
+    cursor = new Date(cursor.getTime() + step)
     remaining -= 1
   }
   return windows
 }
 
-function expandRules(rules: AvailabilityRuleLike[], range: AvailabilityRange): AvailabilityWindow[] {
+function expandRules(rules: AvailabilityRuleLike[], range: AvailabilityRange, weeklyScheduleTemplate: boolean): AvailabilityWindow[] {
   const expanded = rules.flatMap((rule) => {
     const parsed = parseRrule(rule.rrule)
     if (!parsed) return []
-    return expandRule(rule, parsed, range)
+    return expandRule(rule, parsed, range, weeklyScheduleTemplate)
   })
   return expanded.sort((a, b) => a.start.getTime() - b.start.getTime())
 }
@@ -171,8 +228,11 @@ function subtractWindow(window: AvailabilityWindow, blockers: AvailabilityWindow
 export function getMergedAvailabilityWindows(params: {
   rules: AvailabilityRuleLike[]
   range: AvailabilityRange
+  respectTimezone?: boolean
+  weeklyScheduleTemplate?: boolean
 }): AvailabilityWindow[] {
-  const parsedRules = params.rules
+  const rules = params.respectTimezone ? params.rules : params.rules.map((rule) => ({ ...rule, timezone: undefined }))
+  const parsedRules = rules
     .map((rule) => {
       const parsed = parseRrule(rule.rrule)
       if (!parsed) return null
@@ -180,16 +240,17 @@ export function getMergedAvailabilityWindows(params: {
     })
     .filter((entry): entry is { rule: AvailabilityRuleLike; parsed: ParsedRule } => entry !== null)
 
-  const overrideDays = new Map<string, AvailabilityKind>()
+  const overrideDays = new Map<string, { kind: AvailabilityKind; dayKey: string; timezone?: string }>()
   parsedRules
     .filter(({ parsed }) => parsed.repeat === 'once')
     .forEach(({ rule, parsed }) => {
-      const dayKey = toDayKey(parsed.startAt)
+      const dayKey = dayKeyForRule(parsed.startAt, rule.timezone)
+      const overrideKey = `${rule.timezone ?? 'UTC'}|${dayKey}`
       const kind = rule.kind === 'unavailability' ? 'unavailability' : 'availability'
       if (kind === 'unavailability') {
-        overrideDays.set(dayKey, 'unavailability')
-      } else if (!overrideDays.has(dayKey)) {
-        overrideDays.set(dayKey, 'availability')
+        overrideDays.set(overrideKey, { kind, dayKey, timezone: rule.timezone })
+      } else if (!overrideDays.has(overrideKey)) {
+        overrideDays.set(overrideKey, { kind, dayKey, timezone: rule.timezone })
       }
     })
 
@@ -200,20 +261,24 @@ export function getMergedAvailabilityWindows(params: {
     .filter(({ parsed, rule }) => parsed.repeat !== 'once' && rule.kind === 'unavailability')
     .map(({ rule }) => rule)
 
-  const availabilityWindows = expandRules(availabilityRules, params.range)
-    .filter((window) => !overrideDays.has(toDayKey(window.start)))
-  const unavailabilityWindows = expandRules(unavailabilityRules, params.range)
+  const availabilityWindows = availabilityRules.flatMap((rule) =>
+    expandRules([rule], params.range, params.weeklyScheduleTemplate === true).filter((window) =>
+      !overrideDays.has(`${rule.timezone ?? 'UTC'}|${dayKeyForRule(window.start, rule.timezone)}`)))
+  const unavailabilityWindows = expandRules(unavailabilityRules, params.range, params.weeklyScheduleTemplate === true)
 
   const merged = unavailabilityWindows.length === 0
     ? availabilityWindows
     : availabilityWindows.flatMap((window) => subtractWindow(window, unavailabilityWindows))
 
   const overrideWindows: AvailabilityWindow[] = []
-  overrideDays.forEach((kind, dayKey) => {
+  overrideDays.forEach(({ kind, dayKey, timezone }) => {
     if (kind !== 'availability') return
-    const start = new Date(`${dayKey}T00:00:00Z`)
+    const start = timezone ? zonedStartOfDay(dayKey, timezone) : new Date(`${dayKey}T00:00:00Z`)
+    if (!start) return
     if (Number.isNaN(start.getTime())) return
-    const end = new Date(start.getTime() + DAY_MS)
+    const nextDay = new Date(new Date(`${dayKey}T00:00:00Z`).getTime() + DAY_MS).toISOString().slice(0, 10)
+    const end = timezone ? zonedStartOfDay(nextDay, timezone) : new Date(start.getTime() + DAY_MS)
+    if (!end) return
     if (end <= params.range.start || start >= params.range.end) return
     overrideWindows.push({ start, end })
   })

package/src/modules/planner/services/plannerAvailabilityService.ts

@@ -7,6 +7,8 @@ export interface PlannerAvailabilityService {
   getMergedAvailabilityWindows(params: {
     rules: AvailabilityRuleLike[]
     range: AvailabilityRange
+    respectTimezone?: boolean
+    weeklyScheduleTemplate?: boolean
   }): AvailabilityWindow[]
 }
 
@@ -14,6 +16,8 @@ export class DefaultPlannerAvailabilityService implements PlannerAvailabilitySer
   getMergedAvailabilityWindows(params: {
     rules: AvailabilityRuleLike[]
     range: AvailabilityRange
+    respectTimezone?: boolean
+    weeklyScheduleTemplate?: boolean
   }): AvailabilityWindow[] {
     return getMergedAvailabilityWindows(params)
   }

package/src/modules/sales/components/documents/LineItemDialog.tsx

@@ -48,7 +48,11 @@ import {
 import { E } from "#generated/entities.ids.generated";
 import { useT, useLocale } from "@open-mercato/shared/lib/i18n/context";
 import { useOrganizationScopeDetail } from "@open-mercato/shared/lib/frontend/useOrganizationScope";
-import { formatMoney, normalizeNumber } from "./lineItemUtils";
+import {
+  formatMoney,
+  normalizeNumber,
+  resolveCatalogPriceAmount,
+} from "./lineItemUtils";
 import type { SalesLineRecord } from "./lineItemTypes";
 import { prepareShippedLineUpdatePayload } from "./lineItemShipmentLock";
 import {
@@ -540,6 +544,7 @@ export function LineItemDialog({
   const [, setLineStatusLoading] = React.useState(false);
   const productOptionsRef = React.useRef<Map<string, ProductOption>>(new Map());
   const variantOptionsRef = React.useRef<Map<string, VariantOption>>(new Map());
+  const selectedProductIdRef = React.useRef<string | null>(null);
   const taxRatesRef = React.useRef<TaxRateOption[]>([]);
   const defaultTaxRateRef = React.useRef<TaxRateOption | null>(null);
   const dialogContentRef = React.useRef<HTMLDivElement | null>(null);
@@ -645,6 +650,7 @@ export function LineItemDialog({
       }
       setInitialValues(base);
       setLineMode(base.lineMode);
+      selectedProductIdRef.current = null;
       setProductOption(null);
       setVariantOption(null);
       setPriceOptions([]);
@@ -1108,7 +1114,15 @@ export function LineItemDialog({
               scopeTags: tags,
             } as PriceOption;
           })
-          .filter((entry): entry is PriceOption => Boolean(entry));
+          .filter((entry): entry is PriceOption => Boolean(entry))
+          .filter(
+            (entry) =>
+              resolveCatalogPriceAmount(
+                entry.amountNet,
+                entry.amountGross,
+                entry.displayMode === "excluding-tax" ? "net" : "gross",
+              ) !== null,
+          );
         setPriceOptions(mapped);
         return mapped;
       } catch (err) {
@@ -1198,9 +1212,11 @@ export function LineItemDialog({
         const mode =
           selected.displayMode === "excluding-tax" ? "net" : "gross";
         const amountPerBaseUnit =
-          mode === "net"
-            ? (selected.amountNet ?? selected.amountGross ?? 0)
-            : (selected.amountGross ?? selected.amountNet ?? 0);
+          resolveCatalogPriceAmount(
+            selected.amountNet,
+            selected.amountGross,
+            mode,
+          ) ?? 0;
         const factor = resolveUnitPriceFactor(options?.quantityUnit ?? null);
         const amount = Number.isFinite(amountPerBaseUnit * factor)
           ? amountPerBaseUnit * factor
@@ -1223,6 +1239,125 @@ export function LineItemDialog({
     [currencyCode, findTaxRateIdByValue, resolveTaxSelection, resolveUnitPriceFactor],
   );
 
+  const commitVariantSelection = React.useCallback(
+    ({
+      variantId,
+      productId,
+      product,
+      values,
+      setFormValue,
+    }: {
+      variantId: string | null;
+      productId: string | null;
+      product: ProductOption | null;
+      values: Record<string, unknown> | undefined;
+      setFormValue: ((id: string, value: unknown) => void) | undefined;
+    }) => {
+      const selectedOption = variantId
+        ? (variantOptionsRef.current.get(variantId) ?? null)
+        : null;
+      setVariantOption(selectedOption);
+      setFormValue?.("variantId", variantId);
+      const existingName = typeof values?.name === "string" ? values.name : "";
+      if (!existingName.trim()) {
+        setFormValue?.(
+          "name",
+          selectedOption?.title ?? product?.title ?? existingName,
+        );
+      }
+      const taxSource = hasTaxMetadata(selectedOption)
+        ? selectedOption
+        : hasTaxMetadata(product)
+          ? product
+          : null;
+      if (taxSource) {
+        const taxSelection = resolveTaxSelection(taxSource);
+        setFormValue?.("taxRate", taxSelection.taxRate ?? null);
+        setFormValue?.("taxRateId", taxSelection.taxRateId ?? null);
+      }
+      const prevSnapshot =
+        typeof values?.catalogSnapshot === "object" && values.catalogSnapshot
+          ? (values.catalogSnapshot as Record<string, unknown>)
+          : null;
+      if (variantId) {
+        setFormValue?.("catalogSnapshot", {
+          ...(prevSnapshot ?? {}),
+          variant: {
+            id: variantId,
+            title: selectedOption?.title ?? null,
+            sku: selectedOption?.sku ?? null,
+            thumbnailUrl: selectedOption?.thumbnailUrl ?? null,
+          },
+        });
+      } else if (prevSnapshot) {
+        const snapshot = { ...prevSnapshot };
+        if ("variant" in snapshot)
+          delete (snapshot as CatalogSnapshotRecord).variant;
+        setFormValue?.(
+          "catalogSnapshot",
+          Object.keys(snapshot).length ? snapshot : null,
+        );
+      } else {
+        setFormValue?.("catalogSnapshot", null);
+      }
+      if (productId) {
+        const currentQuantity =
+          typeof values?.quantity === "string" ? values.quantity : 1;
+        const currentQuantityUnit =
+          typeof values?.quantityUnit === "string" ? values.quantityUnit : null;
+        void loadPrices(
+          productId,
+          variantId,
+          currentQuantity,
+          currentQuantityUnit,
+        );
+      }
+    },
+    [hasTaxMetadata, loadPrices, resolveTaxSelection],
+  );
+
+  const autoSelectSoleVariant = React.useCallback(
+    async ({
+      productId,
+      product,
+      values,
+      setFormValue,
+    }: {
+      productId: string;
+      product: ProductOption | null;
+      values: Record<string, unknown>;
+      setFormValue: ((id: string, value: unknown) => void) | undefined;
+    }) => {
+      let variants: LookupSelectItem[] = [];
+      try {
+        variants = await loadVariantOptions(
+          productId,
+          product?.thumbnailUrl ?? null,
+        );
+      } catch (err) {
+        logger.error('sales.document.items.autoSelectVariant', { err });
+      }
+      if (selectedProductIdRef.current !== productId) return;
+      if (variants.length === 1) {
+        commitVariantSelection({
+          variantId: variants[0].id,
+          productId,
+          product,
+          values,
+          setFormValue,
+        });
+        return;
+      }
+      void loadPrices(
+        productId,
+        null,
+        typeof values.quantity === "string" ? values.quantity : 1,
+        typeof values.quantityUnit === "string" ? values.quantityUnit : null,
+      );
+    },
+    [commitVariantSelection, loadPrices, loadVariantOptions],
+  );
+
   const loadLineStatuses = React.useCallback(async (): Promise<
     StatusOption[]
   > => {
@@ -1671,6 +1806,7 @@ export function LineItemDialog({
           const switchMode = (next: "catalog" | "custom") => {
             if (next === mode) return;
             setValue(next);
+            selectedProductIdRef.current = null;
             setLineMode(next);
             if (next === "custom") {
               setProductOption(null);
@@ -1795,18 +1931,17 @@ export function LineItemDialog({
                       selectedOption?.defaultUnit ??
                       null;
                     setFormValue?.("quantityUnit", defaultQuantityUnit);
-                    if (
+                    const defaultQuantity =
                       typeof selectedOption?.defaultSalesUnitQuantity ===
                         "number" &&
                       Number.isFinite(
                         selectedOption.defaultSalesUnitQuantity,
                       ) &&
                       selectedOption.defaultSalesUnitQuantity > 0
-                    ) {
-                      setFormValue?.(
-                        "quantity",
-                        String(selectedOption.defaultSalesUnitQuantity),
-                      );
+                        ? String(selectedOption.defaultSalesUnitQuantity)
+                        : null;
+                    if (defaultQuantity) {
+                      setFormValue?.("quantity", defaultQuantity);
                     }
                     const taxSelection = selectedOption
                       ? resolveTaxSelection(selectedOption)
@@ -1818,33 +1953,38 @@ export function LineItemDialog({
                     if (!existingName.trim() && selectedOption?.title) {
                       setFormValue?.("name", selectedOption.title);
                     }
-                    setFormValue?.(
-                      "catalogSnapshot",
-                      next
-                        ? {
-                            product: {
-                              id: next,
-                              title: selectedOption?.title ?? null,
-                              sku: selectedOption?.sku ?? null,
-                              thumbnailUrl:
-                                selectedOption?.thumbnailUrl ?? null,
-                              defaultUnit: selectedOption?.defaultUnit ?? null,
-                              defaultSalesUnit:
-                                selectedOption?.defaultSalesUnit ?? null,
-                            },
-                          }
-                        : null,
-                    );
+                    const productSnapshot = next
+                      ? {
+                          product: {
+                            id: next,
+                            title: selectedOption?.title ?? null,
+                            sku: selectedOption?.sku ?? null,
+                            thumbnailUrl:
+                              selectedOption?.thumbnailUrl ?? null,
+                            defaultUnit: selectedOption?.defaultUnit ?? null,
+                            defaultSalesUnit:
+                              selectedOption?.defaultSalesUnit ?? null,
+                          },
+                        }
+                      : null;
+                    setFormValue?.("catalogSnapshot", productSnapshot);
+                    selectedProductIdRef.current = next ?? null;
                     if (next) {
                       void loadProductUnits(next, selectedOption);
-                      void loadPrices(
-                        next,
-                        null,
-                        typeof values?.quantity === "string"
-                          ? values.quantity
-                          : 1,
-                        defaultQuantityUnit,
-                      );
+                      const valuesAfterProductChange = {
+                        ...values,
+                        name:
+                          existingName.trim() || selectedOption?.title || "",
+                        catalogSnapshot: productSnapshot,
+                        quantity: defaultQuantity ?? values?.quantity,
+                        quantityUnit: defaultQuantityUnit,
+                      };
+                      void autoSelectSoleVariant({
+                        productId: next,
+                        product: selectedOption,
+                        values: valuesAfterProductChange,
+                        setFormValue,
+                      });
                     }
                   }}
                   fetchItems={loadProductOptions}
@@ -1921,76 +2061,14 @@ export function LineItemDialog({
                     key={productId ?? "no-product"}
                     value={typeof value === "string" ? value : null}
                     onChange={(next) => {
-                      const selectedOption = next
-                        ? (variantOptionsRef.current.get(next) ?? null)
-                        : null;
-                      setVariantOption(selectedOption);
                       setValue(next ?? null);
-                      const existingName =
-                        typeof values?.name === "string" ? values.name : "";
-                      if (!existingName.trim()) {
-                        setFormValue?.(
-                          "name",
-                          selectedOption?.title ??
-                            productOption?.title ??
-                            existingName,
-                        );
-                      }
-                      const taxSource = hasTaxMetadata(selectedOption)
-                        ? selectedOption
-                        : hasTaxMetadata(productOption)
-                          ? productOption
-                          : null;
-                      if (taxSource) {
-                        const taxSelection = resolveTaxSelection(taxSource);
-                        setFormValue?.("taxRate", taxSelection.taxRate ?? null);
-                        setFormValue?.(
-                          "taxRateId",
-                          taxSelection.taxRateId ?? null,
-                        );
-                      }
-                      const prevSnapshot =
-                        typeof values?.catalogSnapshot === "object" &&
-                        values.catalogSnapshot
-                          ? (values.catalogSnapshot as Record<string, unknown>)
-                          : null;
-                      if (next) {
-                        setFormValue?.("catalogSnapshot", {
-                          ...(prevSnapshot ?? {}),
-                          variant: {
-                            id: next,
-                            title: selectedOption?.title ?? null,
-                            sku: selectedOption?.sku ?? null,
-                            thumbnailUrl: selectedOption?.thumbnailUrl ?? null,
-                          },
-                        });
-                      } else if (prevSnapshot) {
-                        const snapshot = { ...prevSnapshot };
-                        if ("variant" in snapshot)
-                          delete (snapshot as CatalogSnapshotRecord).variant;
-                        setFormValue?.(
-                          "catalogSnapshot",
-                          Object.keys(snapshot).length ? snapshot : null,
-                        );
-                      } else {
-                        setFormValue?.("catalogSnapshot", null);
-                      }
-                      if (productId) {
-                        const currentQuantity =
-                          typeof values?.quantity === "string"
-                            ? values.quantity
-                            : 1;
-                        const currentQuantityUnit =
-                          typeof values?.quantityUnit === "string"
-                            ? values.quantityUnit
-                            : null;
-                        void loadPrices(
-                          productId,
-                          next,
-                          currentQuantity,
-                          currentQuantityUnit,
-                        );
-                      }
+                      commitVariantSelection({
+                        variantId: next ?? null,
+                        productId,
+                        product: productOption,
+                        values,
+                        setFormValue,
+                      });
                     }}
                     fetchItems={async (query) => {
                       if (!productId) return [];
@@ -2355,9 +2433,10 @@ export function LineItemDialog({
             event: React.ChangeEvent<HTMLSelectElement>,
           ) => {
             const nextId = event.target.value || null;
-            const option = nextId ? (taxRateMap.get(nextId) ?? null) : null;
+            if (!nextId) return;
+            const option = taxRateMap.get(nextId) ?? null;
             setValue(nextId);
-            const rate = normalizeNumber(option?.rate);
+            const rate = normalizeNumber(option?.rate, Number.NaN);
             setFormValue?.("taxRate", Number.isFinite(rate) ? rate : null);
           };
           return (
@@ -2672,6 +2751,8 @@ export function LineItemDialog({
     ];
   }, [
     applyPriceSelection,
+    autoSelectSoleVariant,
+    commitVariantSelection,
     convertUnitPriceForUnitChange,
     currencyCode,
     findTaxRateIdByValue,
@@ -2716,6 +2797,7 @@ export function LineItemDialog({
       return;
     }
     let cancelled = false;
+    selectedProductIdRef.current = null;
     setDeletedCatalogReference(false);
     setEditingId(initialLine.id);
     const nextForm = defaultForm(initialLine.currencyCode ?? currencyCode);
@@ -2778,10 +2860,11 @@ export function LineItemDialog({
         ? metaRec.taxRateId
         : null;
     const fallbackTaxRateId = findTaxRateIdByValue(nextForm.taxRate);
-    nextForm.taxRateId =
-      metaTaxRateId ??
-      fallbackTaxRateId ??
-      (defaultTaxRateRef.current ? defaultTaxRateRef.current.id : null);
+    const defaultTaxRateId =
+      !Number.isFinite(nextForm.taxRate) && defaultTaxRateRef.current
+        ? defaultTaxRateRef.current.id
+        : null;
+    nextForm.taxRateId = metaTaxRateId ?? fallbackTaxRateId ?? defaultTaxRateId;
     if (!Number.isFinite(nextForm.taxRate) && nextForm.taxRateId) {
       const matched = taxRatesRef.current.find(
         (rate) => rate.id === nextForm.taxRateId,