@isoftdata/svelte-ecommerce 1.0.0-beta.0

package/dist/data/ebay.d.ts

@@ -0,0 +1,11 @@
+import type { PackageType } from './types.js';
+export type LengthUnit = 'INCH' | 'FEET' | 'CENTIMETER' | 'METER';
+export type WeightUnit = 'POUND' | 'KILOGRAM' | 'OUNCE' | 'GRAM';
+export type TimeUnit = 'YEAR' | 'MONTH' | 'DAY' | 'HOUR' | 'CALENDAR_DAY' | 'BUSINESS_DAY';
+export interface EbayStaticData {
+    lengthUnits: LengthUnit[];
+    weightUnits: WeightUnit[];
+    timeUnits: TimeUnit[];
+    packageTypes: PackageType[];
+}
+export declare const ebayStaticData: EbayStaticData;

package/dist/data/ebay.js

@@ -0,0 +1,31 @@
+export const ebayStaticData = {
+    lengthUnits: ['INCH', 'FEET', 'CENTIMETER', 'METER'],
+    weightUnits: ['POUND', 'KILOGRAM', 'OUNCE', 'GRAM'],
+    timeUnits: ['YEAR', 'MONTH', 'DAY', 'HOUR', 'CALENDAR_DAY', 'BUSINESS_DAY'],
+    packageTypes: [
+        {
+            name: 'Bulky Goods',
+            partnerValue: 'BULKY_GOODS',
+        },
+        {
+            name: 'Letter',
+            partnerValue: 'LETTER',
+        },
+        {
+            name: 'Mailing Box',
+            partnerValue: 'MAILING_BOX',
+        },
+        {
+            name: 'Pallet',
+            partnerValue: 'ONE_WAY_PALLET',
+        },
+        {
+            name: 'Parcel or Padded Envelope',
+            partnerValue: 'PARCEL_OR_PADDED_ENVELOPE',
+        },
+        {
+            name: 'USPS Flat Rate Envelope',
+            partnerValue: 'USPS_FLAT_RATE_ENVELOPE',
+        },
+    ],
+};

package/dist/data/htp.d.ts

@@ -0,0 +1,9 @@
+import type { PackageType } from './types.js';
+export type LengthUnit = 'in' | 'cm' | 'm' | 'ft';
+export type WeightUnit = 'g' | 'lb' | 'kg' | 'oz';
+export interface HtpStaticData {
+    lengthUnits: LengthUnit[];
+    weightUnits: WeightUnit[];
+    packageTypes: PackageType[];
+}
+export declare const htpStaticData: HtpStaticData;

package/dist/data/htp.js

@@ -0,0 +1,22 @@
+export const htpStaticData = {
+    lengthUnits: ['in', 'cm', 'm', 'ft'],
+    weightUnits: ['g', 'lb', 'kg', 'oz'],
+    packageTypes: [
+        {
+            name: 'Box',
+            partnerValue: 'Box',
+        },
+        {
+            name: 'Envelope',
+            partnerValue: 'Envelope',
+        },
+        {
+            name: 'Letter',
+            partnerValue: 'Letter',
+        },
+        {
+            name: 'Pallet',
+            partnerValue: 'Pallet',
+        },
+    ]
+};

package/dist/data/index.d.ts

@@ -0,0 +1,4 @@
+export declare const ecommercePartnerStaticData: {
+    htp: import("./htp.js").HtpStaticData;
+    ebay: import("./ebay.js").EbayStaticData;
+};

package/dist/data/index.js

@@ -0,0 +1,6 @@
+import { htpStaticData } from './htp.js';
+import { ebayStaticData } from './ebay.js';
+export const ecommercePartnerStaticData = {
+    htp: htpStaticData,
+    ebay: ebayStaticData,
+};

package/dist/data/types.d.ts

@@ -0,0 +1,4 @@
+export interface PackageType {
+    name: string;
+    partnerValue: string;
+}

