@shopify/hydrogen 2026.4.5 → 2026.10.0-preview.2

package/dist/development/core/product/options.d.mts

@@ -0,0 +1,43 @@
+import { SelectedOption } from "./state.mjs";
+
+//#region src/core/product/options.d.ts
+/**
+ * Extracts selected product options from search params.
+ *
+ * Each query parameter is treated as an option name/value pair
+ * (e.g. `?Color=Red&Size=M` → `[{name:"Color",value:"Red"},{name:"Size",value:"M"}]`).
+ *
+ * The `variant` param is reserved for numeric variant ids (Liquid parity) and is
+ * never treated as an option name, even when listed in `allowedOptionNames`.
+ *
+ * When `allowedOptionNames` is provided, the search params are filtered to only
+ * entries whose decoded param name exactly matches a product option name.
+ * Passing an empty array filters out every option.
+ *
+ * Pass the result to `createProductFormStore` or `useProductForm` to pre-select
+ * the variant that matches the current URL.
+ *
+ * @example
+ * ```ts
+ * // Loader (React Router / Remix)
+ * const selectedOptions = getSelectedProductOptions({
+ *   searchParams: new URL(request.url).searchParams,
+ * });
+ *
+ * // Filter to known product option names when product data is available
+ * const selectedOptions = getSelectedProductOptions({
+ *   searchParams,
+ *   allowedOptionNames: product.options.map((option) => option.name),
+ * });
+ * ```
+ */
+declare function getSelectedProductOptions({
+  searchParams,
+  allowedOptionNames
+}: {
+  searchParams: URLSearchParams;
+  allowedOptionNames?: readonly string[];
+}): SelectedOption[];
+//#endregion
+export { getSelectedProductOptions };
+//# sourceMappingURL=options.d.mts.map

package/dist/development/core/product/options.mjs

