@factorypure/client-helpers 1.0.14 → 1.0.16

package/dist/index.d.ts

@@ -28,7 +28,25 @@ export type FilterOptionsType = {
     search_exclusions_enabled?: boolean;
     exclude_ignored_keys_enabled?: boolean;
 };
-export declare const filterScrapeResults: ({ scrapeResults, variant, filters, filterOptions, }: {
+export declare const HIDE_REASONS: {
+    IGNORED: string;
+    HIGH_PRICE_OUTLIER: string;
+    LOW_PRICE_OUTLIER: string;
+    DATE_OUTLIER: string;
+    COMPETITOR_EXCLUSION: string;
+    DUPLICATE: string;
+    SEARCH_EXCLUSION: string;
+    CALCULATED_SKU_MISMATCH: string;
+    CRITICAL_SPEC_MISMATCH: string;
+    MANUALLY_IGNORED: string;
+    OUT_OF_STOCK_ONLINE: string;
+    REFURBISHED_USED: string;
+    SKIP_SKU: string;
+    VENDOR_EXCLUSION: 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, }: {
     scrapeResults: ScrapeResultsType[];
     variant: {
         id: number;
@@ -39,6 +57,7 @@ export declare const filterScrapeResults: ({ scrapeResults, variant, filters, fi
     };
     filters: ScrapeFiltersType;
     filterOptions?: FilterOptionsType;
+    globalScrapeOptions?: any;
 }) => z.infer<any>[];
 export declare const calculateIgnoreStatus: (result: ScrapeResultsType, variant: {
     id: number;

package/dist/index.js

@@ -37,8 +37,24 @@ export const scrapeResultsSchema = z.object({
     store_id: z.number(),
     match_score: z.number().nullable(),
 });
-const TOO_CHEAP_MULTIPLIER = 0.75;
-const TOO_EXPENSIVE_MULTIPLIER = 1.25;
+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",
+};
+export const TOO_CHEAP_MULTIPLIER = 0.75;
+export const TOO_EXPENSIVE_MULTIPLIER = 1.25;
 const wattages = Array.from({ length: 41 }, (_, i) => (5000 + i * 500).toString());
 export const filterScrapeResults = ({ scrapeResults, variant, filters, filterOptions = {
     exclude_linked_variants_enabled: true,
@@ -52,32 +68,35 @@ export const filterScrapeResults = ({ scrapeResults, variant, filters, filterOpt
     wattage_exclusions_enabled: true,
     search_exclusions_enabled: true,
     exclude_ignored_keys_enabled: false,
-}, }) => {
+}, globalScrapeOptions, }) => {
     let filteredResults = scrapeResults;
-    if (filterOptions.exclude_linked_variants_enabled) {
-        filteredResults = filterLinkedElsewhereResults(filteredResults, variant.id);
-    }
-    if (filterOptions.found_id_exclusions_enabled) {
-        filteredResults = filterFoundProductIdExclusions(filteredResults, filters.found_id_exclusions);
-    }
-    if (filterOptions.exclude_ignored_keys_enabled) {
-        filteredResults = filterIgnoredResults(filteredResults);
-    }
-    if (filterOptions.price_filter_enabled) {
-        filteredResults = filterPriceOutliers(filteredResults, variant.price, filters.showHighPriceOutliers, filters.showLowPriceOutliers);
-    }
-    if (filterOptions.date_filter_enabled) {
-        filteredResults = filterDateWindow(filteredResults, filters.dayWindow);
-    }
-    if (filterOptions.competitor_filter_enabled) {
-        filteredResults = filterCompetitors(filteredResults, filters.competitor_exclusions);
-    }
-    if (filterOptions.duplicates_filter_enabled) {
-        filteredResults = filterDuplicateResults(filteredResults);
-    }
-    if (filterOptions.search_index_enabled) {
-        filteredResults = handleIndexSearch(filteredResults, filters, variant, filterOptions);
-    }
+    // if (filterOptions.exclude_linked_variants_enabled) {
+    //     filteredResults = filterLinkedElsewhereResults(filteredResults, variant.id)
+    // }
+    // if (filterOptions.found_id_exclusions_enabled) {
+    //     filteredResults = filterFoundProductIdExclusions(filteredResults, filters.found_id_exclusions)
+    // }
+    // if (filterOptions.exclude_ignored_keys_enabled) {
+    // filteredResults = filterIgnoredResults(filteredResults)
+    // }
+    // if (filterOptions.price_filter_enabled) {
+    filteredResults = filterPriceOutliers(filteredResults, variant.price, globalScrapeOptions);
+    // }
+    // if (filterOptions.date_filter_enabled) {
+    filteredResults = filterDateWindow(filteredResults, filters.dayWindow);
+    // }
+    // if (filterOptions.competitor_filter_enabled) {
+    filteredResults = filterCompetitors(filteredResults, filters.competitor_exclusions);
+    // }
+    // if (filterOptions.duplicates_filter_enabled) {
+    filteredResults = filterDuplicateResults(filteredResults);
+    // }
+    // if (filterOptions.search_index_enabled) {
+    filteredResults = handleExclusionsSearch(filteredResults, filters, variant, filterOptions);
+    filteredResults = handleSkipSkuSearch(filteredResults, filters, variant, filterOptions);
+    filteredResults = handleVendorExclusions(filteredResults, filters, variant, filterOptions);
+    // filteredResults = handleIndexSearch(filteredResults, filters, variant, filterOptions)
+    // }
     return filteredResults;
 };
 const handleIndexSearch = (dataToSearch, filters, variant, filterOptions) => {
@@ -104,6 +123,29 @@ const handleIndexSearch = (dataToSearch, filters, variant, filterOptions) => {
         index.add(id, item.title);
     });
     const searchTerms = filters.match_values;
+    let final = null;
+    searchTerms.forEach((term) => {
+        if (final === null) {
+            final = index.search(term, {
+                resolve: false,
+                suggest: true,
+            });
+        }
+        else {
+            final = final.or({
+                index: index,
+                query: term,
+                resolve: false,
+                suggest: true,
+            });
+        }
+    });
+    final = final.and({
+        index: index,
+        query: sku,
+        resolve: false,
+        suggest: true,
+    });
     const nots = [];
     if (filters.skip_skus.length && filterOptions.skip_skus_enabled) {
         const formatted = filters.skip_skus
@@ -142,10 +184,221 @@ const handleIndexSearch = (dataToSearch, filters, variant, filterOptions) => {
     if (title.toLowerCase().includes("dual fuel")) {
         // nots.push('tri fuel', 'trifuel', 'tri-fuel')
     }
+    nots.forEach((term) => {
+        final = final.not({
+            index: index,
+            query: term,
+            resolve: false,
+        });
+    });
+    const result = final.resolve({ limit: 1000 });
+    const resultsArray = [];
+    result.forEach((i) => {
+        resultsArray.push(dataToSearch[i]);
+    });
+    for (let index = 0; index < dataToSearch.length; index++) {
+        const element = dataToSearch[index];
+        if (!result.includes(index)) {
+            if (!element.hide_reasons) {
+                element.hide_reasons = [];
+            }
+            element.hide_reasons.push(HIDE_REASONS.SEARCH_EXCLUSION);
+        }
+    }
+    return dataToSearch;
+};
+const handleVendorExclusions = (dataToSearch, filters, variant, filterOptions) => {
+    if (!filters.skip_vendors || filters.skip_vendors.length === 0) {
+        return dataToSearch;
+    }
+    const { title, sku } = variant;
+    function customEncoder(content) {
+        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 words = cleanedStr2.split(/\s+/);
+        for (let word of words) {
+            tokens.push(word);
+        }
+        return tokens;
+    }
+    const index = new Index({
+        charset: EnglishPreset,
+        // encoder: encoder,
+        encode: customEncoder,
+        tokenize: "strict",
+    });
+    dataToSearch.forEach((item, id) => {
+        index.add(id, item.title);
+    });
+    const searchTerms = filters.match_values;
     let final = null;
-    let urlFinal = null;
     searchTerms.forEach((term) => {
-        if (final === null && urlFinal === null) {
+        if (final === null) {
+            final = index.search(term, {
+                resolve: false,
+                suggest: true,
+            });
+        }
+        else {
+            final = final.or({
+                index: index,
+                query: term,
+                resolve: false,
+                suggest: true,
+            });
+        }
+    });
+    final = final.and({
+        index: index,
+        query: sku,
+        resolve: false,
+        suggest: true,
+    });
+    const nots = [];
+    if (filters.skip_vendors.length && filterOptions.skip_vendors_enabled) {
+        const formatted = filters.skip_vendors
+            .filter((vendor) => vendor.toLowerCase() !== variant.vendor.toLowerCase())
+            .map((vendor) => ` ${vendor} `);
+        nots.push(...formatted);
+    }
+    nots.forEach((term) => {
+        final = final.not({
+            index: index,
+            query: term,
+            resolve: false,
+        });
+    });
+    const result = final.resolve({ limit: 1000 });
+    const resultsArray = [];
+    result.forEach((i) => {
+        resultsArray.push(dataToSearch[i]);
+    });
+    for (let index = 0; index < dataToSearch.length; index++) {
+        const element = dataToSearch[index];
+        if (!result.includes(index)) {
+            if (!element.hide_reasons) {
+                element.hide_reasons = [];
+            }
+            element.hide_reasons.push(HIDE_REASONS.VENDOR_EXCLUSION);
+        }
+    }
+    return dataToSearch;
+};
+const handleSkipSkuSearch = (dataToSearch, filters, variant, filterOptions) => {
+    // if (
+    //     (!filters.skip_skus || filters.skip_skus.length === 0) &&
+    //     (!filters.vendor_search_exclusions || filters.vendor_search_exclusions.length === 0)
+    // ) {
+    //     return dataToSearch
+    // }
+    const { title, sku } = variant;
+    function customEncoder(content) {
+        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 words = cleanedStr2.split(/\s+/);
+        for (let word of words) {
+            tokens.push(word);
+        }
+        return tokens;
+    }
+    const index = new Index({
+        charset: EnglishPreset,
+        // encoder: encoder,
+        encode: customEncoder,
+        tokenize: "strict",
+    });
+    dataToSearch.forEach((item, id) => {
+        index.add(id, item.title);
+    });
+    const searchTerms = filters.match_values;
+    let final = null;
+    searchTerms.forEach((term) => {
+        if (final === null) {
+            final = index.search(term, {
+                resolve: false,
+                suggest: true,
+            });
+        }
+        else {
+            final = final.or({
+                index: index,
+                query: term,
+                resolve: false,
+                suggest: true,
+            });
+        }
+    });
+    final = final.and({
+        index: index,
+        query: sku,
+        resolve: false,
+        suggest: true,
+    });
+    const nots = [];
+    const formatted = filters.skip_skus
+        .filter((sku) => sku.toLowerCase() !== variant.sku.toLowerCase())
+        .map((sku) => ` ${sku} `);
+    nots.push(...formatted);
+    nots.push(...filters.vendor_search_exclusions.filter((sku) => sku.toLowerCase() !== variant.sku.toLowerCase()));
+    nots.forEach((term) => {
+        final = final.not({
+            index: index,
+            query: term,
+            resolve: false,
+        });
+    });
+    const result = final.resolve({ limit: 1000 });
+    const resultsArray = [];
+    result.forEach((i) => {
+        resultsArray.push(dataToSearch[i]);
+    });
+    for (let index = 0; index < dataToSearch.length; index++) {
+        const element = dataToSearch[index];
+        if (!result.includes(index)) {
+            if (!element.hide_reasons) {
+                element.hide_reasons = [];
+            }
+            element.hide_reasons.push(HIDE_REASONS.SKIP_SKU);
+        }
+    }
+    return dataToSearch;
+};
+const handleExclusionsSearch = (dataToSearch, filters, variant, filterOptions) => {
+    if (!filters.search_exclusions || filters.search_exclusions.length === 0) {
+        return dataToSearch;
+    }
+    const { title, sku } = variant;
+    function customEncoder(content) {
+        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 words = cleanedStr2.split(/\s+/);
+        for (let word of words) {
+            tokens.push(word);
+        }
+        return tokens;
+    }
+    const index = new Index({
+        charset: EnglishPreset,
+        // encoder: encoder,
+        encode: customEncoder,
+        tokenize: "strict",
+    });
+    dataToSearch.forEach((item, id) => {
+        index.add(id, item.title);
+    });
+    const searchTerms = filters.match_values;
+    let final = null;
+    searchTerms.forEach((term) => {
+        if (final === null) {
             final = index.search(term, {
                 resolve: false,
                 suggest: true,
@@ -160,19 +413,14 @@ const handleIndexSearch = (dataToSearch, filters, variant, filterOptions) => {
             });
         }
     });
-    // final = final.and({
-    //     index: index,
-    //     query: 'Chipper',
-    //     resolve: false,
-    //     // suggest: true,
-    // })
-    // MUST INCLUDE SKU???
     final = final.and({
         index: index,
         query: sku,
         resolve: false,
         suggest: true,
     });
+    const nots = [];
+    nots.push(...filters.search_exclusions);
     nots.forEach((term) => {
         final = final.not({
             index: index,
@@ -185,7 +433,16 @@ const handleIndexSearch = (dataToSearch, filters, variant, filterOptions) => {
     result.forEach((i) => {
         resultsArray.push(dataToSearch[i]);
     });
-    return resultsArray;
+    for (let index = 0; index < dataToSearch.length; index++) {
+        const element = dataToSearch[index];
+        if (!result.includes(index)) {
+            if (!element.hide_reasons) {
+                element.hide_reasons = [];
+            }
+            element.hide_reasons.push(HIDE_REASONS.SEARCH_EXCLUSION);
+        }
+    }
+    return dataToSearch;
 };
 const filterLinkedElsewhereResults = (results, variantId) => {
     const filtered = results.filter((result) => {
@@ -220,48 +477,89 @@ const filterFoundProductIdExclusions = (results, found_id_exclusions) => {
     return filtered;
 };
 const filterIgnoredResults = (results) => {
-    const filtered = results.filter((item) => {
-        return item.ignore_result ? false : true;
+    results.forEach((item) => {
+        if (!item.hide_reasons) {
+            item.hide_reasons = [];
+        }
+        if (item.ignore_result) {
+            item.hide_reasons.push(HIDE_REASONS.IGNORED);
+        }
     });
-    return filtered;
+    // const filtered = results.filter((item) => {
+    //     return item.ignore_result ? false : true
+    // })
+    return results;
 };
-const filterPriceOutliers = (results, variantPrice, showHighPriceOutliers, showLowPriceOutliers) => {
-    const filtered = results.filter((item) => {
-        const showMoreExpensive = showHighPriceOutliers === true;
+const filterPriceOutliers = (results, variantPrice, globalScrapeOptions) => {
+    results.forEach((item) => {
+        if (!item.hide_reasons) {
+            item.hide_reasons = [];
+        }
+        const too_cheap_multiplier = getUndercutThreshold(variantPrice, globalScrapeOptions.undercut_threshold_ranges || []);
         const isMoreExpensive = item.extracted_price > variantPrice * TOO_EXPENSIVE_MULTIPLIER;
-        const showTooCheap = showLowPriceOutliers === true;
-        const isTooCheap = item.extracted_price < variantPrice * TOO_CHEAP_MULTIPLIER;
-        if (isMoreExpensive && !showMoreExpensive) {
-            return false;
+        const isTooCheap = item.extracted_price < variantPrice * too_cheap_multiplier;
+        if (isMoreExpensive) {
+            item.hide_reasons.push(HIDE_REASONS.HIGH_PRICE_OUTLIER);
         }
-        if (isTooCheap && !showTooCheap) {
-            return false;
+        if (isTooCheap) {
+            item.hide_reasons.push(HIDE_REASONS.LOW_PRICE_OUTLIER);
         }
-        return true;
     });
+    const filtered = results;
+    // const filtered = results.filter((item) => {
+    //     const showMoreExpensive = showHighPriceOutliers === true
+    //     const isMoreExpensive = item.extracted_price > variantPrice * TOO_EXPENSIVE_MULTIPLIER
+    //     const showTooCheap = showLowPriceOutliers === true
+    //     const isTooCheap = item.extracted_price < variantPrice * TOO_CHEAP_MULTIPLIER
+    //     if (isMoreExpensive && !showMoreExpensive) {
+    //         return false
+    //     }
+    //     if (isTooCheap && !showTooCheap) {
+    //         return false
+    //     }
+    //     return true
+    // })
     return filtered;
 };
 const filterDateWindow = (results, dayWindow) => {
-    const filtered = results.filter((item) => {
-        if (!dayWindow)
-            return true;
+    results.forEach((item) => {
+        if (!item.hide_reasons) {
+            item.hide_reasons = [];
+        }
         const itemDate = new Date(item.created_at);
-        const variantDate = startOfDay(subDays(new Date(), Number(dayWindow) || 7));
-        return itemDate >= variantDate;
+        const variantDate = startOfDay(subDays(new Date(), Number(dayWindow) || 3));
+        if (itemDate < variantDate) {
+            item.hide_reasons.push(HIDE_REASONS.DATE_OUTLIER);
+        }
     });
-    return filtered;
+    // const filtered = results.filter((item) => {
+    //     if (!dayWindow) return true
+    //     const itemDate = new Date(item.created_at)
+    //     const variantDate = startOfDay(subDays(new Date(), Number(dayWindow) || 7))
+    //     return itemDate >= variantDate
+    // })
+    return results;
 };
 const filterCompetitors = (results, competitor_exclusions) => {
-    const filtered = results.filter((item) => {
+    results.forEach((item) => {
+        if (!item.hide_reasons) {
+            item.hide_reasons = [];
+        }
         const lowerSource = item.source.toLowerCase();
-        for (const exclusion of competitor_exclusions) {
-            if (exclusion && lowerSource === exclusion.toLowerCase()) {
-                return false;
-            }
+        if (competitor_exclusions.some((exclusion) => exclusion && lowerSource === exclusion.toLowerCase())) {
+            item.hide_reasons.push(HIDE_REASONS.COMPETITOR_EXCLUSION);
         }
-        return true;
     });
-    return filtered;
+    // const filtered = results.filter((item) => {
+    //     const lowerSource = item.source.toLowerCase()
+    //     for (const exclusion of competitor_exclusions) {
+    //         if (exclusion && lowerSource === exclusion.toLowerCase()) {
+    //             return false
+    //         }
+    //     }
+    //     return true
+    // })
+    return results;
 };
 const filterDuplicateResults = (results) => {
     const filteredUniqueResultsMap = {};
@@ -273,12 +571,24 @@ const filterDuplicateResults = (results) => {
         else {
             const existingItem = filteredUniqueResultsMap[key];
             if (new Date(item.created_at) > new Date(existingItem.created_at)) {
+                const foundResult = results.find((res) => res.id === existingItem.id);
+                if (foundResult) {
+                    if (!foundResult.hide_reasons) {
+                        foundResult.hide_reasons = [];
+                    }
+                    foundResult.hide_reasons.push(HIDE_REASONS.DUPLICATE);
+                }
                 filteredUniqueResultsMap[key] = item;
             }
+            else {
+                if (!item.hide_reasons) {
+                    item.hide_reasons = [];
+                }
+                item.hide_reasons.push(HIDE_REASONS.DUPLICATE);
+            }
         }
     });
-    const filtered = Object.values(filteredUniqueResultsMap);
-    return filtered;
+    return results;
 };
 export const calculateIgnoreStatus = (result, variant, result_ignore_keys) => {
     let ignore = false;
@@ -316,3 +626,7 @@ export const calculateIgnoreStatus = (result, variant, result_ignore_keys) => {
     }
     return ignore;
 };
+function getUndercutThreshold(price, undercutThresholdRanges) {
+    const range = undercutThresholdRanges.find((r) => price >= r.min && price <= r.max);
+    return range ? range.threshold : 0.75; // fallback default
+}

package/package.json

@@ -1,27 +1,27 @@
 {
-  "name": "@factorypure/client-helpers",
-  "version": "1.0.14",
-  "description": "",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "files": [
-    "dist"
-  ],
-  "type": "module",
-  "scripts": {
-    "build": "tsc",
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "devDependencies": {
-    "typescript": "^5.6.2"
-  },
-  "dependencies": {
-    "@types/date-fns": "^2.5.3",
-    "date-fns": "^4.1.0",
-    "flexsearch": "^0.8.212",
-    "zod": "^4.3.5"
-  }
+    "name": "@factorypure/client-helpers",
+    "version": "1.0.16",
+    "description": "",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "files": [
+        "dist"
+    ],
+    "type": "module",
+    "scripts": {
+        "build": "tsc",
+        "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "keywords": [],
+    "author": "",
+    "license": "ISC",
+    "devDependencies": {
+        "typescript": "^5.6.2"
+    },
+    "dependencies": {
+        "@types/date-fns": "^2.5.3",
+        "date-fns": "^4.1.0",
+        "flexsearch": "^0.8.212",
+        "zod": "^4.3.5"
+    }
 }