package/dist/data/types.js

@@ -0,0 +1 @@
+export {};

package/dist/helpers/index.d.ts

@@ -0,0 +1,3 @@
+export { validateInventoryListingDetails } from './validation.js';
+export { convertAndApplyTemplate, replaceInventoryTokens } from './template.js';
+export { buildEbayListing, processImageUrls } from './listing.js';

package/dist/helpers/index.js

@@ -0,0 +1,3 @@
+export { validateInventoryListingDetails } from './validation.js';
+export { convertAndApplyTemplate, replaceInventoryTokens } from './template.js';
+export { buildEbayListing, processImageUrls } from './listing.js';

package/dist/helpers/listing.d.ts

@@ -0,0 +1,22 @@
+import type { BuildEbayListingInput, FileItem, ImageUrl, InventoryListingDetail, NewInventoryListingDetail } from '../utils.js';
+/**
+ * Shared method for creating an inventorylistingdetail row
+ * Includes minimum validation and may return undefined if certain configuration settings determine the inventory item doesn't get a listing created
+ */
+export declare const buildEbayListing: (buildEbayListingInput: BuildEbayListingInput) => InventoryListingDetail | NewInventoryListingDetail | undefined;
+/**
+ * Accepts:
+ * the raw string of imageUrls from the listing, should be stringified json
+ * file list results from db
+ * Returns: stringified imageUrl list that can be tacked right onto the listing object for insert/update
+ *
+ * This function tries to compare the most recent file list for the inventory record with anything saved on the listing and:
+ * Filters for acceptable mime types
+ * Adds new items to the url array
+ * Updates existing items if rank or name changes
+ * Re-sorts to keep rank 1 at "top"
+ *
+ * TODO: need to make sure a specific type is used for file list so it's sharable
+ * TODO: I believe there's a max 12 image, probably have to account for that including returning a message if exceeded?
+ */
+export declare function processImageUrls(partFileList: FileItem[]): ImageUrl[] | null;

package/dist/helpers/listing.js