@@ -0,0 +1,296 @@
+import { getLogger } from "../logging/logging.mjs";
+import { VARIANT_SEARCH_PARAM } from "./url.mjs";
+
+//#region src/core/product/options.ts
+const log = getLogger("product");
+const INCLUSIVE_RANGE_END_OFFSET = 1;
+/**
+* Extracts selected product options from search params.
+*
+* Each query parameter is treated as an option name/value pair
+* (e.g. `?Color=Red&Size=M` → `[{name:"Color",value:"Red"},{name:"Size",value:"M"}]`).
+*
+* The `variant` param is reserved for numeric variant ids (Liquid parity) and is
+* never treated as an option name, even when listed in `allowedOptionNames`.
+*
+* When `allowedOptionNames` is provided, the search params are filtered to only
+* entries whose decoded param name exactly matches a product option name.
+* Passing an empty array filters out every option.
+*
+* Pass the result to `createProductFormStore` or `useProductForm` to pre-select
+* the variant that matches the current URL.
+*
+* @example
+* ```ts
+* // Loader (React Router / Remix)
+* const selectedOptions = getSelectedProductOptions({
+*   searchParams: new URL(request.url).searchParams,
+* });
+*
+* // Filter to known product option names when product data is available
+* const selectedOptions = getSelectedProductOptions({
+*   searchParams,
+*   allowedOptionNames: product.options.map((option) => option.name),
+* });
+* ```
+*/
+function getSelectedProductOptions({ searchParams, allowedOptionNames }) {
+	const allowedOptionNameSet = allowedOptionNames ? new Set(allowedOptionNames) : null;
+	const selectedOptions = [];
+	for (const [name, value] of searchParams.entries()) {
+		if (name === "variant") continue;
+		if (allowedOptionNameSet && !allowedOptionNameSet.has(name)) continue;
+		selectedOptions.push({
+			name,
+			value
+		});
+	}
+	return selectedOptions;
+}
+function getAdjacentAndFirstSelectableVariants(product) {
+	const variants = /* @__PURE__ */ new Map();
+	for (const option of product.options) for (const value of option.optionValues) if (isConcreteProductVariant(value.firstSelectableVariant)) addVariant(variants, value.firstSelectableVariant, product.options);
+	for (const variant of product.adjacentVariants) if (isConcreteProductVariant(variant)) addVariant(variants, variant, product.options);
+	if (isConcreteProductVariant(product.selectedOrFirstAvailableVariant)) addVariant(variants, product.selectedOrFirstAvailableVariant, product.options);
+	return [...variants.values()];
+}
+function buildProductOptions(product, selectedOptions, cache) {
+	const selectedOptionMap = selectedOptionsToMap(selectedOptions);
+	const optionValueIndex = buildOptionValueIndex(product);
+	const selectableVariants = getAdjacentAndFirstSelectableVariants(product);
+	const encodedOptionIndexes = buildEncodedOptionIndexes(product, selectableVariants);
+	const variants = mapVariants(product, selectableVariants);
+	const currentProductOptionValues = buildCurrentProductOptionValues(product, selectableVariants);
+	return product.options.map((option) => ({
+		name: option.name,
+		values: option.optionValues.map((value) => buildProductOptionValue({
+			cache,
+			currentProductOptionValues,
+			encodedOptionIndexes,
+			option,
+			optionValueIndex,
+			product,
+			selectedOptionMap,
+			value,
+			variants
+		}))
+	}));
+}
+function selectedOptionsToMap(selectedOptions) {
+	const map = Object.create(null);
+	for (const option of selectedOptions) map[option.name] = option.value;
+	return map;
+}
+function selectedOptionsKey(selectedOptions, productOptions) {
+	return JSON.stringify(selectedOptionsFromMap({ options: productOptions }, selectedOptionsToMap(selectedOptions)));
+}
+function selectedOptionsFromMap(product, selectedOptionMap) {
+	const selectedOptions = [];
+	for (const option of product.options) {
+		const value = selectedOptionMap[option.name];
+		if (value !== void 0) selectedOptions.push({
+			name: option.name,
+			value
+		});
+	}
+	return selectedOptions;
+}
+function mapVariants(product, selectableVariants) {
+	const variants = /* @__PURE__ */ new Map();
+	for (const variant of selectableVariants) variants.set(selectedOptionsKey(variant.selectedOptions, product.options), variant);
+	return variants;
+}
+function addVariant(variants, variant, productOptions) {
+	variants.set(selectedOptionsKey(variant.selectedOptions, productOptions), variant);
+}
+function buildProductOptionValue({ cache, currentProductOptionValues, encodedOptionIndexes, option, optionValueIndex, product, selectedOptionMap, value, variants }) {
+	const firstSelectableVariant = isConcreteProductVariant(value.firstSelectableVariant) ? value.firstSelectableVariant : null;
+	const selected = selectedOptionMap[option.name] === value.name;
+	const crossProduct = isCrossProductOptionValue(product, option.name, value.name, firstSelectableVariant, currentProductOptionValues);
+	const targetOptionMap = buildTargetOptionMap({
+		currentProductOptionValues,
+		crossProduct,
+		firstSelectableVariant,
+		optionName: option.name,
+		selectedOptionMap,
+		valueName: value.name
+	});
+	const targetSelectedOptions = selectedOptionsFromMap(product, targetOptionMap);
+	const key = selectedOptionsKey(targetSelectedOptions, product.options);
+	const variant = variants.get(key) ?? null;
+	const targetProductHandle = getTargetProductHandle(product, crossProduct, firstSelectableVariant);
+	const encodingConstraints = buildEncodingConstraints(targetOptionMap, product, optionValueIndex, encodedOptionIndexes.get(targetProductHandle));
+	return {
+		name: value.name,
+		swatch: value.swatch,
+		selected,
+		exists: resolveEncodedStatus(product.encodedVariantExistence, encodingConstraints, true, cache),
+		available: resolveEncodedStatus(product.encodedVariantAvailability, encodingConstraints, variant?.availableForSale ?? false, cache),
+		variant,
+		selectedOptions: variant?.selectedOptions ?? targetSelectedOptions,
+		handle: getOptionValueHandle(selected, product.handle, variant, firstSelectableVariant)
+	};
+}
+function getOptionValueHandle(selected, productHandle, variant, firstSelectableVariant) {
+	if (selected) return productHandle;
+	return variant?.product?.handle ?? firstSelectableVariant?.product?.handle ?? productHandle;
+}
+function buildOptionValueIndex(product) {
+	return new Map(product.options.map((option) => [option.name, new Map(option.optionValues.map((value, index) => [value.name, index]))]));
+}
+function getTargetProductHandle(product, crossProduct, firstSelectableVariant) {
+	if (crossProduct && firstSelectableVariant?.product?.handle) return firstSelectableVariant.product.handle;
+	return product.handle;
+}
+function buildEncodedOptionIndexes(product, selectableVariants) {
+	const indexes = /* @__PURE__ */ new Map();
+	for (const variant of selectableVariants) addEncodedOptionIndex(indexes, variant.product?.handle ?? product.handle, product.options, variant.selectedOptions);
+	return indexes;
+}
+function addEncodedOptionIndex(indexes, productHandle, productOptions, selectedOptions) {
+	const index = indexes.get(productHandle) ?? /* @__PURE__ */ new Map();
+	const selectedOptionNames = new Set(selectedOptions.map((option) => option.name));
+	for (const option of productOptions) {
+		if (!selectedOptionNames.has(option.name) || index.has(option.name)) continue;
+		index.set(option.name, index.size);
+	}
+	indexes.set(productHandle, index);
+}
+function buildCurrentProductOptionValues(product, selectableVariants) {
+	const optionValues = /* @__PURE__ */ new Map();
+	for (const variant of selectableVariants) {
+		if (!variantBelongsToProduct(product, variant)) continue;
+		for (const option of variant.selectedOptions) addCurrentProductOptionValue(optionValues, option.name, option.value);
+	}
+	return optionValues;
+}
+function addCurrentProductOptionValue(optionValues, optionName, valueName) {
+	const values = optionValues.get(optionName) ?? /* @__PURE__ */ new Set();
+	values.add(valueName);
+	optionValues.set(optionName, values);
+}
+function isCrossProductOptionValue(product, optionName, valueName, firstSelectableVariant, currentProductOptionValues) {
+	if (!firstSelectableVariant || variantBelongsToProduct(product, firstSelectableVariant)) return false;
+	return !currentProductOptionValues.get(optionName)?.has(valueName);
+}
+function variantBelongsToProduct(product, variant) {
+	return variant.product?.handle === void 0 || variant.product.handle === product.handle;
+}
+function buildTargetOptionMap({ currentProductOptionValues, crossProduct, firstSelectableVariant, optionName, selectedOptionMap, valueName }) {
+	if (crossProduct && firstSelectableVariant) return selectedOptionsToMap(firstSelectableVariant.selectedOptions);
+	const nextOptionMap = {
+		...selectedOptionMap,
+		[optionName]: valueName
+	};
+	if (currentProductOptionValues.size === 0) return nextOptionMap;
+	return filterOptionMap(nextOptionMap, currentProductOptionValues);
+}
+function filterOptionMap(selectedOptionMap, currentProductOptionValues) {
+	const filtered = Object.create(null);
+	for (const [optionName, values] of currentProductOptionValues) {
+		const value = selectedOptionMap[optionName];
+		if (value !== void 0 && values.has(value)) filtered[optionName] = value;
+	}
+	return filtered;
+}
+function buildEncodingConstraints(selectedOptionMap, product, optionValueIndex = buildOptionValueIndex(product), encodedOptionIndex) {
+	const constraints = [];
+	for (const [productOptionIndex, option] of product.options.entries()) {
+		const selectedValue = selectedOptionMap[option.name];
+		if (selectedValue === void 0) continue;
+		const optionIndex = encodedOptionIndex?.get(option.name) ?? productOptionIndex;
+		const valueIndex = optionValueIndex.get(option.name)?.get(selectedValue);
+		if (valueIndex === void 0) continue;
+		constraints.push({
+			optionIndex,
+			valueIndex
+		});
+	}
+	return constraints;
+}
+function resolveEncodedStatus(encodedField, constraints, fallback, cache) {
+	if (!encodedField) return fallback;
+	return isAnyEncodedVariantMatchingConstraints(constraints, encodedField, cache);
+}
+function isAnyEncodedVariantMatchingConstraints(constraints, encodedVariantField, cache) {
+	if (constraints.length === 0) return false;
+	return getDecodedVariantCombinations(encodedVariantField, cache).some((combination) => combinationMatchesConstraints(combination, constraints));
+}
+function getDecodedVariantCombinations(encodedVariantField, cache) {
+	const cached = cache?.get(encodedVariantField);
+	if (cached) return cached;
+	const decoded = decodeEncodedVariant(encodedVariantField);
+	cache?.set(encodedVariantField, decoded);
+	return decoded;
+}
+function combinationMatchesConstraints(combination, constraints) {
+	return constraints.every(({ optionIndex, valueIndex }) => combination[optionIndex] === valueIndex);
+}
+function decodeEncodedVariant(encodedVariantField) {
+	if (!encodedVariantField) return [];
+	if (!encodedVariantField.startsWith("v1_")) {
+		log.warn(`unsupported variant encoding: "${encodedVariantField}"`);
+		return [];
+	}
+	return decodeV1EncodedVariant(encodedVariantField.replace(/^v1_/, ""));
+}
+function decodeV1EncodedVariant(encodedVariantField) {
+	const tokenizer = /[ :,-]/g;
+	const state = {
+		currentOptionValue: [],
+		decodedOptions: [],
+		depth: 0,
+		index: 0,
+		rangeStart: null
+	};
+	let token;
+	while (token = tokenizer.exec(encodedVariantField)) processDecodeV1Token(encodedVariantField, state, token, tokenizer);
+	pushFinalDecodeV1Value(encodedVariantField, state);
+	return state.decodedOptions;
+}
+function isConcreteProductVariant(variant) {
+	return variant !== null && variant !== void 0;
+}
+function processDecodeV1Token(encodedVariantField, state, token, tokenizer) {
+	const operation = token[0];
+	const optionValueIndex = Number.parseInt(encodedVariantField.slice(state.index, token.index), 10) || 0;
+	pushDecodeV1Range(state, optionValueIndex);
+	state.currentOptionValue[state.depth] = optionValueIndex;
+	if (operation === "-") state.rangeStart = optionValueIndex;
+	else if (operation === ":") state.depth++;
+	else processDecodeV1Separator(encodedVariantField, state, token, operation);
+	state.index = tokenizer.lastIndex;
+}
+function processDecodeV1Separator(encodedVariantField, state, token, operation) {
+	if (shouldPushDecodeV1Option(encodedVariantField, token, operation)) state.decodedOptions.push([...state.currentOptionValue]);
+	if (operation !== ",") return;
+	state.currentOptionValue.pop();
+	state.depth--;
+}
+function shouldPushDecodeV1Option(encodedVariantField, token, operation) {
+	return operation === " " || operation === "," && encodedVariantField[token.index - 1] !== ",";
+}
+function pushFinalDecodeV1Value(encodedVariantField, state) {
+	const finalIndex = encodedVariantField.match(/\d+$/g)?.[0];
+	if (finalIndex === void 0) return;
+	const finalValueIndex = Number.parseInt(finalIndex, 10);
+	if (state.rangeStart !== null) {
+		pushDecodeV1Range(state, finalValueIndex + INCLUSIVE_RANGE_END_OFFSET);
+		return;
+	}
+	state.currentOptionValue[state.depth] = finalValueIndex;
+	state.decodedOptions.push([...state.currentOptionValue]);
+}
+function pushDecodeV1Range(state, rangeEndExclusive) {
+	const rangeStart = state.rangeStart;
+	if (rangeStart === null) return;
+	for (let value = rangeStart; value < rangeEndExclusive; value++) {
+		state.currentOptionValue[state.depth] = value;
+		state.decodedOptions.push([...state.currentOptionValue]);
+	}
+	state.rangeStart = null;
+}
+
+//#endregion
+export { buildProductOptions, getSelectedProductOptions, selectedOptionsFromMap, selectedOptionsToMap };
+//# sourceMappingURL=options.mjs.map

