@factorypure/client-helpers 1.0.18 → 1.0.19

package/dist/index.d.ts

@@ -15,6 +15,7 @@ export type ScrapeFiltersType = {
     vendor_search_exclusions: string[];
     search_exclusions: string[];
     result_ignore_keys: ResultIgnoreType[];
+    brand_name_alternates: string[];
 };
 export type FilterOptionsType = {
     exclude_linked_variants_enabled?: boolean;
@@ -72,3 +73,20 @@ export declare const calculateIgnoreStatus: (result: ScrapeResultsType, variant:
     sku?: string;
 }, result_ignore_keys: string[] | null) => boolean;
 export declare function calculateVisibility(hide_reasons: string[], hide_override_reasons: string[]): boolean;
+export declare const calculateHideReasons: (result: ScrapeResultsType, variant: {
+    id: number;
+    title: string;
+    sku: string;
+    price: number;
+    vendor: string;
+    regexUnitResults?: any;
+}, variantScrapeOptions: ScrapeFiltersType) => string[];
+export declare const calculateHideOverrideReasons: (result: ScrapeResultsType, variant: {
+    id: number;
+    title: string;
+    sku: string;
+    price: number;
+    vendor: string;
+    found_product_ids?: string[];
+}) => string[];
+export declare function findUnitVariations(data: any): any;

package/dist/index.js

@@ -671,3 +671,180 @@ function getUndercutThreshold(price, undercutThresholdRanges) {
     const range = undercutThresholdRanges.find((r) => price >= r.min && price <= r.max);
     return range ? range.threshold : 0.75; // fallback default
 }
