@factorypure/client-helpers 1.0.0 → 1.0.2

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+export declare const scrapeResultsSchema: any;
+export type ScrapeResultsType = z.infer<typeof scrapeResultsSchema>;
+export type ScrapeFiltersType = {
+    found_id_exclusions: number[];
+    showHighPriceOutliers: boolean;
+    showLowPriceOutliers: boolean;
+    dayWindow: number | null;
+    competitor_exclusions: string[];
+    match_values: string[];
+    skip_skus: string[];
+    vendor_search_exclusions: string[];
+    search_exclusions: string[];
+};
+export type FilterOptionsType = {
+    exclude_linked_variants_enabled?: boolean;
+    found_id_exclusions_enabled?: boolean;
+    price_filter_enabled?: boolean;
+    date_filter_enabled?: boolean;
+    competitor_filter_enabled?: boolean;
+    duplicates_filter_enabled?: boolean;
+    search_index_enabled?: boolean;
+    skip_skus_enabled?: boolean;
+    wattage_exclusions_enabled?: boolean;
+    search_exclusions_enabled?: boolean;
+};
+export declare const filterScrapeResults: ({ scrapeResults, variant, filters, filterOptions, }: {
+    scrapeResults: ScrapeResultsType[];
+    variant: {
+        id: number;
+        title: string;
+        sku: string;
+        price: number;
+    };
+    filters: ScrapeFiltersType;
+    filterOptions?: FilterOptionsType;
+}) => z.infer<any>[];

package/dist/index.js

@@ -0,0 +1,256 @@
+import { subDays } from "date-fns";
+// @ts-ignore
+import { Index } from "flexsearch";
+// @ts-ignore
+import EnglishPreset from "flexsearch/lang/en";
+// @ts-ignore
+import { z } from "zod";
+export const scrapeResultsSchema = z.object({
+    id: z.number(),
+    scrape_id: z.number(),
+    variant_id: z.number(),
+    type: z.string(),
+    format: z.nullable(z.any()),
+    position: z.number(),
+    title: z.string(),
+    found_product_id: z.number(),
+    product_link: z.string(),
+    inline_link: z.nullable(z.any()),
+    immersive_product_page_token: z.string(),
+    serpapi_immersive_product_api: z.string(),
+    source: z.string(),
+    source_icon: z.string(),
+    multiple_sources: z.number(),
+    price: z.string(),
+    extracted_price: z.number(),
+    old_price: z.nullable(z.any()),
+    extracted_old_price: z.nullable(z.any()),
+    rating: z.nullable(z.any()),
+    reviews: z.nullable(z.any()),
+    snippet: z.nullable(z.any()),
+    thumbnail: z.string(),
+    serpapi_thumbnail: z.string(),
+    tag: z.nullable(z.any()),
+    extensions: z.nullable(z.any()),
+    delivery: z.nullable(z.any()),
+    created_at: z.string(),
+    store_id: z.number(),
+    match_score: z.number().nullable(),
+});
+const TOO_CHEAP_MULTIPLIER = 0.75;
+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,
+    found_id_exclusions_enabled: true,
+    price_filter_enabled: true,
+    date_filter_enabled: true,
+    competitor_filter_enabled: true,
+    duplicates_filter_enabled: true,
+    search_index_enabled: true,
+    skip_skus_enabled: true,
+    wattage_exclusions_enabled: true,
+    search_exclusions_enabled: true,
+}, }) => {
+    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.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);
+    }
+    return filteredResults;
+};
+const handleIndexSearch = (dataToSearch, filters, variant, filterOptions) => {
+    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;
+    const nots = [];
+    if (filters.skip_skus.length && filterOptions.skip_skus_enabled) {
+        const formatted = filters.skip_skus
+            .filter((sku) => sku.toLowerCase() !== sku.toLowerCase())
+            .map((sku) => ` ${sku} `);
+        nots.push(...formatted);
+    }
+    const lowerCaseTitle = title.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) {
+        wattagesToExclude.forEach((wattage) => {
+            nots.push(wattage);
+            nots.push(` ${wattage}w `);
+            // Push wattage with comma formatting for numbers over 999
+            if (Number(wattage) > 999) {
+                nots.push(Number(wattage).toLocaleString());
+            }
+        });
+    }
+    if (filters.search_exclusions.length &&
+        filterOptions.search_exclusions_enabled) {
+        nots.push(...filters.search_exclusions);
+    }
+    if (filters.vendor_search_exclusions.length &&
+        filterOptions.skip_skus_enabled) {
+        nots.push(...filters.vendor_search_exclusions.filter((sku) => sku.toLowerCase() !== sku.toLowerCase()));
+    }
+    if (title.toLowerCase().includes("dual fuel")) {
+        // nots.push('tri fuel', 'trifuel', 'tri-fuel')
+    }
+    let final = null;
+    let urlFinal = null;
+    searchTerms.forEach((term) => {
+        if (final === null && urlFinal === 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: 'Chipper',
+    //     resolve: false,
+    //     // suggest: true,
+    // })
+    // MUST INCLUDE SKU???
+    final = final.and({
+        index: index,
+        query: sku,
+        resolve: false,
+        suggest: true,
+    });
+    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]);
+    });
+    return resultsArray;
+};
+const filterLinkedElsewhereResults = (results, variantId) => {
+    const filtered = results.filter((result) => {
+        const productLinkedElsewhere = result.linked_variant_ids?.length > 0 &&
+            !result.linked_variant_ids.includes(variantId);
+        if (productLinkedElsewhere) {
+            return false;
+        }
+        return true;
+    });
+    return filtered;
+};
+const filterFoundProductIdExclusions = (results, found_id_exclusions) => {
+    const filtered = results.filter((item) => {
+        if (found_id_exclusions.length) {
+            if (found_id_exclusions.includes(item.found_product_id)) {
+                return false;
+            }
+        }
+        return true;
+    });
+    return filtered;
+};
+const filterPriceOutliers = (results, variantPrice, showHighPriceOutliers, showLowPriceOutliers) => {
+    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;
+        const itemDate = new Date(item.created_at);
+        const variantDate = subDays(new Date(), Number(dayWindow) || 7);
+        return itemDate >= variantDate;
+    });
+    return filtered;
+};
+const filterCompetitors = (results, competitor_exclusions) => {
+    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 filtered;
+};
+const filterDuplicateResults = (results) => {
+    const filteredUniqueResultsMap = {};
+    results.forEach((item) => {
+        const key = `${item.source}-${item.title}-${item.extracted_price}`;
+        if (!filteredUniqueResultsMap[key]) {
+            filteredUniqueResultsMap[key] = item;
+        }
+        else {
+            const existingItem = filteredUniqueResultsMap[key];
+            if (new Date(item.created_at) > new Date(existingItem.created_at)) {
+                filteredUniqueResultsMap[key] = item;
+            }
+        }
+    });
+    const filtered = Object.values(filteredUniqueResultsMap);
+    return filtered;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@factorypure/client-helpers",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -21,6 +21,7 @@
   "dependencies": {
     "@types/date-fns": "^2.5.3",
     "date-fns": "^4.1.0",
-    "flexsearch": "^0.8.212"
+    "flexsearch": "^0.8.212",
+    "zod": "^4.3.5"
   }
 }