package/dist/development/core/product/options.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.mjs","names":[],"sources":["../../../../src/core/product/options.ts"],"sourcesContent":["import { getLogger } from \"../logging\";\nimport type {\n  ProductInput,\n  ProductOptionValueFrom,\n  ProductVariantFrom,\n  ProductVariantInput,\n  SelectedOption,\n  VariantOptionState,\n  VariantOptionValueState,\n} from \"./state\";\nimport { VARIANT_SEARCH_PARAM } from \"./url\";\n\nconst log = getLogger(\"product\");\n\nconst INCLUSIVE_RANGE_END_OFFSET = 1;\n\nexport type DecodedVariantCache = Map<string, number[][]>;\n\ntype EncodedVariantConstraint = {\n  optionIndex: number;\n  valueIndex: number;\n};\n\n/**\n * Extracts selected product options from search params.\n *\n * Each query parameter is treated as an option name/value pair\n * (e.g. `?Color=Red&Size=M` → `[{name:\"Color\",value:\"Red\"},{name:\"Size\",value:\"M\"}]`).\n *\n * The `variant` param is reserved for numeric variant ids (Liquid parity) and is\n * never treated as an option name, even when listed in `allowedOptionNames`.\n *\n * When `allowedOptionNames` is provided, the search params are filtered to only\n * entries whose decoded param name exactly matches a product option name.\n * Passing an empty array filters out every option.\n *\n * Pass the result to `createProductFormStore` or `useProductForm` to pre-select\n * the variant that matches the current URL.\n *\n * @example\n * ```ts\n * // Loader (React Router / Remix)\n * const selectedOptions = getSelectedProductOptions({\n *   searchParams: new URL(request.url).searchParams,\n * });\n *\n * // Filter to known product option names when product data is available\n * const selectedOptions = getSelectedProductOptions({\n *   searchParams,\n *   allowedOptionNames: product.options.map((option) => option.name),\n * });\n * ```\n */\nexport function getSelectedProductOptions({\n  searchParams,\n  allowedOptionNames,\n}: {\n  searchParams: URLSearchParams;\n  allowedOptionNames?: readonly string[];\n}): SelectedOption[] {\n  const allowedOptionNameSet = allowedOptionNames ? new Set(allowedOptionNames) : null;\n  const selectedOptions: SelectedOption[] = [];\n\n  for (const [name, value] of searchParams.entries()) {\n    if (name === VARIANT_SEARCH_PARAM) continue;\n    if (allowedOptionNameSet && !allowedOptionNameSet.has(name)) continue;\n    selectedOptions.push({ name, value });\n  }\n\n  return selectedOptions;\n}\n\nfunction getAdjacentAndFirstSelectableVariants<TProduct extends ProductInput>(\n  product: TProduct,\n): ProductVariantFrom<TProduct>[] {\n  // Shopify returns a bounded set, not the whole matrix. Treat it as a concrete-variant cache.\n  const variants = new Map<string, ProductVariantFrom<TProduct>>();\n\n  for (const option of product.options) {\n    for (const value of option.optionValues) {\n      if (isConcreteProductVariant<TProduct>(value.firstSelectableVariant)) {\n        addVariant(variants, value.firstSelectableVariant, product.options);\n      }\n    }\n  }\n\n  for (const variant of product.adjacentVariants) {\n    if (isConcreteProductVariant<TProduct>(variant)) addVariant(variants, variant, product.options);\n  }\n\n  if (isConcreteProductVariant<TProduct>(product.selectedOrFirstAvailableVariant)) {\n    addVariant(variants, product.selectedOrFirstAvailableVariant, product.options);\n  }\n\n  return [...variants.values()];\n}\n\nexport function buildProductOptions<TProduct extends ProductInput>(\n  product: TProduct,\n  selectedOptions: SelectedOption[],\n  cache?: DecodedVariantCache,\n): VariantOptionState<ProductVariantFrom<TProduct>, ProductOptionValueFrom<TProduct>>[] {\n  const selectedOptionMap = selectedOptionsToMap(selectedOptions);\n  const optionValueIndex = buildOptionValueIndex(product);\n  const selectableVariants = getAdjacentAndFirstSelectableVariants(product);\n  const encodedOptionIndexes = buildEncodedOptionIndexes(product, selectableVariants);\n  const variants = mapVariants(product, selectableVariants);\n  const currentProductOptionValues = buildCurrentProductOptionValues(product, selectableVariants);\n\n  return product.options.map((option) => ({\n    name: option.name,\n    values: option.optionValues.map((value) =>\n      buildProductOptionValue({\n        cache,\n        currentProductOptionValues,\n        encodedOptionIndexes,\n        option,\n        optionValueIndex,\n        product,\n        selectedOptionMap,\n        value,\n        variants,\n      }),\n    ),\n  }));\n}\n\nexport function selectedOptionsToMap(selectedOptions: SelectedOption[]): Record<string, string> {\n  const map: Record<string, string> = Object.create(null);\n  for (const option of selectedOptions) {\n    map[option.name] = option.value;\n  }\n  return map;\n}\n\nfunction selectedOptionsKey(\n  selectedOptions: SelectedOption[],\n  productOptions: Array<{ name: string }>,\n): string {\n  return JSON.stringify(\n    selectedOptionsFromMap({ options: productOptions }, selectedOptionsToMap(selectedOptions)),\n  );\n}\n\nexport function selectedOptionsFromMap(\n  product: { options: Array<{ name: string }> },\n  selectedOptionMap: Record<string, string>,\n): SelectedOption[] {\n  const selectedOptions: SelectedOption[] = [];\n  for (const option of product.options) {\n    const value = selectedOptionMap[option.name];\n    if (value !== undefined) selectedOptions.push({ name: option.name, value });\n  }\n  return selectedOptions;\n}\n\nfunction mapVariants<TProduct extends ProductInput>(\n  product: TProduct,\n  selectableVariants: ProductVariantFrom<TProduct>[],\n): Map<string, ProductVariantFrom<TProduct>> {\n  const variants = new Map<string, ProductVariantFrom<TProduct>>();\n  for (const variant of selectableVariants) {\n    variants.set(selectedOptionsKey(variant.selectedOptions, product.options), variant);\n  }\n  return variants;\n}\n\nfunction addVariant<TVariant extends ProductVariantInput>(\n  variants: Map<string, TVariant>,\n  variant: TVariant,\n  productOptions: Array<{ name: string }>,\n): void {\n  variants.set(selectedOptionsKey(variant.selectedOptions, productOptions), variant);\n}\n\nfunction buildProductOptionValue<TProduct extends ProductInput>({\n  cache,\n  currentProductOptionValues,\n  encodedOptionIndexes,\n  option,\n  optionValueIndex,\n  product,\n  selectedOptionMap,\n  value,\n  variants,\n}: {\n  cache?: DecodedVariantCache;\n  currentProductOptionValues: Map<string, Set<string>>;\n  encodedOptionIndexes: Map<string, Map<string, number>>;\n  option: TProduct[\"options\"][number];\n  optionValueIndex: Map<string, Map<string, number>>;\n  product: TProduct;\n  selectedOptionMap: Record<string, string>;\n  value: ProductOptionValueFrom<TProduct>;\n  variants: Map<string, ProductVariantFrom<TProduct>>;\n}): VariantOptionValueState<ProductVariantFrom<TProduct>, ProductOptionValueFrom<TProduct>> {\n  const firstSelectableVariant = isConcreteProductVariant<TProduct>(value.firstSelectableVariant)\n    ? value.firstSelectableVariant\n    : null;\n  const selected = selectedOptionMap[option.name] === value.name;\n  const crossProduct = isCrossProductOptionValue(\n    product,\n    option.name,\n    value.name,\n    firstSelectableVariant,\n    currentProductOptionValues,\n  );\n  const targetOptionMap = buildTargetOptionMap({\n    currentProductOptionValues,\n    crossProduct,\n    firstSelectableVariant,\n    optionName: option.name,\n    selectedOptionMap,\n    valueName: value.name,\n  });\n  const targetSelectedOptions = selectedOptionsFromMap(product, targetOptionMap);\n  const key = selectedOptionsKey(targetSelectedOptions, product.options);\n  const variant = variants.get(key) ?? null;\n  const targetProductHandle = getTargetProductHandle(product, crossProduct, firstSelectableVariant);\n  const encodingConstraints = buildEncodingConstraints(\n    targetOptionMap,\n    product,\n    optionValueIndex,\n    encodedOptionIndexes.get(targetProductHandle),\n  );\n\n  return {\n    name: value.name,\n    swatch: value.swatch,\n    selected,\n    exists: resolveEncodedStatus(product.encodedVariantExistence, encodingConstraints, true, cache),\n    available: resolveEncodedStatus(\n      product.encodedVariantAvailability,\n      encodingConstraints,\n      variant?.availableForSale ?? false,\n      cache,\n    ),\n    variant,\n    selectedOptions: variant?.selectedOptions ?? targetSelectedOptions,\n    handle: getOptionValueHandle(selected, product.handle, variant, firstSelectableVariant),\n  };\n}\n\nfunction getOptionValueHandle<TVariant extends ProductVariantInput>(\n  selected: boolean,\n  productHandle: string,\n  variant: TVariant | null,\n  firstSelectableVariant: TVariant | null,\n): string {\n  if (selected) return productHandle;\n  return variant?.product?.handle ?? firstSelectableVariant?.product?.handle ?? productHandle;\n}\n\nfunction buildOptionValueIndex<TProduct extends ProductInput>(\n  product: TProduct,\n): Map<string, Map<string, number>> {\n  return new Map(\n    product.options.map((option) => [\n      option.name,\n      new Map(option.optionValues.map((value, index) => [value.name, index])),\n    ]),\n  );\n}\n\nfunction getTargetProductHandle<TVariant extends ProductVariantInput>(\n  product: ProductInput,\n  crossProduct: boolean,\n  firstSelectableVariant: TVariant | null,\n): string {\n  if (crossProduct && firstSelectableVariant?.product?.handle) {\n    return firstSelectableVariant.product.handle;\n  }\n  return product.handle;\n}\n\nfunction buildEncodedOptionIndexes<TProduct extends ProductInput>(\n  product: TProduct,\n  selectableVariants: ProductVariantFrom<TProduct>[],\n): Map<string, Map<string, number>> {\n  const indexes = new Map<string, Map<string, number>>();\n  for (const variant of selectableVariants) {\n    const productHandle = variant.product?.handle ?? product.handle;\n    addEncodedOptionIndex(indexes, productHandle, product.options, variant.selectedOptions);\n  }\n  return indexes;\n}\n\nfunction addEncodedOptionIndex(\n  indexes: Map<string, Map<string, number>>,\n  productHandle: string,\n  productOptions: Array<{ name: string }>,\n  selectedOptions: SelectedOption[],\n): void {\n  const index = indexes.get(productHandle) ?? new Map<string, number>();\n  const selectedOptionNames = new Set(selectedOptions.map((option) => option.name));\n\n  for (const option of productOptions) {\n    if (!selectedOptionNames.has(option.name) || index.has(option.name)) continue;\n    index.set(option.name, index.size);\n  }\n\n  indexes.set(productHandle, index);\n}\n\nfunction buildCurrentProductOptionValues<TProduct extends ProductInput>(\n  product: TProduct,\n  selectableVariants: ProductVariantFrom<TProduct>[],\n): Map<string, Set<string>> {\n  const optionValues = new Map<string, Set<string>>();\n  for (const variant of selectableVariants) {\n    if (!variantBelongsToProduct(product, variant)) continue;\n    for (const option of variant.selectedOptions) {\n      addCurrentProductOptionValue(optionValues, option.name, option.value);\n    }\n  }\n  return optionValues;\n}\n\nfunction addCurrentProductOptionValue(\n  optionValues: Map<string, Set<string>>,\n  optionName: string,\n  valueName: string,\n): void {\n  const values = optionValues.get(optionName) ?? new Set<string>();\n  values.add(valueName);\n  optionValues.set(optionName, values);\n}\n\nfunction isCrossProductOptionValue<TVariant extends ProductVariantInput>(\n  product: ProductInput,\n  optionName: string,\n  valueName: string,\n  firstSelectableVariant: TVariant | null,\n  currentProductOptionValues: Map<string, Set<string>>,\n): boolean {\n  if (!firstSelectableVariant || variantBelongsToProduct(product, firstSelectableVariant)) {\n    return false;\n  }\n  return !currentProductOptionValues.get(optionName)?.has(valueName);\n}\n\nfunction variantBelongsToProduct<TVariant extends ProductVariantInput>(\n  product: ProductInput,\n  variant: TVariant,\n): boolean {\n  return variant.product?.handle === undefined || variant.product.handle === product.handle;\n}\n\ntype TargetOptionMapInput<TVariant extends ProductVariantInput> = {\n  currentProductOptionValues: Map<string, Set<string>>;\n  crossProduct: boolean;\n  firstSelectableVariant: TVariant | null;\n  optionName: string;\n  selectedOptionMap: Record<string, string>;\n  valueName: string;\n};\n\nfunction buildTargetOptionMap<TVariant extends ProductVariantInput>({\n  currentProductOptionValues,\n  crossProduct,\n  firstSelectableVariant,\n  optionName,\n  selectedOptionMap,\n  valueName,\n}: TargetOptionMapInput<TVariant>): Record<string, string> {\n  if (crossProduct && firstSelectableVariant) {\n    return selectedOptionsToMap(firstSelectableVariant.selectedOptions);\n  }\n\n  const nextOptionMap = { ...selectedOptionMap, [optionName]: valueName };\n  if (currentProductOptionValues.size === 0) return nextOptionMap;\n  return filterOptionMap(nextOptionMap, currentProductOptionValues);\n}\n\nfunction filterOptionMap(\n  selectedOptionMap: Record<string, string>,\n  currentProductOptionValues: Map<string, Set<string>>,\n): Record<string, string> {\n  const filtered: Record<string, string> = Object.create(null);\n  for (const [optionName, values] of currentProductOptionValues) {\n    const value = selectedOptionMap[optionName];\n    if (value !== undefined && values.has(value)) filtered[optionName] = value;\n  }\n  return filtered;\n}\n\nfunction buildEncodingConstraints<TProduct extends ProductInput>(\n  selectedOptionMap: Record<string, string>,\n  product: TProduct,\n  optionValueIndex = buildOptionValueIndex(product),\n  encodedOptionIndex?: Map<string, number>,\n): EncodedVariantConstraint[] {\n  const constraints: EncodedVariantConstraint[] = [];\n\n  for (const [productOptionIndex, option] of product.options.entries()) {\n    const selectedValue = selectedOptionMap[option.name];\n    if (selectedValue === undefined) continue;\n    const optionIndex = encodedOptionIndex?.get(option.name) ?? productOptionIndex;\n    const valueIndex = optionValueIndex.get(option.name)?.get(selectedValue);\n    if (valueIndex === undefined) continue;\n    constraints.push({ optionIndex, valueIndex });\n  }\n\n  return constraints;\n}\n\nfunction resolveEncodedStatus(\n  encodedField: string | null | undefined,\n  constraints: EncodedVariantConstraint[],\n  fallback: boolean,\n  cache?: DecodedVariantCache,\n): boolean {\n  if (!encodedField) return fallback;\n  return isAnyEncodedVariantMatchingConstraints(constraints, encodedField, cache);\n}\n\nfunction isAnyEncodedVariantMatchingConstraints(\n  constraints: EncodedVariantConstraint[],\n  encodedVariantField: string,\n  cache?: DecodedVariantCache,\n): boolean {\n  if (constraints.length === 0) return false;\n\n  return getDecodedVariantCombinations(encodedVariantField, cache).some((combination) =>\n    combinationMatchesConstraints(combination, constraints),\n  );\n}\n\nfunction getDecodedVariantCombinations(\n  encodedVariantField: string,\n  cache?: DecodedVariantCache,\n): number[][] {\n  const cached = cache?.get(encodedVariantField);\n  if (cached) return cached;\n\n  const decoded = decodeEncodedVariant(encodedVariantField);\n  cache?.set(encodedVariantField, decoded);\n  return decoded;\n}\n\nfunction combinationMatchesConstraints(\n  combination: number[],\n  constraints: EncodedVariantConstraint[],\n): boolean {\n  return constraints.every(\n    ({ optionIndex, valueIndex }) => combination[optionIndex] === valueIndex,\n  );\n}\n\nfunction decodeEncodedVariant(encodedVariantField: string | null | undefined): number[][] {\n  if (!encodedVariantField) return [];\n  if (!encodedVariantField.startsWith(\"v1_\")) {\n    log.warn(`unsupported variant encoding: \"${encodedVariantField}\"`);\n    return [];\n  }\n  return decodeV1EncodedVariant(encodedVariantField.replace(/^v1_/, \"\"));\n}\n\nfunction decodeV1EncodedVariant(encodedVariantField: string): number[][] {\n  const tokenizer = /[ :,-]/g;\n  const state: DecodeV1State = {\n    currentOptionValue: [],\n    decodedOptions: [],\n    depth: 0,\n    index: 0,\n    rangeStart: null,\n  };\n  let token: RegExpExecArray | null;\n\n  while ((token = tokenizer.exec(encodedVariantField))) {\n    processDecodeV1Token(encodedVariantField, state, token, tokenizer);\n  }\n\n  pushFinalDecodeV1Value(encodedVariantField, state);\n\n  return state.decodedOptions;\n}\n\ntype DecodeV1State = {\n  currentOptionValue: number[];\n  decodedOptions: number[][];\n  depth: number;\n  index: number;\n  rangeStart: number | null;\n};\n\nfunction isConcreteProductVariant<TProduct extends ProductInput>(\n  variant: ProductVariantInput | null | undefined,\n): variant is ProductVariantFrom<TProduct> {\n  return variant !== null && variant !== undefined;\n}\n\nfunction processDecodeV1Token(\n  encodedVariantField: string,\n  state: DecodeV1State,\n  token: RegExpExecArray,\n  tokenizer: RegExp,\n): void {\n  const operation = token[0];\n  const optionValueIndex =\n    Number.parseInt(encodedVariantField.slice(state.index, token.index), 10) || 0;\n\n  pushDecodeV1Range(state, optionValueIndex);\n  state.currentOptionValue[state.depth] = optionValueIndex;\n\n  if (operation === \"-\") {\n    state.rangeStart = optionValueIndex;\n  } else if (operation === \":\") {\n    state.depth++;\n  } else {\n    processDecodeV1Separator(encodedVariantField, state, token, operation);\n  }\n\n  state.index = tokenizer.lastIndex;\n}\n\nfunction processDecodeV1Separator(\n  encodedVariantField: string,\n  state: DecodeV1State,\n  token: RegExpExecArray,\n  operation: string,\n): void {\n  if (shouldPushDecodeV1Option(encodedVariantField, token, operation)) {\n    state.decodedOptions.push([...state.currentOptionValue]);\n  }\n\n  if (operation !== \",\") return;\n\n  state.currentOptionValue.pop();\n  state.depth--;\n}\n\nfunction shouldPushDecodeV1Option(\n  encodedVariantField: string,\n  token: RegExpExecArray,\n  operation: string,\n): boolean {\n  return operation === \" \" || (operation === \",\" && encodedVariantField[token.index - 1] !== \",\");\n}\n\nfunction pushFinalDecodeV1Value(encodedVariantField: string, state: DecodeV1State): void {\n  const finalIndex = encodedVariantField.match(/\\d+$/g)?.[0];\n  if (finalIndex === undefined) return;\n\n  const finalValueIndex = Number.parseInt(finalIndex, 10);\n  if (state.rangeStart !== null) {\n    pushDecodeV1Range(state, finalValueIndex + INCLUSIVE_RANGE_END_OFFSET);\n    return;\n  }\n\n  state.currentOptionValue[state.depth] = finalValueIndex;\n  state.decodedOptions.push([...state.currentOptionValue]);\n}\n\nfunction pushDecodeV1Range(state: DecodeV1State, rangeEndExclusive: number): void {\n  const rangeStart = state.rangeStart;\n  if (rangeStart === null) return;\n\n  for (let value = rangeStart; value < rangeEndExclusive; value++) {\n    state.currentOptionValue[state.depth] = value;\n    state.decodedOptions.push([...state.currentOptionValue]);\n  }\n\n  state.rangeStart = null;\n}\n"],"mappings":"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"}

