HTML Entity Conversion

### Solution:

$legheight = get_post_meta($post_id, '_legheight_field', true);
$legheight = html_entity_decode($legheight, ENT_QUOTES, 'UTF-8');

echo $legheight; // Output: 7/8"

### Explanation:
– `get_post_meta($post_id, '_legheight_field', true)`: Fetches the meta value from the database.
– `html_entity_decode($legheight, ENT_QUOTES, 'UTF-8')`: Converts HTML entities like `"` back to their respective characters (`"` in this case).

This will ensure that when the value is displayed or processed, it appears as `7/8"` instead of `7/8"`.

### **1. Using WooCommerce Global `$product` Object (Inside Loop or Single Product Page)**

global $product;

if ($product) {
    $width = $product->get_attribute('pa_width'); // Get the attribute value
    echo esc_html($width); // Output the value
}

**Explanation:**
– The `get_attribute('pa_width')` method retrieves the value of the `pa_width` attribute.
– `esc_html()` ensures safe output to prevent XSS vulnerabilities.

—

### **2. Using Product ID (Outside Loop)**
If you have a specific product ID, you can fetch the attribute like this:

$product_id = 123; // Replace with your product ID
$product = wc_get_product($product_id);

if ($product) {
    $width = $product->get_attribute('pa_width');
    echo esc_html($width);
}

—

### **3. Getting the Value in JavaScript (for AJAX or Frontend Manipulation)**
If you want to retrieve the `attribute_pa_width` dynamically using JavaScript, you can do this by adding a custom `data-attribute` in your WooCommerce product template:

#### **Step 1: Add Data Attribute in PHP**
Modify your WooCommerce template or a shortcode:

global $product;
if ($product) {
    $width = $product->get_attribute('pa_width');
    echo '<div id="product-width" data-width="' . esc_attr($width) . '"></div>';
}

#### **Step 2: Retrieve it using JavaScript**

document.addEventListener("DOMContentLoaded", function () {
    let width = document.getElementById("product-width")?.dataset.width;
    console.log("Product Width:", width);
});

—

### **4. Debugging**
If the value is not showing, check the following:
– Ensure `pa_width` is defined in **Products → Attributes** in WooCommerce.
– Make sure the product has the attribute assigned.

Let me know if you need further refinements! 🚀

—

### **Retrieve `attribute_pa_width` in Frontend (PHP)**
Use the `get_attribute('pa_width')` method from the `$product` object.

#### **Method 1: Within the Loop or Single Product Page**

global $product;

if ($product) {
    $width = $product->get_attribute('pa_width'); // Retrieves the stored value
    echo esc_html($width); // Output: 14X16
}

—

### **Retrieve `attribute_pa_width` for a Specific Product ID**
If you are outside the loop and have a specific product ID, use `wc_get_product()`:

$product_id = 123; // Replace with the actual product ID
$product = wc_get_product($product_id);

if ($product) {
    $width = $product->get_attribute('pa_width');
    echo esc_html($width);
}

—

### **Retrieve `attribute_pa_width` Using `get_post_meta()`**
Since WooCommerce saves product variations and attributes in post meta, you can also fetch the raw database value:

$product_id = 123; // Replace with the product ID
$width = get_post_meta($product_id, 'attribute_pa_width', true);

echo esc_html($width); // Output: 14X16

**⚠️ Note:**
– `get_post_meta()` is useful for debugging but should be avoided for getting WooCommerce attributes because it does not handle taxonomy-based attributes properly.
– `get_attribute('pa_width')` is the preferred method.

—

### **Retrieve `attribute_pa_width` Using JavaScript (Frontend)**
If you want to retrieve this value dynamically on the frontend using JavaScript, you can expose it in a `data-attribute`:

#### **1. Add a Data Attribute in PHP**

global $product;
if ($product) {
    $width = $product->get_attribute('pa_width');
    echo '<div id="product-width" data-width="' . esc_attr($width) . '"></div>';
}

#### **2. Fetch It Using JavaScript**

document.addEventListener("DOMContentLoaded", function () {
    let width = document.getElementById("product-width")?.dataset.width;
    console.log("Product Width:", width); // Output: 14X16
});

—