@@ -0,0 +1,324 @@
+import { convertAndApplyTemplate, validateInventoryListingDetails } from './index.js';
+import klona from 'klona';
+const newInventoryListingDetailTemplate = {
+    active: false,
+    convertedListingDetails: null,
+    duration: 'GTC',
+    ecommercePartnerId: 0,
+    ecommerceCategoryId: null,
+    ecommerceConditionId: null,
+    ecommerceConditionDescription: null,
+    fulfillmentTime: null,
+    fulfillmentTimeUnit: null,
+    imageUrls: [],
+    inventoryId: 0,
+    inventoryDescription: null,
+    lastUpdate: '',
+    listingDescription: null,
+    listingStatus: 'pending',
+    listingTitle: null,
+    manufacturerPartNumber: null,
+    message: [],
+    partnerSpecificDetails: {
+        brand: '',
+        listingFormat: 'FIXED_PRICE',
+        fulfillmentPolicy: [],
+        marketplaceId: 'EBAY_MOTORS',
+        merchantLocationKey: '',
+        oemNumber: '',
+        paymentPolicy: [],
+        returnPolicy: []
+    },
+    price: null,
+    quantity: null,
+    shippingLength: null,
+    shippingWidth: null,
+    shippingHeight: null,
+    shippingLengthUnit: null,
+    shippingPackage: null,
+    sku: null,
+    storeId: 0,
+    upc: '',
+    weight: null,
+    weightUnit: null
+};
+/**
+ * Shared method for creating an inventorylistingdetail row
+ * Includes minimum validation and may return undefined if certain configuration settings determine the inventory item doesn't get a listing created
+ */
+export const buildEbayListing = (buildEbayListingInput) => {
+    const { categoryMapping, conditionMapping, ecommercePartnerConfiguration, existingListing, inventoryRow, inventoryTypeListingDefaults, inventoryType, partFileList } = buildEbayListingInput;
+    if (!ecommercePartnerConfiguration) {
+        // No partner config, no listing
+        return;
+    }
+    const ecommercePartnerId = ecommercePartnerConfiguration.ecommercePartnerId;
+    // Check various fields/configs to determine if we should go skip creating the listing details
+    if (!inventoryRow.isWorldViewable) {
+        // Worldviewable is false, do not create listing row
+        return;
+    }
+    // TODO: this is problematic, we need to offer a way out of 'cancelled'
+    // Alternatively, build the listing anyway but keep the status?
+    if (existingListing && existingListing.listingStatus === 'cancelled') {
+        return;
+    }
+    // Is the ecommerce config set to active? 
+    if (ecommercePartnerConfiguration && !ecommercePartnerConfiguration.active) {
+        // Ecommerce config set to inactive
+        return;
+    }
+    // Is store mapped and active? 
+    const matchingStoreConfig = ecommercePartnerConfiguration?.defaults?.store?.find(store => store.storeId === inventoryRow.storeId);
+    if (!matchingStoreConfig) {
+        // No store/location configured, do not create listing row 
+        return;
+    }
+    if (matchingStoreConfig && !matchingStoreConfig.active) {
+        // Store configured to inactive, do not create listing row 
+        return;
+    }
+    // Check if part type + category configuration is inactive
+    if (shouldSkipListingDueToInactiveConfiguration(inventoryRow, inventoryTypeListingDefaults)) {
+        return; // Part type configuration set to inactive, do not create listing row
+    }
+    // TODO: consider the possibility of an override flag on the listing details
+    // Pull out the various levels of defaults, if they exist
+    const globalDefaults = ecommercePartnerConfiguration.defaults?.global;
+    const storeDefaults = ecommercePartnerConfiguration.defaults?.store?.find(row => row?.storeId === inventoryRow.storeId)?.defaults;
+    const partTypeDefaults = findMatchingPartTypeConfig(inventoryRow, inventoryTypeListingDefaults)?.defaults;
+    // Clone existing listing details or template to start
+    let listingDetails;
+    if (existingListing) {
+        listingDetails = klona(existingListing);
+        // Also, if partnerSpecificDetails doesn't exist, create it.  (Get weird type errors if we don't)
+        if (!listingDetails.partnerSpecificDetails || Object.keys(listingDetails.partnerSpecificDetails).length === 0) {
+            listingDetails.partnerSpecificDetails = {
+                brand: '',
+                listingFormat: 'FIXED_PRICE',
+                fulfillmentPolicy: [],
+                marketplaceId: 'EBAY_MOTORS',
+                merchantLocationKey: '',
+                oemNumber: '',
+                paymentPolicy: [],
+                returnPolicy: []
+            };
+        }
+    }
+    else {
+        listingDetails = klona(newInventoryListingDetailTemplate);
+    }
+    // Static
+    listingDetails.ecommercePartnerId = ecommercePartnerId;
+    listingDetails.partnerSpecificDetails.merchantLocationKey ?? listingDetails.partnerSpecificDetails.merchantLocationKey ?? matchingStoreConfig?.merchantLocationKey ?? null;
+    // Mapped
+    listingDetails.ecommerceCategoryId = listingDetails.ecommerceCategoryId
+        ? listingDetails.ecommerceCategoryId
+        : (categoryMapping?.ebayCategoryId ?? null);
+    // Use latest from inventory
+    // TODO: I'll need to check some of these, they may not allow changes on the config screen and inventory.* is the only truth avail
+    listingDetails.quantity = inventoryRow.quantity;
+    listingDetails.storeId = listingDetails.storeId || inventoryRow.storeId;
+    listingDetails.sku = listingDetails.sku || inventoryRow.tagNumber;
+    listingDetails.price = listingDetails.price || inventoryRow.retailPrice || null;
+    listingDetails.upc = listingDetails.upc ?? inventoryRow.upc ?? null;
+    listingDetails.weight = listingDetails.weight ?? inventoryRow.weight ?? null;
+    listingDetails.shippingHeight = listingDetails.shippingHeight ?? inventoryRow.shippingHeight ?? null;
+    listingDetails.shippingLength = listingDetails.shippingLength ?? inventoryRow.shippingLength ?? null;
+    listingDetails.shippingWidth = listingDetails.shippingWidth ?? inventoryRow.shippingWidth ?? null;
+    listingDetails.inventoryDescription = listingDetails.inventoryDescription ?? inventoryRow.description ?? null;
+    // For this MVP, we'll default to the existing listing info first (this would include any edits on the part config page, then part type, store, finally global or nothing)
+    // TODO: I suppose we could've made this easier by also having a defaults-shaped stringified json column on inventorylistingdetail
+    listingDetails.ecommerceConditionId = getFirstValidValue(listingDetails.ecommerceConditionId, partTypeDefaults?.conditionId, storeDefaults?.conditionId, globalDefaults?.conditionId);
+    listingDetails.ecommerceConditionDescription = getFirstValidValue(listingDetails.ecommerceConditionDescription, partTypeDefaults?.conditionDescription, storeDefaults?.conditionDescription, globalDefaults?.conditionDescription);
+    listingDetails.fulfillmentTime = getFirstValidValue(listingDetails.fulfillmentTime, partTypeDefaults?.fulfillmentTimeValue, storeDefaults?.fulfillmentTimeValue, globalDefaults?.fulfillmentTimeValue);
+    listingDetails.fulfillmentTimeUnit = getFirstValidValue(listingDetails.fulfillmentTimeUnit, partTypeDefaults?.fulfillmentTimeUnit, storeDefaults?.fulfillmentTimeUnit, globalDefaults?.fulfillmentTimeUnit);
+    listingDetails.partnerSpecificDetails.fulfillmentPolicy = getFirstValidArray(listingDetails.partnerSpecificDetails.fulfillmentPolicy, partTypeDefaults?.fulfillmentPolicies, storeDefaults?.fulfillmentPolicies, globalDefaults?.fulfillmentPolicies);
+    listingDetails.partnerSpecificDetails.paymentPolicy = getFirstValidArray(listingDetails.partnerSpecificDetails.paymentPolicy, partTypeDefaults?.paymentPolicies, storeDefaults?.paymentPolicies, globalDefaults?.paymentPolicies);
+    listingDetails.partnerSpecificDetails.returnPolicy = getFirstValidArray(listingDetails.partnerSpecificDetails.returnPolicy, partTypeDefaults?.returnPolicies, storeDefaults?.returnPolicies, globalDefaults?.returnPolicies);
+    listingDetails.shippingPackage = getFirstValidValue(listingDetails.shippingPackage, partTypeDefaults?.packageType, storeDefaults?.packageType, globalDefaults?.packageType);
+    listingDetails.weightUnit = getFirstValidValue(listingDetails.weightUnit, partTypeDefaults?.shippingWeightUnit, storeDefaults?.shippingWeightUnit, globalDefaults?.shippingWeightUnit);
+    listingDetails.shippingLengthUnit = getFirstValidValue(listingDetails.shippingLengthUnit, partTypeDefaults?.shippingLengthUnit, storeDefaults?.shippingLengthUnit, globalDefaults?.shippingLengthUnit);
+    // Handle Templates with same fallback pattern as above
+    listingDetails.partnerSpecificDetails.brand = getFirstValidTemplateValue(listingDetails.partnerSpecificDetails.brand, partTypeDefaults?.brandMapping, storeDefaults?.brandMapping, globalDefaults?.brandMapping, inventoryRow, inventoryType?.name);
+    listingDetails.listingTitle = getFirstValidTemplateValue(listingDetails.listingTitle, partTypeDefaults?.listingTitleTemplate, storeDefaults?.listingTitleTemplate, globalDefaults?.listingTitleTemplate, inventoryRow, inventoryType?.name);
+    listingDetails.listingDescription = getFirstValidTemplateValue(listingDetails.listingDescription, partTypeDefaults?.listingDescriptionTemplate, storeDefaults?.listingDescriptionTemplate, globalDefaults?.listingDescriptionTemplate, inventoryRow, inventoryType?.name);
+    listingDetails.manufacturerPartNumber = getFirstValidTemplateValue(listingDetails.manufacturerPartNumber, partTypeDefaults?.manufacturerPartNumberMapping, storeDefaults?.manufacturerPartNumberMapping, globalDefaults?.manufacturerPartNumberMapping, inventoryRow, inventoryType?.name);
+    listingDetails.partnerSpecificDetails.oemNumber = getFirstValidTemplateValue(listingDetails.partnerSpecificDetails.oemNumber, partTypeDefaults?.oemNumberMapping, storeDefaults?.oemNumberMapping, globalDefaults?.oemNumberMapping, inventoryRow, inventoryType?.name);
+    // Process image URLs if partFileList is provided
+    if (partFileList && partFileList.length > 0) {
+        const processedImageUrls = processImageUrls(partFileList);
+        listingDetails.imageUrls = processedImageUrls || [];
+    }
+    else {
+        // Ensure imageUrls is always an array
+        listingDetails.imageUrls = listingDetails.imageUrls || [];
+    }
+    // With all known fields set, validate for errors
+    const validationErrors = validateInventoryListingDetails(listingDetails);
+    // Set active, status and message props depending on validation result
+    if (validationErrors.length) {
+        listingDetails.listingStatus = 'error';
+        const errObj = {
+            type: "validation",
+            messages: validationErrors
+        };
+        listingDetails.message = [errObj];
+        listingDetails.active = false;
+    }
+    else {
+        // Clean up old messages
+        listingDetails.message = [];
+        // set to pending
+        listingDetails.active = true;
+        listingDetails.listingStatus = 'pending';
+    }
+    // TODO: In the old func there's an explicit reassignment for convertedListingDetails but shouldn't matter if we're cloning?
+    return listingDetails;
+};
+const getFirstValidArray = (...arrays) => {
+    return arrays.find(arr => arr != null && arr.length > 0) ?? [];
+};
+/**
+ * Returns the first non-null/undefined value from the provided arguments
+ */
+const getFirstValidValue = (...values) => {
+    return values.find(value => value != null) ?? null;
+};
+/**
+ * Returns the first valid template result using the fallback pattern:
+ * 1. Use existing value if it exists and is not empty
+ * 2. Try templates in order: partType -> store -> global
+ * 3. Return null if no valid template produces a result
+ */
+const getFirstValidTemplateValue = (existingValue, partTypeTemplate, storeTemplate, globalTemplate, inventoryRow, inventoryTypeName) => {
+    // If existing value exists and is not empty, use it
+    if (existingValue && existingValue.trim() !== '') {
+        return existingValue;
+    }
+    // Try templates in fallback order
+    const templates = [partTypeTemplate, storeTemplate, globalTemplate];
+    for (const template of templates) {
+        if (template) {
+            try {
+                const result = convertAndApplyTemplate({
+                    inventory: inventoryRow,
+                    inventoryTypeName,
+                    template
+                });
+                if (result && result.trim() !== '') {
+                    return result;
+                }
+            }
+            catch (error) {
+                // Log error but continue to next template
+                console.warn('Template processing error:', error);
+                continue;
+            }
+        }
+    }
+    return null;
+};
+/**
+ * Accepts:
+ * the raw string of imageUrls from the listing, should be stringified json
+ * file list results from db
+ * Returns: stringified imageUrl list that can be tacked right onto the listing object for insert/update
+ *
+ * This function tries to compare the most recent file list for the inventory record with anything saved on the listing and:
+ * Filters for acceptable mime types
+ * Adds new items to the url array
+ * Updates existing items if rank or name changes
+ * Re-sorts to keep rank 1 at "top"
+ *
+ * TODO: need to make sure a specific type is used for file list so it's sharable
+ * TODO: I believe there's a max 12 image, probably have to account for that including returning a message if exceeded?
+ */
+export function processImageUrls(partFileList) {
+    // Accepted image MIME types for eBay picture service
+    const acceptedMimeTypes = [
+        'image/avif',
+        'image/bmp',
+        'image/gif',
+        'image/heic',
+        'image/jpeg',
+        'image/jpg',
+        'image/png',
+        'image/tiff',
+        'image/tif',
+        'image/webp'
+    ];
+    // Create a new array that will only contain valid files
+    const updatedImageUrlArray = [];
+    // Process each file in the most recent partFileList results for an inventory item
+    for (const file of partFileList) {
+        // Check if the file has an accepted mimeType
+        if (!acceptedMimeTypes.includes(file.mimeType.toLowerCase())) {
+            continue; // Skip files with unsupported mimeTypes
+        }
+        // Check if the file is public (skip if public is false)
+        if (file.public === false) {
+            continue; // Skip files that are not public (removes them from existing list)
+        }
+        updatedImageUrlArray.push({
+            fileId: file.fileId,
+            fileName: file.name,
+            rank: file.rank ?? 0,
+            mimeType: file.mimeType
+        });
+    }
+    // Sort by rank to maintain order, presumably the "top" image in the list of images given to eBay for a listing is shown first
+    updatedImageUrlArray.sort((a, b) => a.rank - b.rank);
+    // Stringify it so we return it in same format it was received
+    return updatedImageUrlArray.length > 0 ? updatedImageUrlArray : null;
+}
+// TODO: pretty much identical to the next method, could probably have just combined and returned two things
+function findMatchingPartTypeConfig(inventoryRow, inventoryTypeListingDetails) {
+    // Early return if no configurations to check
+    if (!inventoryTypeListingDetails || inventoryTypeListingDetails.length === 0) {
+        return;
+    }
+    // Scenario 1: Single config with no category (applies to all categories)
+    if (inventoryTypeListingDetails.length === 1 && !inventoryTypeListingDetails[0].categoryId) {
+        return inventoryTypeListingDetails[0]; // Skip if inactive
+    }
+    const categoryMatch = inventoryTypeListingDetails.find(config => config.categoryName === inventoryRow.category);
+    if (categoryMatch) {
+        return categoryMatch;
+    }
+    // TODO: this one's iffy, double-check if types match reality, also make sure we can't have more than one
+    const allCategoryMatch = inventoryTypeListingDetails.find(config => config.categoryName === '');
+    if (allCategoryMatch) {
+        return allCategoryMatch;
+    }
+    return;
+}
+// Needed a separate method to check what I think are all of the ways we'd need to check 
+// part type
+function shouldSkipListingDueToInactiveConfiguration(inventoryRow, inventoryTypeListingDetails) {
+    // Early return if no configurations to check
+    if (!inventoryTypeListingDetails || inventoryTypeListingDetails.length === 0) {
+        return false; // No restrictions, continue processing
+    }
+    // Early return if inventory has no category
+    if (!inventoryRow.category) {
+        return true; // No category to match against, continue processing
+    }
+    // Scenario 1: Single config with no category (applies to all categories)
+    if (inventoryTypeListingDetails.length === 1 && !inventoryTypeListingDetails[0].categoryId) {
+        return !inventoryTypeListingDetails[0].active; // Skip if inactive
+    }
+    // Scenario 2 & 3: Multiple configs or single config with category
+    // Try to find exact category match first
+    const categoryMatch = inventoryTypeListingDetails.find(config => config.categoryName === inventoryRow.category);
+    if (categoryMatch) {
+        return !categoryMatch.active; // Skip if category match is inactive
+    }
+    // No exact category match - check if there's a "no category" fallback
+    const noCategoryConfig = inventoryTypeListingDetails.find(config => !config.categoryId);
+    if (noCategoryConfig) {
+        return !noCategoryConfig.active; // Skip if fallback is inactive
+    }
+    // No matching configuration found, continue processing
+    return false;
+}

