@factorypure/client-helpers 1.0.17 → 1.0.19

package/dist/index.d.ts

@@ -1,6 +1,8 @@
-import { z } from "zod";
+import { z } from 'zod';
 export declare const scrapeResultsSchema: any;
 export type ScrapeResultsType = z.infer<typeof scrapeResultsSchema>;
+export declare const ResultIgnoreSchema: any;
+export type ResultIgnoreType = z.infer<typeof ResultIgnoreSchema>;
 export type ScrapeFiltersType = {
     found_id_exclusions: number[] | null;
     showHighPriceOutliers: boolean;
@@ -12,7 +14,8 @@ export type ScrapeFiltersType = {
     skip_vendors: string[];
     vendor_search_exclusions: string[];
     search_exclusions: string[];
-    result_ignore_keys: string[] | null;
+    result_ignore_keys: ResultIgnoreType[];
+    brand_name_alternates: string[];
 };
 export type FilterOptionsType = {
     exclude_linked_variants_enabled?: boolean;
@@ -39,11 +42,17 @@ export declare const HIDE_REASONS: {
     CALCULATED_SKU_MISMATCH: string;
     CRITICAL_SPEC_MISMATCH: string;
     MANUALLY_IGNORED: string;
+    MANUALLY_EXCLUDED: string;
     OUT_OF_STOCK_ONLINE: string;
     REFURBISHED_USED: string;
     SKIP_SKU: string;
     VENDOR_EXCLUSION: string;
 };
+export declare const HIDE_OVERRIDE_REASONS: {
+    SKU_MATCH: string;
+    CALCULATED_SKU_MATCH: string;
+    CALCULATED_SKU_PARTIAL_MATCH: string;
+};
 export declare const TOO_CHEAP_MULTIPLIER = 0.75;
 export declare const TOO_EXPENSIVE_MULTIPLIER = 1.25;
 export declare const filterScrapeResults: ({ scrapeResults, variant, filters, filterOptions, globalScrapeOptions, }: {
@@ -63,3 +72,21 @@ export declare const calculateIgnoreStatus: (result: ScrapeResultsType, variant:
     id: number;
     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

@@ -1,10 +1,10 @@
-import { startOfDay, subDays } from "date-fns";
+import { startOfDay, subDays } from 'date-fns';
 // @ts-ignore
-import { Index } from "flexsearch";
+import { Index } from 'flexsearch';
 // @ts-ignore
-import EnglishPreset from "flexsearch/lang/en";
+import EnglishPreset from 'flexsearch/lang/en';
 // @ts-ignore
-import { z } from "zod";
+import { z } from 'zod';
 export const scrapeResultsSchema = z.object({
     id: z.number(),
     scrape_id: z.number(),
@@ -37,21 +37,53 @@ export const scrapeResultsSchema = z.object({
     store_id: z.number(),
     match_score: z.number().nullable(),
 });
+export const ResultIgnoreSchema = z.object({
+    id: z.number(),
+    variant_id: z.number(),
+    title: z.string(),
+    price: z.string(),
+    source: z.string(),
+    reason: z.string(),
+    duration_days: z.number(),
+    created_by: z.number(),
+    key_parts: z.string(),
+});
 export const HIDE_REASONS = {
-    IGNORED: "Ignored",
-    HIGH_PRICE_OUTLIER: "Too Expensive",
-    LOW_PRICE_OUTLIER: "Too Cheap",
-    DATE_OUTLIER: "Outdated Listing",
-    COMPETITOR_EXCLUSION: "Source Excluded",
-    DUPLICATE: "Duplicate",
-    SEARCH_EXCLUSION: "Search Exclusion",
-    CALCULATED_SKU_MISMATCH: "Calculated SKU Mismatch",
-    CRITICAL_SPEC_MISMATCH: "Critical Spec Mismatch",
-    MANUALLY_IGNORED: "Manually ignored",
-    OUT_OF_STOCK_ONLINE: "Out of stock online",
-    REFURBISHED_USED: "Refurbished/Used",
-    SKIP_SKU: "Skipped SKU",
-    VENDOR_EXCLUSION: "Vendor Exclusion",
+    IGNORED: 'Ignored',
+    HIGH_PRICE_OUTLIER: 'Too Expensive',
+    LOW_PRICE_OUTLIER: 'Too Cheap',
+    DATE_OUTLIER: 'Outdated Listing',
+    COMPETITOR_EXCLUSION: 'Source Excluded',
+    DUPLICATE: 'Duplicate',
+    SEARCH_EXCLUSION: 'Search Exclusion',
+    CALCULATED_SKU_MISMATCH: 'Calculated SKU Mismatch',
+    CRITICAL_SPEC_MISMATCH: 'Critical Spec Mismatch',
+    MANUALLY_IGNORED: 'Manually ignored',
+    MANUALLY_EXCLUDED: 'Manually excluded',
+    OUT_OF_STOCK_ONLINE: 'Out of stock online',
+    REFURBISHED_USED: 'Refurbished/Used',
+    SKIP_SKU: 'Skipped SKU',
+    VENDOR_EXCLUSION: 'Vendor Exclusion',
+};
+export const HIDE_OVERRIDE_REASONS = {
+    SKU_MATCH: 'SKU Match',
+    CALCULATED_SKU_MATCH: 'Calculated SKU Match',
+    CALCULATED_SKU_PARTIAL_MATCH: 'Calculated SKU Partial Match',
+};
+const HIDE_ALWAYS_MAP = {
+    [HIDE_REASONS.HIGH_PRICE_OUTLIER]: true,
+    [HIDE_REASONS.LOW_PRICE_OUTLIER]: true,
+    [HIDE_REASONS.DATE_OUTLIER]: true,
+    [HIDE_REASONS.COMPETITOR_EXCLUSION]: false,
+    [HIDE_REASONS.DUPLICATE]: true,
+    [HIDE_REASONS.SEARCH_EXCLUSION]: false,
+    [HIDE_REASONS.CALCULATED_SKU_MISMATCH]: false,
+    [HIDE_REASONS.CRITICAL_SPEC_MISMATCH]: false,
+    [HIDE_REASONS.MANUALLY_IGNORED]: true,
+    [HIDE_REASONS.OUT_OF_STOCK_ONLINE]: true,
+    [HIDE_REASONS.REFURBISHED_USED]: false,
+    [HIDE_REASONS.SKIP_SKU]: false,
+    [HIDE_REASONS.VENDOR_EXCLUSION]: false,
 };
 export const TOO_CHEAP_MULTIPLIER = 0.75;
 export const TOO_EXPENSIVE_MULTIPLIER = 1.25;
@@ -105,8 +137,8 @@ const handleIndexSearch = (dataToSearch, filters, variant, filterOptions) => {
         const tokens = [];
         const str = content.toLowerCase();
         // Remove symbols from the string (keep only letters, numbers, commas, and spaces)
-        const cleanedStr = str.replace(/[\/-]/g, " ");
-        const cleanedStr2 = cleanedStr.replace(/[^a-z0-9,\/\s]/gi, "");
+        const cleanedStr = str.replace(/[\/-]/g, ' ');
+        const cleanedStr2 = cleanedStr.replace(/[^a-z0-9,\/\s]/gi, '');
         const words = cleanedStr2.split(/\s+/);
         for (let word of words) {
             tokens.push(word);
@@ -117,7 +149,7 @@ const handleIndexSearch = (dataToSearch, filters, variant, filterOptions) => {
         charset: EnglishPreset,
         // encoder: encoder,
         encode: customEncoder,
-        tokenize: "strict",
+        tokenize: 'strict',
     });
     dataToSearch.forEach((item, id) => {
         index.add(id, item.title);
@@ -160,7 +192,7 @@ const handleIndexSearch = (dataToSearch, filters, variant, filterOptions) => {
         nots.push(...formatted);
     }
     const lowerCaseTitle = title.toLowerCase();
-    const titleWithoutSku = lowerCaseTitle.replace(sku.toLowerCase(), "");
+    const titleWithoutSku = lowerCaseTitle.replace(sku.toLowerCase(), '');
     const wattageTerms = Array.from(titleWithoutSku.matchAll(/\b(\d{4,5})w\b/gi)).map((match) => match[1]);
     const wattagesToExclude = wattages.filter((wattage) => !wattageTerms.includes(wattage));
     if (filterOptions.wattage_exclusions_enabled) {
@@ -173,15 +205,13 @@ const handleIndexSearch = (dataToSearch, filters, variant, filterOptions) => {
             }
         });
     }
-    if (filters.search_exclusions.length &&
-        filterOptions.search_exclusions_enabled) {
+    if (filters.search_exclusions.length && filterOptions.search_exclusions_enabled) {
         nots.push(...filters.search_exclusions);
     }
-    if (filters.vendor_search_exclusions.length &&
-        filterOptions.skip_skus_enabled) {
+    if (filters.vendor_search_exclusions.length && filterOptions.skip_skus_enabled) {
         nots.push(...filters.vendor_search_exclusions.filter((sku) => sku.toLowerCase() !== variant.sku.toLowerCase()));
     }
-    if (title.toLowerCase().includes("dual fuel")) {
+    if (title.toLowerCase().includes('dual fuel')) {
         // nots.push('tri fuel', 'trifuel', 'tri-fuel')
     }
     nots.forEach((term) => {
@@ -216,8 +246,8 @@ const handleVendorExclusions = (dataToSearch, filters, variant, filterOptions) =
         const tokens = [];
         const str = content.toLowerCase();
         // Remove symbols from the string (keep only letters, numbers, commas, and spaces)
-        const cleanedStr = str.replace(/[\/-]/g, " ");
-        const cleanedStr2 = cleanedStr.replace(/[^a-z0-9,\/\s]/gi, "");
+        const cleanedStr = str.replace(/[\/-]/g, ' ');
+        const cleanedStr2 = cleanedStr.replace(/[^a-z0-9,\/\s]/gi, '');
         const words = cleanedStr2.split(/\s+/);
         for (let word of words) {
             tokens.push(word);
@@ -228,7 +258,7 @@ const handleVendorExclusions = (dataToSearch, filters, variant, filterOptions) =
         charset: EnglishPreset,
         // encoder: encoder,
         encode: customEncoder,
-        tokenize: "strict",
+        tokenize: 'strict',
     });
     dataToSearch.forEach((item, id) => {
         index.add(id, item.title);
@@ -299,8 +329,8 @@ const handleSkipSkuSearch = (dataToSearch, filters, variant, filterOptions) => {
         const tokens = [];
         const str = content.toLowerCase();
         // Remove symbols from the string (keep only letters, numbers, commas, and spaces)
-        const cleanedStr = str.replace(/[\/-]/g, " ");
-        const cleanedStr2 = cleanedStr.replace(/[^a-z0-9,\/\s]/gi, "");
+        const cleanedStr = str.replace(/[\/-]/g, ' ');
+        const cleanedStr2 = cleanedStr.replace(/[^a-z0-9,\/\s]/gi, '');
         const words = cleanedStr2.split(/\s+/);
         for (let word of words) {
             tokens.push(word);
@@ -311,7 +341,7 @@ const handleSkipSkuSearch = (dataToSearch, filters, variant, filterOptions) => {
         charset: EnglishPreset,
         // encoder: encoder,
         encode: customEncoder,
-        tokenize: "strict",
+        tokenize: 'strict',
     });
     dataToSearch.forEach((item, id) => {
         index.add(id, item.title);
@@ -378,8 +408,8 @@ const handleExclusionsSearch = (dataToSearch, filters, variant, filterOptions) =
         const tokens = [];
         const str = content.toLowerCase();
         // Remove symbols from the string (keep only letters, numbers, commas, and spaces)
-        const cleanedStr = str.replace(/[\/-]/g, " ");
-        const cleanedStr2 = cleanedStr.replace(/[^a-z0-9,\/\s]/gi, "");
+        const cleanedStr = str.replace(/[\/-]/g, ' ');
+        const cleanedStr2 = cleanedStr.replace(/[^a-z0-9,\/\s]/gi, '');
         const words = cleanedStr2.split(/\s+/);
         for (let word of words) {
             tokens.push(word);
@@ -390,7 +420,7 @@ const handleExclusionsSearch = (dataToSearch, filters, variant, filterOptions) =
         charset: EnglishPreset,
         // encoder: encoder,
         encode: customEncoder,
-        tokenize: "strict",
+        tokenize: 'strict',
     });
     dataToSearch.forEach((item, id) => {
         index.add(id, item.title);
@@ -456,8 +486,7 @@ const filterLinkedElsewhereResults = (results, variantId) => {
                 parsedLinkedVariantIds = [];
             }
         }
-        const productLinkedElsewhere = parsedLinkedVariantIds.length > 0 &&
-            !parsedLinkedVariantIds.includes(variantId);
+        const productLinkedElsewhere = parsedLinkedVariantIds.length > 0 && !parsedLinkedVariantIds.includes(variantId);
         if (productLinkedElsewhere) {
             return false;
         }
@@ -596,37 +625,226 @@ export const calculateIgnoreStatus = (result, variant, result_ignore_keys) => {
     if (result_ignore_keys && result_ignore_keys.includes(resultKey)) {
         ignore = true;
     }
-    if (result.details_and_offers &&
-        result.details_and_offers.includes("Out of stock online")) {
+    if (result.details_and_offers && result.details_and_offers.includes('Out of stock online')) {
         ignore = true;
     }
     const refurbishedKeywords = [
-        "refurbished",
-        "renewed",
-        "reconditioned",
-        "refurb",
-        "remanufactured",
-        "scratch",
-        "dent",
-        "used",
+        '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 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"));
+        (result.details_and_offers && result.details_and_offers.includes('Pre-owned'));
     if (isRefurbished) {
         ignore = true;
     }
     return ignore;
 };
+export function calculateVisibility(hide_reasons, hide_override_reasons) {
+    if (!hide_reasons || hide_reasons.length === 0) {
+        // no reason to hide
+        return true;
+    }
+    if (hide_reasons.some((reason) => HIDE_ALWAYS_MAP[reason])) {
+        // has a reason that should always hide
+        return false;
+    }
+    if (!hide_override_reasons || hide_override_reasons.length === 0) {
+        // has reasons to hide, no overrides
+        return false;
+    }
+    // has reasons to hide, has overrides
+    return true;
+}
 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.17",
+    "version": "1.0.19",
     "description": "",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",