package/dist/development/core/product/product-form.d.mts

@@ -0,0 +1,72 @@
+import { CartLine, CartNetworkEntry, CartUserError, CartWarning } from "../cart/state.mjs";
+import { CartStore } from "../cart/cart.mjs";
+import { ProductInput, ProductOptionValueFrom, ProductOptionValueInput, ProductVariantFrom, ProductVariantInput, SelectedOption, VariantOptionState } from "./state.mjs";
+
+//#region src/core/product/product-form.d.ts
+interface ProductFormErrors {
+  userErrors: CartUserError[];
+  warnings: CartWarning[];
+  networkErrors: CartNetworkEntry[];
+}
+/** Live state snapshot emitted by a {@link ProductFormStore}. */
+interface ProductFormStoreState<TVariant extends ProductVariantInput = ProductVariantInput, TOptionValue extends ProductOptionValueInput = ProductOptionValueInput> {
+  options: VariantOptionState<TVariant, TOptionValue>[];
+  selectedOptions: SelectedOption[];
+  selectedVariant: TVariant | null;
+  errors: ProductFormErrors;
+  matchedLineItem: CartLine | null;
+}
+type ProductFormOptions<TProduct extends ProductInput = ProductInput> = ProductFormStoreState<ProductVariantFrom<TProduct>, ProductOptionValueFrom<TProduct>>["options"];
+/**
+ * Result returned by {@link ProductFormStore.selectOption}.
+ *
+ * - `resolved` — a specific variant was matched for the full selection.
+ * - `unresolved` — the selection is valid but not yet complete.
+ * - `invalid` — the option name or value does not exist on the product.
+ */
+type VariantSelectionResult<TVariant extends ProductVariantInput = ProductVariantInput> = {
+  status: "resolved";
+  selectedOptions: SelectedOption[];
+  selectedVariant: TVariant;
+} | {
+  status: "unresolved";
+  selectedOptions: SelectedOption[];
+  selectedVariant: null;
+} | {
+  status: "invalid";
+  selectedOptions: SelectedOption[];
+  selectedVariant: null;
+  reason: string;
+};
+/** A selection result that is not invalid — either resolved or unresolved. */
+type ValidProductSelectionResult<TProduct extends ProductInput = ProductInput> = Exclude<VariantSelectionResult<ProductVariantFrom<TProduct>>, {
+  status: "invalid";
+}>;
+type CreateProductFormStoreOptions = {
+  selectedOptions?: SelectedOption[];
+};
+/** Manages variant selection + cart integration for a product form. */
+interface ProductFormStore<TProduct extends ProductInput = ProductInput, TVariant extends ProductVariantInput = ProductVariantFrom<TProduct>> {
+  getState(): ProductFormStoreState<TVariant, ProductOptionValueFrom<TProduct>>;
+  subscribe(listener: (state: ProductFormStoreState<TVariant, ProductOptionValueFrom<TProduct>>) => void): () => void;
+  selectOption(name: string, value: string): VariantSelectionResult<TVariant>;
+  hydrate(product: TProduct, opts?: {
+    selectedOptions?: SelectedOption[];
+  }): void;
+  reset(): void;
+  destroy(): void;
+  handleFormSubmit(event: SubmitEvent): Promise<void>;
+}
+declare function getSelectedVariant<TVariant extends ProductVariantInput>(options: VariantOptionState<TVariant, ProductOptionValueInput>[]): TVariant | null;
+declare function canAddToCart<TProduct extends ProductInput>(product: TProduct, options: VariantOptionState<ProductVariantFrom<TProduct>, ProductOptionValueFrom<TProduct>>[]): boolean;
+/**
+ * Finds the first cart line whose merchandise ID matches.
+ * When selling plans are used, the same merchandise ID can appear on multiple
+ * cart lines — this returns the first match. Future attribute-based matching
+ * will narrow to the exact line.
+ */
+declare function findCartLineByMerchandiseId(lines: CartLine[], merchandiseId: string): CartLine | null;
+declare function createProductFormStore<TProduct extends ProductInput>(product: TProduct, cartStore: CartStore, options?: CreateProductFormStoreOptions): ProductFormStore<TProduct, ProductVariantFrom<TProduct>>;
+//#endregion
+export { CreateProductFormStoreOptions, ProductFormErrors, ProductFormOptions, ProductFormStore, ProductFormStoreState, ValidProductSelectionResult, VariantSelectionResult, canAddToCart, createProductFormStore, findCartLineByMerchandiseId, getSelectedVariant };
+//# sourceMappingURL=product-form.d.mts.map