package/dist/helpers/template.d.ts

@@ -0,0 +1,31 @@
+import type { InventoryRow, InventoryDetailsForTemplate } from "../utils.js";
+/**
+ *
+ * @param template Configured in ecommerce settings
+ * @returns a string with template values replaced by inventory values
+ * Convert product inventory row to a shared type for the token replacement
+ */
+export declare function convertAndApplyTemplate({ inventory, inventoryTypeName, template }: {
+    inventory: InventoryRow;
+    inventoryTypeName: string | null | undefined;
+    template: string | null | undefined;
+}): string | null;
+/**
+ * Replaces tokens in a template string with values from an inventory record
+ * @param template - The template string containing tokens like "{$PartType}"
+ * @param inventoryDetails - The inventory object containing values to replace tokens
+ * @returns The processed string with tokens replaced by values
+ *
+ * @example
+ * // Example usage:
+ * const template = "This is a {$PartType} made by {$Manufacturer}, model {$AssemblyModel}"
+ * const inventoryDetails = {
+ *   partType: "Engine",
+ *   manufacturer: "Toyota",
+ *   model: "2JZ-GTE"
+ * }
+ * const description = replaceInventoryTokens(template, inventoryDetails)
+ * // Result: "This is a Engine made by Toyota, model 2JZ-GTE"
+ * https://wikido.isoftdata.com//index.php?title=Ebay_templates
+ */
+export declare function replaceInventoryTokens(template: string, inventoryDetails: Partial<InventoryDetailsForTemplate>): string;