### **Final Recommendation**
✅ **Use `$product->get_attribute('pa_width')`** for retrieving the attribute correctly.
✅ **Use `get_post_meta($product_id, 'attribute_pa_width', true)`** for debugging only.

Let me know if you need more details! 🚀

—

### **Solution for Retrieving Correctly Formatted `attribute_pa_width`**
Use `html_entity_decode()` to convert `"` into `"`.

#### **1. Preferred Method (WooCommerce `get_attribute`)**

global $product;

if ($product) {
    $width = $product->get_attribute('pa_width'); // Get attribute value
    $width = html_entity_decode($width, ENT_QUOTES, 'UTF-8'); // Convert " to "
    echo esc_html($width); // Output: 14"X16"
}

—

#### **2. Alternative: Using `get_post_meta()`**
If you prefer using `get_post_meta()`, do the following:

$product_id = 123; // Replace with the actual product ID
$width = get_post_meta($product_id, 'attribute_pa_width', true);
$width = html_entity_decode($width, ENT_QUOTES, 'UTF-8');

echo esc_html($width); // Output: 14"X16"

—

#### **3. JavaScript Approach for Frontend Display**
If you need to use this value in JavaScript, ensure it's printed correctly in an attribute:

##### **Step 1: Modify the PHP Output**

global $product;
if ($product) {
    $width = $product->get_attribute('pa_width');
    $width = html_entity_decode($width, ENT_QUOTES, 'UTF-8');
    echo '<div id="product-width" data-width="' . esc_attr($width) . '"></div>';
}

##### **Step 2: Retrieve in JavaScript**

document.addEventListener("DOMContentLoaded", function () {
    let width = document.getElementById("product-width")?.dataset.width;
    console.log("Product Width:", width); // Output: 14"X16"
});

—

### **Final Recommendation**
✅ **Use `$product->get_attribute('pa_width')`** and decode HTML entities using `html_entity_decode()`.
✅ **Use `esc_html()` for output safety** when displaying in HTML.
✅ **For JavaScript, store the attribute in `data-` and retrieve it cleanly**.

Let me know if you need any refinements! 🚀

—

### **Retrieve `attribute_pa_width` Using Variation ID**

$variation_id = 123; // Replace with actual variation ID
$width = get_post_meta($variation_id, 'attribute_pa_width', true);
$width = html_entity_decode($width, ENT_QUOTES, 'UTF-8'); // Convert " to "

echo esc_html($width); // Output: 14"X16"

—

### **Alternative: Retrieve Using `WC_Product_Variation` Class**

$variation = wc_get_product($variation_id);

if ($variation && $variation->is_type('variation')) {
    $width = $variation->get_attribute('pa_width'); // Retrieve the formatted attribute
    $width = html_entity_decode($width, ENT_QUOTES, 'UTF-8');

    echo esc_html($width); // Output: 14"X16"
}

✔ **Recommended because it ensures WooCommerce properly processes the attribute.**

—

### **Retrieve in JavaScript (Frontend)**
If you need to use this in JavaScript, add it as a `data-attribute`:

#### **1. Modify the PHP Output**

echo '<div id="product-width" data-width="' . esc_attr($width) . '"></div>';

#### **2. Fetch It Using JavaScript**

document.addEventListener("DOMContentLoaded", function () {
    let width = document.getElementById("product-width")?.dataset.width;
    console.log("Product Width:", width); // Output: 14"X16"
});

—

### **Key Takeaways**
✅ Use `get_post_meta($variation_id, 'attribute_pa_width', true)` for raw database values.
✅ Use `$variation->get_attribute('pa_width')` for WooCommerce-friendly processing.
✅ Use `html_entity_decode()` to convert `"` into `"` for proper formatting.

Let me know if you need more help! 🚀

### **Solution: Convert `14X16` to `14"X16"` Before Matching**

#### **Step 1: Check the Frontend Format**
WooCommerce automatically formats attribute labels when rendering them in variation dropdowns. If it's adding quotes, you need to **match the stored value (`14X16`) with the formatted version (`14"X16"`)**.

#### **Step 2: Add Quotes to Stored Value**
Before comparing, **modify the stored value (`14X16`) to match WooCommerce’s format** by adding quotes (`"`) around the numbers.

##### **PHP Fix**