package/dist/development/core/product/product-form.mjs

@@ -0,0 +1,158 @@
+import { createObservable } from "../observable.mjs";
+import { buildProductOptions, selectedOptionsFromMap, selectedOptionsToMap } from "./options.mjs";
+
+//#region src/core/product/product-form.ts
+function getSelectedVariant(options) {
+	return options[0]?.values.find((v) => v.selected)?.variant ?? null;
+}
+function canAddToCart(product, options) {
+	if (product.requiresSellingPlan) return false;
+	const variant = getSelectedVariant(options);
+	return variant !== null && variant.availableForSale;
+}
+/**
+* Finds the first cart line whose merchandise ID matches.
+* When selling plans are used, the same merchandise ID can appear on multiple
+* cart lines — this returns the first match. Future attribute-based matching
+* will narrow to the exact line.
+*/
+function findCartLineByMerchandiseId(lines, merchandiseId) {
+	return lines.find((l) => l.merchandise?.id === merchandiseId) ?? null;
+}
+function createProductFormStore(product, cartStore, options = {}) {
+	const decodedVariantCache = /* @__PURE__ */ new Map();
+	const initialSelectedOptions = resolveSelectedOptions(product, options.selectedOptions);
+	const context = {
+		observable: createObservable(deriveFullState(buildVariantState(product, initialSelectedOptions, decodedVariantCache), cartStore.getState())),
+		cartStore,
+		currentProduct: product,
+		initialProduct: product,
+		initialSelectedOptions,
+		decodedVariantCache,
+		destroyed: false,
+		unsubCart: () => {}
+	};
+	context.unsubCart = cartStore.subscribe(() => {
+		if (context.destroyed) return;
+		syncFromCart(context);
+	});
+	return {
+		getState: () => context.observable.state,
+		subscribe: (listener) => context.observable.subscribe(listener),
+		selectOption: (name, value) => selectOption(context, name, value),
+		hydrate: (nextProduct, opts) => hydrate(context, nextProduct, opts),
+		reset: () => reset(context),
+		destroy: () => destroy(context),
+		handleFormSubmit: (event) => handleFormSubmit(context, event)
+	};
+}
+function buildVariantState(product, selectedOptions, cache) {
+	return {
+		options: buildProductOptions(product, selectedOptions, cache),
+		selectedOptions
+	};
+}
+function deriveFullState(variant, cartState) {
+	const selectedVariant = getSelectedVariant(variant.options);
+	const matchedLineItem = selectedVariant ? findCartLineByMerchandiseId(cartState.data.lines.nodes, selectedVariant.id) : null;
+	const lineErrors = matchedLineItem ? cartState.errors.lines.get(matchedLineItem.id) : void 0;
+	return {
+		options: variant.options,
+		selectedOptions: variant.selectedOptions,
+		selectedVariant,
+		errors: {
+			userErrors: [...cartState.errors.cart.userErrors, ...lineErrors?.userErrors ?? []],
+			warnings: [...cartState.errors.cart.warnings, ...lineErrors?.warnings ?? []],
+			networkErrors: cartState.errors.network
+		},
+		matchedLineItem
+	};
+}
+function resolveSelectedOptions(product, requested) {
+	return product.selectedOrFirstAvailableVariant?.selectedOptions ?? requested ?? [];
+}
+function selectOption(context, name, value) {
+	const { options, selectedOptions } = context.observable.state;
+	const option = options.find((o) => o.name === name);
+	const optionValue = option?.values.find((v) => v.name === value);
+	if (!option || !optionValue) return invalid(selectedOptions, `Unknown option "${name}" value "${value}".`);
+	if (!optionValue.exists) return invalid(selectedOptions, `Option "${name}" value "${value}" does not resolve to a product variant.`);
+	const nextSelectedOptionMap = {
+		...selectedOptionsToMap(selectedOptions),
+		[name]: value
+	};
+	const nextSelectedOptions = selectedOptionsFromMap(context.currentProduct, nextSelectedOptionMap);
+	return applySelection(context, optionValue.variant ? {
+		status: "resolved",
+		selectedOptions: optionValue.variant.selectedOptions,
+		selectedVariant: optionValue.variant
+	} : {
+		status: "unresolved",
+		selectedOptions: nextSelectedOptions,
+		selectedVariant: null
+	});
+}
+function hydrate(context, product, opts = {}) {
+	context.currentProduct = product;
+	context.decodedVariantCache.clear();
+	const variantState = buildVariantState(product, product.selectedOrFirstAvailableVariant?.selectedOptions ?? opts.selectedOptions ?? context.observable.state.selectedOptions, context.decodedVariantCache);
+	context.observable.setState(deriveFullState(variantState, context.cartStore.getState()));
+}
+function reset(context) {
+	context.currentProduct = context.initialProduct;
+	context.decodedVariantCache.clear();
+	const variantState = buildVariantState(context.initialProduct, context.initialSelectedOptions, context.decodedVariantCache);
+	context.observable.setState(deriveFullState(variantState, context.cartStore.getState()));
+}
+function destroy(context) {
+	context.destroyed = true;
+	context.unsubCart();
+	context.decodedVariantCache.clear();
+}
+function buildAddToCartDetail(context) {
+	const { selectedVariant } = context.observable.state;
+	if (!selectedVariant) return void 0;
+	return { products: [{
+		id: selectedVariant.id,
+		title: selectedVariant.title,
+		product: selectedVariant.product ? {
+			title: selectedVariant.product.title,
+			handle: selectedVariant.product.handle
+		} : void 0,
+		selectedOptions: selectedVariant.selectedOptions,
+		image: selectedVariant.image,
+		price: selectedVariant.price
+	}] };
+}
+async function handleFormSubmit(context, event) {
+	const eventDetail = buildAddToCartDetail(context);
+	await context.cartStore.handleFormSubmit(event, eventDetail);
+}
+function applySelection(context, result) {
+	const variantState = buildVariantState(context.currentProduct, result.selectedOptions, context.decodedVariantCache);
+	context.observable.setState(deriveFullState(variantState, context.cartStore.getState()));
+	return result;
+}
+function hasCartDerivedFieldsChanged(prev, next) {
+	return prev.matchedLineItem !== next.matchedLineItem || prev.selectedVariant !== next.selectedVariant || prev.errors.userErrors !== next.errors.userErrors || prev.errors.warnings !== next.errors.warnings || prev.errors.networkErrors !== next.errors.networkErrors;
+}
+function syncFromCart(context) {
+	const prev = context.observable.state;
+	const next = deriveFullState({
+		options: prev.options,
+		selectedOptions: prev.selectedOptions
+	}, context.cartStore.getState());
+	if (hasCartDerivedFieldsChanged(prev, next)) context.observable.setState(next);
+}
+function invalid(selectedOptions, reason) {
+	return {
+		status: "invalid",
+		selectedOptions,
+		selectedVariant: null,
+		reason
+	};
+}
+
+//#endregion
+export { canAddToCart, createProductFormStore, findCartLineByMerchandiseId, getSelectedVariant };
+//# sourceMappingURL=product-form.mjs.map