+export const calculateHideReasons = (result, variant, variantScrapeOptions) => {
+    const hide_reasons = [];
+    if (variantScrapeOptions.result_ignore_keys && variantScrapeOptions.result_ignore_keys.length > 0) {
+        variantScrapeOptions.result_ignore_keys.forEach((key) => {
+            const resultKeyValues = [variant.id];
+            const keyValues = [];
+            const keyParts = JSON.parse(key.key_parts);
+            keyParts.forEach((part) => {
+                keyValues.push(key[part]);
+                if (part !== 'variant_id') {
+                    resultKeyValues.push(result[part === 'price' ? 'extracted_price' : part]);
+                }
+            });
+            const parsedIgnoreKey = keyValues.join('-');
+            const resultIgnoreKey = resultKeyValues.join('-');
+            if (parsedIgnoreKey === resultIgnoreKey) {
+                key.reason === 'Ignored'
+                    ? hide_reasons.push('Manually ignored')
+                    : hide_reasons.push('Manually excluded');
+            }
+        });
+    }
+    if (result.brand) {
+        const vendor = variant.vendor ? variant.vendor.toLowerCase() : null;
+        const brandNameAlternates = variantScrapeOptions.brand_name_alternates;
+        const targetBrands = [vendor, ...(brandNameAlternates || [])].filter((b) => b).map((b) => b?.toLowerCase());
+        const calcBrandMatched = result.brand && result.brand !== '' ? targetBrands.includes(result.brand.toLowerCase()) : null;
+        if (calcBrandMatched === false) {
+            hide_reasons.push('Calculated Brand Mismatch');
+        }
+    }
+    if (result.details_and_offers && result.details_and_offers.includes('Out of stock online')) {
+        hide_reasons.push('Out of stock online');
+    }
+    if (result.calculated_sku && result.calculated_sku?.toLowerCase() !== variant.sku.toLowerCase()) {
+        hide_reasons.push('Calculated SKU Mismatch');
+    }
+    if (result.regexUnitResults && variant.regexUnitResults) {
+        const [regexIgnore, regexIgnoreReasons] = getRegexUnitResultsIgnore(result.regexUnitResults, variant.regexUnitResults, result, variant);
+        if (regexIgnore) {
+            hide_reasons.push(...regexIgnoreReasons);
+        }
+    }
+    const refurbishedKeywords = [
+        'refurbished',
+        'renewed',
+        'reconditioned',
+        'refurb',
+        'remanufactured',
+        'scratch',
+        'dent',
+        'used',
+        `${variant.sku}-R`,
+        `${variant.sku}-R`.toLowerCase(),
+        `${variant.sku}-R`.toUpperCase(),
+        `${variant.sku?.toLowerCase()}-R`,
+        `${variant.sku?.toUpperCase()}-R`,
+    ];
+    const normalizedTitle = result.title.toLowerCase().replace(/[^a-z0-9-]/g, ' ');
+    const isRefurbished = refurbishedKeywords.some((keyword) => normalizedTitle.split(/\s+/).includes(keyword)) ||
+        (result.details_and_offers && result.details_and_offers.includes('Pre-owned'));
+    if (isRefurbished) {
+        hide_reasons.push('Refurbished/Used');
+    }
+    return hide_reasons;
+};
+export const calculateHideOverrideReasons = (result, variant) => {
+    const hide_override_reasons = [];
+    const skuRegex = new RegExp(`\\b${variant.sku}\\b`, 'gi');
+    if (skuRegex.test(result.title)) {
+        hide_override_reasons.push('SKU Match');
+    }
+    if (variant.sku.toLowerCase() === result.calculated_sku?.toLowerCase()) {
+        hide_override_reasons.push('Calculated SKU Match');
+    }
+    if (variant.found_product_ids && variant.found_product_ids.includes(result.found_product_id)) {
+        hide_override_reasons.push('Product Id Linked');
+    }
+    return hide_override_reasons;
+};
+function getRegexUnitResultsIgnore(resultRegexResults, variantRegexResults, result, variant) {
+    const failedUnits = [];
+    for (const unit in variantRegexResults) {
+        const variations = variantRegexResults[unit];
+        if (variations.length === 0)
+            continue;
+        const mostCommonVariation = variations[0];
+        const targetVariations = resultRegexResults[unit] || [];
+        if (targetVariations.length === 0)
+            continue;
+        const matchingVariation = resultRegexResults[unit].find((v) => v.normalized === mostCommonVariation.normalized);
+        if (!matchingVariation) {
+            // A unit exists in both the target and variant, but no matching variations were found
+            failedUnits.push(unit);
+        }
+    }
+    const criticalUnits = ['ton', 'cc', 'hp'];
+    const ignoreReasons = [];
+    for (const criticalUnit of criticalUnits) {
+        if (failedUnits.includes(criticalUnit)) {
+            ignoreReasons.push(`Critical Spec Mismatch`);
+        }
+    }
+    if (ignoreReasons.length === 0) {
+        return [false, []];
+    }
+    else {
+        return [true, ignoreReasons];
+    }
+}
+export function findUnitVariations(data) {
+    const units = ['inch', 'cm', 'hp', 'cc', 'ton', 'lbs', 'volts', 'amp', 'ah', 'watt', 'mph', 'mile'];
+    const results = {
+        inch: [],
+        cm: [],
+        hp: [],
+        cc: [],
+        ton: [],
+        lbs: [],
+        volts: [],
+        amp: [],
+        watt: [],
+        mph: [],
+        mile: [],
+        ah: [],
+    };
+    units.forEach((unit) => {
+        const escapedUnit = unit.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+        let variationsRegex;
+        if (unit === '"' || unit.toLowerCase() === 'inch') {
+            // Match numbers (integer or decimal) followed by ", ”, in, inch, inches, -in, - inch, etc.
+            variationsRegex = /\b\d+(\.\d+)?-?\s*(?:(\\"|\\u201d)|("|”)|in(ch(es)?)?|-\s*in(ch(es)?)?)/gi;
+        }
+        else if (unit.toLowerCase() === 'cm') {
+            variationsRegex = /\b\d+(\.\d+)?-?\s*(cm|centimeter(s)?)/gi;
+        }
+        else if (unit.toLowerCase() === 'volts') {
+            variationsRegex = /\b\d+(\.\d+)?-?\s*(v|volts|volt)/gi;
+        }
+        else if (unit.toLowerCase() === 'lbs') {
+            variationsRegex = /\b\d+(\.\d+)?-?\s*(lb|lbs|pounds|pound)/gi;
+        }
+        else if (unit.toLowerCase() === 'hp') {
+            variationsRegex = /\b\d+(\.\d+)?-?\s*(hp|horsepower|horse power)/gi;
+        }
+        else if (unit.toLowerCase() === 'mph') {
+            variationsRegex = /\b\d+(\.\d+)?-?\s*(mph|miles per hour|mile per hour)/gi;
+        }
+        else if (unit.toLowerCase() === 'amp') {
+            variationsRegex = /\b\d+(\.\d+)?-?\s*(?<!A?W?G\s*)(A\b|amp\b|amps\b|amperes\b|ampere\b)/gi;
+        }
+        else if (unit.toLowerCase() === 'ah') {
+            variationsRegex = /\b\d+(\.\d+)?-?\s*(ah|ampere hours|amp hour|amp hours)/gi;
+        }
+        else if (unit.toLowerCase() === 'cc') {
+            variationsRegex = /\b\d+(\.\d+)?-?\s*(cc|cubic centimeters|cubic centimeter)/gi;
+        }
+        else if (unit.toLowerCase() === 'ton') {
+            variationsRegex = /\b\d+(\.\d+)?\s*-?\s*(ton|tons)/gi;
+        }
+        else {
+            // Generic: number + unit, with optional dash or space
+            variationsRegex = new RegExp(`\\b\\d+(\\.\\d+)?\\s*(-?\\s*${escapedUnit})`, 'gi');
+        }
+        const matches = [];
+        const sampleText = JSON.stringify(data);
+        let match;
+        while ((match = variationsRegex.exec(sampleText)) !== null) {
+            matches.push({ value: match[0], source: match[0], normalized: match[0].replace(/[^\d.]/g, '') });
+        }
+        results[unit] = matches;
+        if (results[unit].length === 0) {
+            delete results[unit];
+        }
+    });
+    return results;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@factorypure/client-helpers",
-    "version": "1.0.18",
+    "version": "1.0.19",
     "description": "",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",