$variation_id = 123; // Replace with actual variation ID
$width = get_post_meta($variation_id, 'attribute_pa_width', true);

// Convert "14X16" to '14"X16"'
$formatted_width = preg_replace('/(d+)X(d+)/', '$1"$2"', $width);

echo esc_html($formatted_width); // Output: 14"X16"

**What This Does:**
– Looks for **numbers (`d+`) separated by `X`**.
– Converts `14X16` into `14"X16"`.
– Ensures it matches WooCommerce's frontend dropdown format.

—

### **Step 3: Use This When Comparing Dropdown Selection**
If you're using this in **JavaScript (Frontend)** to match the dropdown selection, pass this formatted value:

echo '<div id="product-width" data-width="' . esc_attr($formatted_width) . '"></div>';

Then in **JavaScript**:

document.addEventListener("DOMContentLoaded", function () {
    let storedWidth = document.getElementById("product-width")?.dataset.width;
    let selectedWidth = document.querySelector("#width-dropdown")?.value; // Replace with actual selector

    if (storedWidth === selectedWidth) {
        console.log("Matched:", storedWidth);
    } else {
        console.log("Mismatch: Stored =", storedWidth, ", Selected =", selectedWidth);
    }
});

—

### **Final Thoughts**
✔ **Use `preg_replace('/(d+)X(d+)/', '$1"$2"', $width);` to match WooCommerce formatting.**
✔ **Ensure the backend and frontend use the same format before comparison.**
✔ **Use JavaScript for matching if comparing dropdown selections dynamically.**

Let me know if you need further tweaks! 🚀

Let me know how I can assist! 🚀

—

### **Solution: Convert "1-5-8" to "1-5/8"**
Use `preg_replace()` to format the value correctly.

#### **PHP Code**

$value = "1-5-8"; // Example input from database

// Convert "1-5-8" to "1-5/8"
$formatted_value = preg_replace('/(d+)-(d+)-(d+)/', '$1-$2/$3"', $value);

echo esc_html($formatted_value); // Output: 1-5/8"

—

### **Explanation:**
– `(d+)` → Captures **1st, 2nd, and 3rd numbers**.
– `-` → Matches the **hyphens** in between.
– **Replaces** `1-5-8` with `1-5/8"`.

—

### **Applying to WooCommerce Variation Attribute**
If this value is stored in a **WooCommerce product variation**, use:

$variation_id = 123; // Replace with actual variation ID
$raw_value = get_post_meta($variation_id, 'attribute_pa_width', true);

// Format it
$formatted_value = preg_replace('/(d+)-(d+)-(d+)/', '$1-$2/$3"', $raw_value);

echo esc_html($formatted_value); // Output: 1-5/8"

—

### **Matching in JavaScript (Frontend)**
If the WooCommerce dropdown displays **"1-5/8""** but the raw database value is **"1-5-8"**, modify it in JavaScript before comparison.