package/dist/helpers/template.js

@@ -0,0 +1,131 @@
+/**
+ *
+ * @param template Configured in ecommerce settings
+ * @returns a string with template values replaced by inventory values
+ * Convert product inventory row to a shared type for the token replacement
+ */
+export function convertAndApplyTemplate({ inventory, inventoryTypeName, template }) {
+    if (!template)
+        return null;
+    // Map the inventory object to the InventoryDetails type expected by replaceInventoryTokens
+    const mappedInventoryDetails = {
+        inventoryId: inventory.inventoryId,
+        vehicleMake: inventory.make || undefined,
+        vehicleModel: inventory.model || undefined,
+        year: inventory.year || undefined,
+        description: inventory.description || undefined,
+        price: inventory.retailPrice || undefined,
+        manufacturer: inventory.partManufacturer || undefined,
+        model: inventory.partModel || undefined,
+        partType: inventoryTypeName || undefined,
+        category: inventory.category || undefined,
+        store: inventory.storeId?.toString() || undefined,
+        tagNumber: inventory.tagNumber || undefined,
+        condition: inventory.condition || undefined,
+        flexLabel1: inventory.label1 || undefined,
+        flexLabel2: inventory.label2 || undefined,
+        flexLabel3: inventory.label3 || undefined,
+        flexLabel4: inventory.label4 || undefined,
+        flexValue1: inventory.data1 || undefined,
+        flexValue2: inventory.data2 || undefined,
+        flexValue3: inventory.data3 || undefined,
+        flexValue4: inventory.data4 || undefined,
+        oemNumber: inventory.oemNumber || undefined,
+        side: inventory.side || undefined,
+        serialNumber: inventory.serialNumber || undefined,
+        weight: inventory.weight || undefined,
+        upc: inventory.upc || undefined,
+        notes: inventory.notes || undefined,
+        quantity: inventory.quantity || undefined,
+        partManufacturer: inventory.partManufacturer || undefined,
+        partModel: inventory.partModel || undefined,
+    };
+    // Replace tokens in the template and set the listingDescription
+    return replaceInventoryTokens(template, mappedInventoryDetails);
+}
+/**
+ * Replaces tokens in a template string with values from an inventory record
+ * @param template - The template string containing tokens like "{$PartType}"
+ * @param inventoryDetails - The inventory object containing values to replace tokens
+ * @returns The processed string with tokens replaced by values
+ *
+ * @example
+ * // Example usage:
+ * const template = "This is a {$PartType} made by {$Manufacturer}, model {$AssemblyModel}"
+ * const inventoryDetails = {
+ *   partType: "Engine",
+ *   manufacturer: "Toyota",
+ *   model: "2JZ-GTE"
+ * }
+ * const description = replaceInventoryTokens(template, inventoryDetails)
+ * // Result: "This is a Engine made by Toyota, model 2JZ-GTE"
+ * https://wikido.isoftdata.com//index.php?title=Ebay_templates
+ */
+export function replaceInventoryTokens(template, inventoryDetails) {
+    if (!template)
+        return '';
+    if (!inventoryDetails)
+        return template;
+    // Define token mappings (token name -> inventory property)
+    const generalTokens = {
+        '{?InventoryID}': 'inventoryId',
+        '{?Make}': 'vehicleMake',
+        '{?Model}': 'model',
+        '{?Year}': 'year',
+        '{?Description}': 'description',
+        '{?Price}': 'price',
+        '{?Manufacturer}': 'manufacturer',
+        '{?AssemblyModel}': 'model',
+        '{?PartType}': 'partType',
+        '{?Category}': 'category',
+        '{?Store}': 'store',
+        '{?ProductCode}': 'productCode',
+        '{?TagNumber}': 'tagNumber',
+        '{?Condition}': 'condition',
+        '{?FlexLabel1}': 'flexLabel1',
+        '{?FlexLabel2}': 'flexLabel2',
+        '{?FlexLabel3}': 'flexLabel3',
+        '{?FlexLabel4}': 'flexLabel4',
+        '{?FlexValue1}': 'flexValue1',
+        '{?FlexValue2}': 'flexValue2',
+        '{?FlexValue3}': 'flexValue3',
+        '{?FlexValue4}': 'flexValue4',
+        '{?OEMNumber}': 'oemNumber',
+        '{?Side}': 'side'
+        // Add more mappings as needed
+    };
+    // Pro-specific token mappings
+    const proTokens = {
+        '{?PartNum}': 'inventoryId'
+    };
+    // Enterprise-specific token mappings, need to confirm these
+    const enterpriseTokenMappings = {
+        '{?PartNumber}': 'inventoryId', // not sure on this one, supposed to be vendor part number
+        '{?PartManufacturer}': 'partManufacturer',
+        '{?PartModel}': 'partModel'
+    };
+    // Combine all token mappings
+    const tokenMappings = {
+        ...generalTokens,
+        ...proTokens,
+        ...enterpriseTokenMappings
+    };
+    // Replace each token with its corresponding value
+    let result = template;
+    for (const [token, property] of Object.entries(tokenMappings)) {
+        // Create a global regex pattern to replace all occurrences
+        const tokenPattern = new RegExp(token.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g');
+        // Check if the property exists in inventoryDetails
+        if (inventoryDetails[property]) {
+            result = result.replace(tokenPattern, String(inventoryDetails[property]));
+        }
+        else {
+            // Replace with empty string if no match found
+            result = result.replace(tokenPattern, '');
+        }
+    }
+    // Second pass: replace any remaining tokens that weren't in our mapping with empty strings
+    // This handles tokens like {?MissingToken} that don't exist in our tokenMappings
+    result = result.replace(/\{\?[^}]+\}/g, '');
+    return result;
+}

package/dist/helpers/validation.d.ts

@@ -0,0 +1,2 @@
+import type { InventoryListingDetail, NewInventoryListingDetail } from '../index.js';
+export declare function validateInventoryListingDetails(listingDetails: InventoryListingDetail | NewInventoryListingDetail): string[];