document.addEventListener("DOMContentLoaded", function () {
    let rawValue = "1-5-8"; // Example from database
    let formattedValue = rawValue.replace(/(d+)-(d+)-(d+)/, "$1-$2/$3"");

    console.log("Formatted Value:", formattedValue); // Output: 1-5/8"
});

—

### **Final Thoughts**
✅ Use `preg_replace()` to reformat before displaying in PHP.
✅ Modify WooCommerce variation values before output.
✅ Adjust JavaScript formatting if needed for dropdown selections.

Let me know if you need further refinements! 🚀

—

### **1. WooCommerce's Attribute Slug Sanitization**
WooCommerce **converts non-alphanumeric characters (except dashes) to ensure compatibility** with URLs and internal processing.

– **Original Input (Admin Panel):** `1-5/8"`
– **Sanitized Storage (Database):** `1-5-8`

#### **Why?**
– The **slash (/) and double quote (") are removed or replaced** during WooCommerce's sanitization.
– WooCommerce typically uses `sanitize_title()` or similar functions that **replace non-URL-safe characters**.

✅ **This ensures variation attributes can be used as part of URLs or slugs.**

—

### **2. How to Store & Retrieve the Correct Value?**
Since WooCommerce **automatically formats the dropdown values in the frontend**, the best way to ensure consistency is:

#### **Retrieve the Stored Value and Format It Back**

$variation_id = 123; // Replace with actual variation ID
$raw_value = get_post_meta($variation_id, 'attribute_pa_width', true);

// Convert "1-5-8" back to "1-5/8""
$formatted_value = preg_replace('/(d+)-(d+)-(d+)/', '$1-$2/$3"', $raw_value);

echo esc_html($formatted_value); // Output: 1-5/8"

—

### **3. Ensure Display in WooCommerce Matches the Stored Value**
If WooCommerce automatically **displays "1-5/8"" in the frontend dropdown**, then no change is needed—just ensure that the **backend retrieval matches**.

– **Stored in DB:** `1-5-8`
– **Displayed in Dropdown:** `1-5/8"`

Use `$product->get_attribute('pa_width')` to get the correct formatted value:

global $product;
if ($product) {
    $width = $product->get_attribute('pa_width'); // Retrieves formatted value
    echo esc_html($width); // Output: 1-5/8"
}

—

### **4. How to Avoid This Issue in the Future?**
If you want to **store attributes with exact formatting**, WooCommerce requires a custom approach:
1. **Use a Custom Product Meta Field**
– Instead of using WooCommerce variation attributes (`attribute_pa_width`), create a **custom field** where you store `1-5/8"` as-is.

2. **Modify WooCommerce's Attribute Handling**
– Filter WooCommerce's attribute sanitization using `sanitize_title` or override how attributes are stored.

—

### **Final Thoughts**
✔ **WooCommerce strips slashes (`/`) and quotes (`"`) when saving attributes for URL compatibility.**
✔ **Retrieve the stored value and format it back before displaying.**
✔ **Use `$product->get_attribute('pa_width')` to get WooCommerce's formatted value.**
✔ **For exact storage, consider using custom meta fields instead of variation attributes.**

Let me know if you need further refinements! 🚀

$product = wc_get_product($product_id);
if (!$product || !$product->is_type('variable')) {
wp_send_json_error(['message' => 'No variations found']);
wp_die();
}

$match_attributes = array();
foreach ($attributes as $key => $value) {
$match_attributes['attribute_' . sanitize_title($key)] = strtolower($value);
}

$data_store = WC_Data_Store::load( 'product' );
$variation_id = $data_store->find_matching_product_variation(
new WC_Product( $product_id),$match_attributes
);
variation id always return 0 even we passwed 14"X16" width value and want to get varid based on it

—

### **Steps to Fix:**
We need to:
1. **Sanitize the input attributes correctly** to match WooCommerce’s database format.
2. **Check how the attribute is stored in the database** (`wp_postmeta` table for variations).
3. **Ensure matching happens with the correct format**.

—

### **Step 1: Debug How WooCommerce Stores Attributes**
Before trying to match variations, check how WooCommerce stores attributes.

#### **Run This Query (if you have database access)**

SELECT * FROM wp_postmeta WHERE meta_key LIKE 'attribute_pa_%';

This will help confirm if:
– `14"X16"` is stored as **`14X16`**
– Or as **`14-16`**
– Or some other format.

—

### **Step 2: Modify Your Code to Match WooCommerce's Format**
Since WooCommerce likely stores `14"X16"` as `14X16`, we **convert input attributes before matching**.

#### **Updated Code**

$product_id = intval($_POST['product_id']);
$attributes = $_POST['attributes'];

$product = wc_get_product($product_id);
if (!$product || !$product->is_type('variable')) {
    wp_send_json_error(['message' => 'No variations found']);
    wp_die();
}

$match_attributes = array();
foreach ($attributes as $key => $value) {
    $formatted_value = preg_replace('/(d+)"?X(d+)"/', '$1X$2', strtolower($value)); // Remove quotes
    $match_attributes['attribute_' . sanitize_title($key)] = $formatted_value;
}

// Debugging: Check the attribute format before calling WooCommerce function
error_log(print_r($match_attributes, true));

$data_store   = WC_Data_Store::load('product');
$variation_id = $data_store->find_matching_product_variation(new WC_Product($product_id), $match_attributes);

if ($variation_id) {
    wp_send_json_success(['variation_id' => $variation_id]);
} else {
    wp_send_json_error(['message' => 'No matching variation found']);
}
wp_die();

—

### **Step 3: Explanation of Fix**
✅ **Sanitization Fix:**
– The regex **removes the quotes** from `14"X16"` to match WooCommerce’s stored format (`14X16`).
– `preg_replace('/(d+)"?X(d+)"/', '$1X$2', strtolower($value));` ensures input matches the database.

✅ **Debugging Step:**
– `error_log(print_r($match_attributes, true));` allows you to check the formatted attributes in the PHP error log.

✅ **Ensuring `find_matching_product_variation()` Works:**
– **Before calling it**, check how the database stores `attribute_pa_width` and format your input accordingly.

—

### **Step 4: Alternative Debugging – Check Variations in WooCommerce**
Run this query:

SELECT * FROM wp_postmeta WHERE meta_key = 'attribute_pa_width';

If it returns `14X16`, then **removing `"` in the PHP code** will fix the issue.

—

### **Final Takeaways**
✔ **WooCommerce removes `"` when storing attributes.**
✔ **Modify input (`14"X16"` → `14X16`) before looking up variations.**
✔ **Use `error_log(print_r($match_attributes, true));` for debugging.**

Let me know if you need further refinements! 🚀

—

## **Solution: Convert Input to Match WooCommerce's Storage Format**
To ensure a successful match, **convert** the input (`14"X16"`) to the correct format (`14×16`) before passing it to `find_matching_product_variation()`.

### **Fixed Code**

$product_id = intval($_POST['product_id']);
$attributes = $_POST['attributes'];

$product = wc_get_product($product_id);
if (!$product || !$product->is_type('variable')) {
    wp_send_json_error(['message' => 'No variations found']);
    wp_die();
}

$match_attributes = array();
foreach ($attributes as $key => $value) {
    // Convert input format (14"X16") to match WooCommerce stored format (14x16)
    $formatted_value = strtolower(str_replace(['"', 'X'], ['', 'x'], $value));

    $match_attributes['attribute_' . sanitize_title($key)] = $formatted_value;
}

// Debugging: Log formatted attributes before matching
error_log(print_r($match_attributes, true));

$data_store   = WC_Data_Store::load('product');
$variation_id = $data_store->find_matching_product_variation(new WC_Product($product_id), $match_attributes);

if ($variation_id) {
    wp_send_json_success(['variation_id' => $variation_id]);
} else {
    wp_send_json_error(['message' => 'No matching variation found']);
}
wp_die();

—

## **How This Fix Works**
✅ **Converts `14"X16"` → `14×16`**
– `str_replace(['"', 'X'], ['', 'x'], $value);`
– Removes `"` from the value.
– Converts uppercase `X` to lowercase `x` to match WooCommerce format.

✅ **Ensures WooCommerce Can Find the Variation**
– WooCommerce stores `attribute_pa_width = 14×16`, so we **match the format exactly**.

✅ **Debugging Step**
– `error_log(print_r($match_attributes, true));` helps verify the formatted attributes before matching.

—

## **Expected Behavior After Fix**
| **Input (Sent by Frontend)** | **Transformed Input (Matches DB)** | **WooCommerce Stored Value** | **Match Found?** |
|—————————-|——————————–|————————|—————-|
| `14"X16"` | `14×16` | `14×16` | ✅ Yes |
| `14X16` | `14×16` | `14×16` | ✅ Yes |
| `14"x16"` | `14×16` | `14×16` | ✅ Yes |

Now, `find_matching_product_variation()` will correctly return the variation ID.

—

## **Final Takeaways**
✔ **WooCommerce stores `14×16`, so match input accordingly.**
✔ **Convert `14"X16"` → `14×16` using `str_replace()`.**
✔ **Use `error_log(print_r($match_attributes, true));` for debugging.**
✔ **This will ensure your variation ID is returned correctly.**

Let me know if you need further refinements! 🚀

—

## **Fix: Fetch Post Meta Instead of Taxonomy Terms**
Modify the code to handle **both** taxonomy-based attributes and custom (post meta) attributes.

### **Fixed Code**

$product_id = 123; // Replace with actual product ID
$product = wc_get_product($product_id);

$attributes = $product->get_attributes();

$filterOption = '';

foreach ($attributes as $attr_name => $attribute) {
    if ($attribute->is_taxonomy()) {
        // For taxonomy-based attributes (e.g., global attributes)
        $terms = wc_get_product_terms($product_id, $attr_name, ['fields' => 'names']);
        foreach ($terms as $term) {
            $filterOption .= '<option value="' . esc_attr($term) . '">' . esc_html($term) . '</option>';
        }
    } else {
        // For custom attributes stored in post meta
        $values = explode('|', $attribute->get_options()); // Get values for non-taxonomy attributes
        foreach ($values as $value) {
            $filterOption .= '<option value="' . esc_attr($value) . '">' . esc_html($value) . '</option>';
        }
    }
}

// Output options
echo $filterOption;

—

## **Why This Works**
✅ **Handles both taxonomy-based and custom attributes correctly.**
✅ **Checks if the attribute is stored in the post meta (`!is_taxonomy()`).**
✅ **Uses `get_options()` for custom attributes and `wc_get_product_terms()` for taxonomy attributes.**

Now, if `attribute_pa_width` is stored in post meta (`attribute_pa_width = 14×16`), it will be fetched correctly and displayed in the dropdown.

Let me know if you need further refinements! 🚀

### **Problem**
– Your **dropdown values (`esc_attr($term)`)** are retrieved from **WooCommerce taxonomy attributes** (e.g., `14"X16"`).
– **WooCommerce stores variation attributes differently** (e.g., `14×16`).
– `find_matching_product_variation()` expects attributes to match **exactly** as stored in the DB.
– If `esc_attr($term)` contains `14"X16"`, but the variation is stored as `14×16`, it won’t match.

—

### **Solution: Format `$term` Before Matching**
You need to **sanitize and transform** `$term` to match the stored format before passing it to `find_matching_product_variation()`.

### **Updated Code**

$product_id = 123; // Replace with actual product ID
$attributes = $_POST['attributes']; // Input from the dropdown

$product = wc_get_product($product_id);
if (!$product || !$product->is_type('variable')) {
    wp_send_json_error(['message' => 'No variations found']);
    wp_die();
}

$match_attributes = array();
foreach ($attributes as $key => $value) {
    // Convert WooCommerce display format to match stored format
    $formatted_value = strtolower(str_replace(['"', 'X'], ['', 'x'], $value));

    $match_attributes['attribute_' . sanitize_title($key)] = $formatted_value;
}

// Debugging: Log formatted attributes before matching
error_log(print_r($match_attributes, true));

$data_store = WC_Data_Store::load('product');
$variation_id = $data_store->find_matching_product_variation(new WC_Product($product_id), $match_attributes);

if ($variation_id) {
    wp_send_json_success(['variation_id' => $variation_id]);
} else {
    wp_send_json_error(['message' => 'No matching variation found']);
}
wp_die();

—

### **How This Fix Works**
✔ **Converts `14"X16"` (dropdown value) → `14×16` (WooCommerce stored value).**
✔ **Ensures attribute names match WooCommerce's sanitized format.**
✔ **Logs formatted attributes for debugging (`error_log(print_r($match_attributes, true));`).**

—

### **Alternative Debugging (Check Database Format)**
Run this query in your database to check how attributes are stored:

SELECT meta_key, meta_value FROM wp_postmeta WHERE meta_key LIKE 'attribute_pa_%';

If the values are stored as `14×16`, then your code must **convert** `14"X16"` → `14×16` before passing to `find_matching_product_variation()`.

—

### **Final Thoughts**
– **Match WooCommerce stored format (`14×16`) before calling `find_matching_product_variation()`.**
– **Use `str_replace(['"', 'X'], ['', 'x'], $value);` to fix casing and remove quotes.**
– **Log `error_log(print_r($match_attributes, true));` to debug.**

This should ensure `find_matching_product_variation()` correctly finds the variation. 🚀 Let me know if you need further refinements!

The issue occurs because WooCommerce sanitizes variation attributes **before storing them**, replacing `/` with `-`. However, when displaying on the frontend, it **formats it back as `1-5/8"`**.

#### **Solution: Convert the Dropdown Value (`1-5/8"`) Back to Match the DB Format (`1-5-8`)**
Before calling `find_matching_product_variation()`, convert:
– **`1-5/8"` → `1-5-8`** (to match stored value)
– **`14"X16"` → `14×16`** (as per previous issue)

—

### **Updated Code**

$product_id = intval($_POST['product_id']);
$attributes = $_POST['attributes'];

$product = wc_get_product($product_id);
if (!$product || !$product->is_type('variable')) {
    wp_send_json_error(['message' => 'No variations found']);
    wp_die();
}

$match_attributes = array();
foreach ($attributes as $key => $value) {
    // Convert WooCommerce dropdown format back to stored format
    $formatted_value = strtolower($value);
    
    // Convert "1-5/8" to "1-5-8"
    $formatted_value = preg_replace('/(d+)-(d+)/(d+)"/', '$1-$2-$3', $formatted_value);

    // Convert "14"X16"" to "14x16"
    $formatted_value = str_replace(['"', 'X'], ['', 'x'], $formatted_value);

    // Set the formatted value
    $match_attributes['attribute_' . sanitize_title($key)] = $formatted_value;
}

// Debugging: Check attribute format before calling WooCommerce function
error_log(print_r($match_attributes, true));

$data_store   = WC_Data_Store::load('product');
$variation_id = $data_store->find_matching_product_variation(new WC_Product($product_id), $match_attributes);

if ($variation_id) {
    wp_send_json_success(['variation_id' => $variation_id]);
} else {
    wp_send_json_error(['message' => 'No matching variation found']);
}
wp_die();

—

### **How This Works**
1. **Handles `1-5/8"`**
– Converts `1-5/8"` → `1-5-8` to match the database.
– Uses `preg_replace('/(d+)-(d+)/(d+)"/', '$1-$2-$3', $formatted_value);`.

2. **Handles `14"X16"`**
– Converts `14"X16"` → `14×16` (removes `"` and converts `X` to lowercase `x`).

3. **Ensures Accurate Matching**
– WooCommerce uses sanitized values when calling `find_matching_product_variation()`, so we need to match its format.

—

### **Debugging (Check Database Stored Values)**
Run this SQL query to check how attributes are stored in the database:

SELECT meta_key, meta_value FROM wp_postmeta WHERE meta_key LIKE 'attribute_pa_%';

– If it returns `1-5-8`, the fix above will work.
– If it returns `1-5/8"`, adjust the conversion.

—

### **Final Thoughts**
✅ **Ensures WooCommerce finds variations correctly.**
✅ **Handles `1-5/8"` and `14"X16"` correctly by converting them to stored values.**
✅ **Uses `preg_replace()` for fraction conversion and `str_replace()` for `X`.**
✅ **Logs `error_log(print_r($match_attributes, true));` to debug any mismatches.**

This should correctly return the variation ID when a user selects from the dropdown. 🚀 Let me know if you need further refinements!

—

## **Solution 1: Disable Browser Auto-Fill**
Since the issue is related to **browser auto-suggestions**, adding `autocomplete="off"` to the “ field associated with “ can prevent previously selected values from appearing.

#### **Update the Input Field**

<input type="text" id="product_code_input" list="product_code-<?php echo $product->get_id(); ?>" autocomplete="off">

✔ **Prevents previously entered values from appearing with "X".**
✔ **Still allows selection from “.**

—

## **Solution 2: Use a JavaScript Workaround**
If the browser still remembers previous selections, **clear the input on page load**:

document.addEventListener("DOMContentLoaded", function() {
    document.getElementById("product_code_input").value = "";
});

✔ **Ensures that previously entered values are not pre-filled.**
✔ **Still allows selection from “.**

—

## **Solution 3: Convert “ to a Regular “**
If you **don’t need free text input**, consider using “ instead of “:

<select name="product_code">
    <?php 
    if(is_array($p_sku) && count($p_sku) > 0){
        foreach($p_sku as $data){
            echo '<option value="'.esc_attr($data).'">'.esc_html($data).'</option>';
        }
    }
    ?>
</select>

✔ **No previously entered values are stored.**
✔ **Only predefined options can be selected.**

—

## **Final Takeaways**
– **Use `autocomplete="off"` on the “ field** to prevent previously selected values.
– **Use JavaScript (`document.getElementById("product_code_input").value = ""`)** to clear pre-filled values on page load.
– **Consider using “ instead of “** if only predefined values should be used.

Let me know if you need further refinements! 🚀