@infigo-official/types-for-pricing-script 1.0.4 → 1.0.6

package/package.json

@@ -1,15 +1,16 @@
 {
   "name": "@infigo-official/types-for-pricing-script",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Type definitions for Pricing Script Scripting",
   "types": "v1/index.d.ts",
   "devDependencies": {
+    "http-server": "^14.1.1",
+    "typedoc": "^0.24.8",
     "typescript": "^4.9.5"
   },
   "scripts": {
-    "docs": "cd docusaurus-docs && npm install && npm run build",
-    "docs:dev": "cd docusaurus-docs && npm start",
-    "docs:build": "cd docusaurus-docs && npm run build"
+    "docs": "npx typedoc",
+    "start": "npx http-server docs -p 3000 -o"
   },
   "repository": {
     "type": "git",

package/v1/CheckoutItem/CheckoutItem.d.ts

@@ -213,9 +213,11 @@ declare interface CheckoutAddress {
  * The checkout item object available in checkout pricing scripts.
  * Represents comprehensive checkout information including all items being purchased,
  * customer details, shipping information, and checkout context.
- * 
+ *
  * This object provides complete checkout context for pricing calculations that
  * need to consider shipping, customer information, and multi-item scenarios.
+ *
+ * @category Global Objects
  */
 declare interface CheckoutItem {
     /**

package/v1/Configuration/Configuration.d.ts

@@ -12,6 +12,8 @@
 
 /**
  * Interface representing the configuration object.
+ *
+ * @category Global Objects
  */
 interface Configuration {
     /**

package/v1/Helpers/Helpers.d.ts

@@ -101,6 +101,8 @@ declare interface CsvHelper {
  * Helper methods available in pricing scripts for common calculations and data manipulation
  * These utilities extend the capabilities of pricing scripts and help create more flexible
  * and maintainable pricing logic.
+ *
+ * @category Helper Methods
  */
 declare interface HelperMethods {
     /**

package/v1/OrderItem/Item.d.ts

@@ -17,9 +17,11 @@
  * Represents the product variant being priced and provides access to all
  * product information, attributes, pricing data, and methods for file handling
  * and attribute management.
- * 
+ *
  * This object is the primary interface for accessing product data and performing
  * pricing calculations in pricing scripts.
+ *
+ * @category Global Objects
  */
 declare interface Item {
     /**
@@ -130,9 +132,13 @@ declare interface Item {
     /**
      * The weight of the item in the configured weight unit (typically grams or ounces).
      * This value is used for shipping calculations and weight-based pricing.
-     * 
+     *
      * @example
-     * var shippingCost = calculateShippingByWeight(Item.Weight);
+     * // Calculate shipping cost based on weight
+     * var weightInKg = Item.Weight / 1000;
+     * var shippingRate = 2.50; // $2.50 per kg
+     * var shippingCost = weightInKg * shippingRate;
+     * debug("Item weight: " + Item.Weight + "g, Shipping: $" + shippingCost);
      */
     Weight: number;
 
@@ -140,10 +146,12 @@ declare interface Item {
      * Indicates whether the weight can be set or modified for this item.
      * Some products may have fixed weights that cannot be changed,
      * while others allow weight adjustments based on attributes or custom settings.
-     * 
+     *
      * @example
-     * if (Item.CanSetWeight) {
-     *     // Allow weight adjustments in the UI
+     * if (Item.CanSetWeight && Item.Weight > 5000) {
+     *     debug("Heavy item detected - weight: " + Item.Weight + "g");
+     *     // Apply heavy item surcharge
+     *     return Item.Price + 10.00;
      * }
      */
     CanSetWeight: boolean;
@@ -152,9 +160,13 @@ declare interface Item {
      * The Stock Keeping Unit (SKU) of the product variant.
      * This is the unique identifier for the product variant and is used
      * for inventory management and order processing.
-     * 
+     *
      * @example
-     * var productIdentifier = Item.Sku;
+     * // Apply SKU-specific pricing rules
+     * if (Item.Sku.startsWith("PREMIUM-")) {
+     *     debug("Premium product: " + Item.Sku);
+     *     return Item.Price * 1.10; // 10% premium markup
+     * }
      */
     Sku: string;
 
@@ -162,36 +174,52 @@ declare interface Item {
      * The actual SKU based on the current attribute combination.
      * If no attributes are selected, this will be the same as the product SKU.
      * This value reflects the specific configuration of the product being priced.
-     * 
+     *
      * @example
-     * var configuredSku = Item.ActualSku;
+     * // Log the configured SKU for debugging
+     * debug("Base SKU: " + Item.Sku);
+     * debug("Configured SKU: " + Item.ActualSku);
+     * if (Item.ActualSku !== Item.Sku) {
+     *     debug("Product has attribute variations");
+     * }
      */
     ActualSku: string;
 
     /**
      * The width of the item in the configured dimension unit (typically inches or centimeters).
      * This value is used for packaging calculations and dimensional pricing.
-     * 
+     *
      * @example
-     * var packagingCost = calculatePackagingCost(Item.Width, Item.Height, Item.Length);
+     * // Calculate area-based pricing
+     * var area = Item.Width * Item.Height;
+     * var pricePerSquareUnit = 0.05;
+     * var areaCost = area * pricePerSquareUnit;
+     * debug("Area: " + area + " sq units, Cost: $" + areaCost);
      */
     Width: number;
 
     /**
      * The height of the item in the configured dimension unit (typically inches or centimeters).
      * This value is used for packaging calculations and dimensional pricing.
-     * 
+     *
      * @example
-     * var packagingCost = calculatePackagingCost(Item.Width, Item.Height, Item.Length);
+     * // Check if item is oversized
+     * if (Item.Height > 48) {
+     *     debug("Oversized item - adding handling fee");
+     *     return Item.Price + 25.00;
+     * }
      */
     Height: number;
 
     /**
      * The length of the item in the configured dimension unit (typically inches or centimeters).
      * This value is used for packaging calculations and dimensional pricing.
-     * 
+     *
      * @example
-     * var packagingCost = calculatePackagingCost(Item.Width, Item.Height, Item.Length);
+     * // Calculate volume for shipping
+     * var volume = Item.Width * Item.Height * Item.Length;
+     * var volumetricWeight = volume / 5000; // Standard divisor
+     * debug("Volumetric weight: " + volumetricWeight);
      */
     Length: number;
 
@@ -199,9 +227,14 @@ declare interface Item {
      * The name of the product as displayed to customers.
      * This is the human-readable product name used in the user interface
      * and order confirmations.
-     * 
+     *
      * @example
-     * var displayName = Item.ProductName;
+     * debug("Processing order for: " + Item.ProductName);
+     * // Check for special product names
+     * if (Item.ProductName.indexOf("Rush") >= 0) {
+     *     debug("Rush order product detected");
+     *     return Item.Price * 1.50; // 50% rush fee
+     * }
      */
     ProductName: string;
 
@@ -265,101 +298,261 @@ declare interface Item {
 
     /**
      * Whether this is a batch job
+     *
+     * @example
+     * if (Item.IsBatch) {
+     *     debug("Processing batch job with " + Item.NumberOfRecords + " records");
+     *     var batchSetupFee = 25.00;
+     *     return Item.Price + batchSetupFee;
+     * }
      */
     IsBatch: boolean;
 
     /**
      * Number of pages (-1 if not valid)
+     *
+     * @example
+     * if (Item.NumberOfPages > 0) {
+     *     var perPageCost = 0.10;
+     *     var pageCost = Item.NumberOfPages * perPageCost;
+     *     debug("Document has " + Item.NumberOfPages + " pages, adding $" + pageCost);
+     *     return Item.Price + pageCost;
+     * }
      */
     NumberOfPages: number;
 
     /**
      * Number of records (-1 if not valid)
+     *
+     * @example
+     * if (Item.NumberOfRecords > 0) {
+     *     var perRecordCost = 0.05;
+     *     var recordCost = Item.NumberOfRecords * perRecordCost;
+     *     debug("Batch has " + Item.NumberOfRecords + " records");
+     *     return Item.Price + recordCost;
+     * }
      */
     NumberOfRecords: number;
 
     /**
      * Array of pricing tiers with Price, Quantity, and CustomerRole
+     *
+     * @example
+     * // Find the best tier for the current quantity
+     * var tier = HelperMethods.FindTier(Item.Quantity, Item.PricingTiers, Item.CustomerRoles);
+     * if (tier) {
+     *     debug("Using tier: " + tier.Quantity + " @ $" + tier.Price);
+     *     return tier.Price * Item.Quantity;
+     * }
      */
     PricingTiers: Tier[];
 
     /**
      * Array of batch tiers (same as PricingTiers but for batch tier table)
+     *
+     * @example
+     * if (Item.IsBatch && Item.BatchTiers.length > 0) {
+     *     var batchTier = HelperMethods.FindTier(Item.NumberOfRecords, Item.BatchTiers);
+     *     if (batchTier) {
+     *         debug("Batch tier price: $" + batchTier.Price);
+     *     }
+     * }
      */
     BatchTiers: Tier[];
 
     /**
      * Price per record (-1 if not valid)
+     *
+     * @example
+     * if (Item.PricePerRecord > 0 && Item.NumberOfRecords > 0) {
+     *     var recordTotal = Item.PricePerRecord * Item.NumberOfRecords;
+     *     debug("Record pricing: " + Item.NumberOfRecords + " x $" + Item.PricePerRecord);
+     *     return recordTotal;
+     * }
      */
     PricePerRecord: number;
 
     /**
      * Array of attributes with Key, Value, IsRequired, Prompt, PriceAdjustment, etc.
+     *
+     * @example
+     * // Loop through all attributes and apply price adjustments
+     * var totalAdjustment = 0;
+     * for (var i = 0; i < Item.Attributes.length; i++) {
+     *     var attr = Item.Attributes[i];
+     *     debug("Attribute: " + attr.Key + " = " + attr.Value);
+     *     totalAdjustment += attr.PriceAdjustment || 0;
+     * }
+     * return Item.Price + totalAdjustment;
      */
     Attributes: Attribute[];
 
     /**
      * User email
+     *
+     * @example
+     * // Apply corporate discount for company emails
+     * if (Item.Email.endsWith("@mycompany.com")) {
+     *     debug("Corporate customer: " + Item.Email);
+     *     return Item.Price * 0.85; // 15% corporate discount
+     * }
      */
     Email: string;
 
     /**
      * Array of customer role system names
+     *
+     * @example
+     * // Check for wholesale pricing
+     * if (Item.CustomerRoles.indexOf("Wholesale") >= 0) {
+     *     debug("Wholesale customer detected");
+     *     return Item.Price * 0.70; // 30% wholesale discount
+     * } else if (Item.CustomerRoles.indexOf("VIP") >= 0) {
+     *     return Item.Price * 0.90; // 10% VIP discount
+     * }
      */
     CustomerRoles: string[];
 
     /**
      * Department name of user
+     *
+     * @example
+     * // Apply department-specific pricing
+     * if (Item.Department === "Marketing") {
+     *     debug("Marketing department order");
+     *     return Item.Price * 0.80; // 20% marketing discount
+     * } else if (Item.Department === "Sales") {
+     *     return Item.Price * 0.75; // 25% sales discount
+     * }
      */
     Department: string;
 
     /**
      * Array of other order items using the same custom pricing script
+     *
+     * @example
+     * // Calculate total quantity across all cart items for volume discount
+     * var totalQty = Item.Quantity;
+     * for (var i = 0; i < Item.OtherOrderItems.length; i++) {
+     *     totalQty += Item.OtherOrderItems[i].Quantity;
+     * }
+     * debug("Total quantity in cart: " + totalQty);
      */
     OtherOrderItems: Item[];
 
     /**
      * Alias of OtherOrderItems
+     *
+     * @example
+     * // Apply cart-wide discount if total exceeds threshold
+     * var cartTotal = 0;
+     * for (var i = 0; i < Item.CartItems.length; i++) {
+     *     cartTotal += Item.CartItems[i].Price * Item.CartItems[i].Quantity;
+     * }
+     * if (cartTotal > 500) {
+     *     debug("Cart total $" + cartTotal + " - applying 10% discount");
+     *     return Item.Price * 0.90;
+     * }
      */
     CartItems: Item[];
 
     /**
      * Index of this item in the other order item array (0 if not in array)
+     *
+     * @example
+     * // Apply setup fee only to first item
+     * if (Item.OrderItemIndex === 0) {
+     *     debug("First item - adding setup fee");
+     *     return Item.Price + 15.00;
+     * }
      */
     OrderItemIndex: number;
 
     /**
      * Index of this item in the other order item array (-1 if not in array)
+     *
+     * @example
+     * if (Item.CartItemIndex >= 0) {
+     *     debug("This is cart item #" + (Item.CartItemIndex + 1));
+     * }
      */
     CartItemIndex: number;
 
     /**
      * Whether this item is in the other order item array
+     *
+     * @example
+     * if (Item.IsInOtherOrderItems) {
+     *     debug("Item is part of multi-item order");
+     *     // Consider other items for bundle pricing
+     * }
      */
     IsInOtherOrderItems: boolean;
 
     /**
      * Value of the currently used discount code
+     *
+     * @example
+     * // Apply special discount for specific codes
+     * if (Item.DiscountCode === "SUMMER20") {
+     *     debug("Summer sale discount applied");
+     *     return Item.Price * 0.80; // 20% off
+     * } else if (Item.DiscountCode === "VIP50") {
+     *     return Item.Price * 0.50; // 50% off
+     * }
      */
     DiscountCode: string;
 
     /**
      * Array of versions with JobId, CustomName, and Quantity
+     *
+     * @example
+     * // Calculate pricing across all versions
+     * if (Item.Versions.length > 0) {
+     *     debug("Job has " + Item.Versions.length + " versions");
+     *     for (var i = 0; i < Item.Versions.length; i++) {
+     *         var ver = Item.Versions[i];
+     *         debug("Version: " + ver.CustomName + ", Qty: " + ver.Quantity);
+     *     }
+     * }
      */
     Versions: ItemVersion[];
 
     /**
      * Number of versions
+     *
+     * @example
+     * if (Item.NumberOfVersions > 1) {
+     *     debug("Multi-version job with " + Item.NumberOfVersions + " versions");
+     *     // Apply version discount
+     *     return Item.Price * 0.95; // 5% multi-version discount
+     * }
      */
     NumberOfVersions: number;
 
     /**
      * Whether this is a version of a job
+     *
+     * @example
+     * if (Item.IsVersion) {
+     *     debug("This item is a version of an existing job");
+     *     // Use version-specific pricing logic
+     * }
      */
     IsVersion: boolean;
 
     /**
      * Sum of all quantities of all versions
+     *
+     * @example
+     * // Use total version quantity for tier pricing
+     * if (Item.VersionsSumQuantity > 0) {
+     *     var tier = HelperMethods.FindTier(Item.VersionsSumQuantity, Item.PricingTiers);
+     *     if (tier) {
+     *         debug("Using combined version quantity: " + Item.VersionsSumQuantity);
+     *         return tier.Price;
+     *     }
+     * }
      */
     VersionsSumQuantity: number;
 

package/v1/Output/Output.d.ts

@@ -15,9 +15,10 @@
  * Output a debug message to the user interface.
  * Debug messages are typically used during development and troubleshooting
  * to provide detailed information about script execution and calculations.
- * 
+ *
+ * @category Output Functions
  * @param message - The debug message to display to the user
- * 
+ *
  * @example
  * debug("Calculating price for item: " + Item.ProductName);
  * debug("Base price: $" + Item.Price + ", Quantity: " + Item.Quantity);
@@ -28,9 +29,10 @@ declare function debug(message: string): void;
  * Output an alert message to the user interface.
  * Alert messages are used to display important information that requires
  * user attention, such as pricing changes or special offers.
- * 
+ *
+ * @category Output Functions
  * @param message - The alert message to display to the user
- * 
+ *
  * @example
  * alert("Special pricing applied: 20% discount for bulk orders");
  * alert("Price updated based on selected attributes");
@@ -41,9 +43,10 @@ declare function alert(message: string): void;
  * Output a warning message to the user interface.
  * Warning messages are used to notify users about potential issues
  * or important considerations that may affect their pricing.
- * 
+ *
+ * @category Output Functions
  * @param message - The warning message to display to the user
- * 
+ *
  * @example
  * warning("Large file detected - processing may take longer");
  * warning("Some attributes may affect shipping costs");
@@ -54,9 +57,10 @@ declare function warning(message: string): void;
  * Output an error message to the user interface.
  * Error messages are used to inform users about calculation failures
  * or other issues that prevent normal pricing execution.
- * 
+ *
+ * @category Output Functions
  * @param message - The error message to display to the user
- * 
+ *
  * @example
  * error("Unable to calculate price - missing required attributes");
  * error("File processing failed - please check file format");
@@ -67,9 +71,10 @@ declare function error(message: string): void;
  * Output a message to the browser console/logs.
  * Console messages are used for debugging purposes and are typically
  * only visible to developers in the browser's developer tools.
- * 
+ *
+ * @category Output Functions
  * @param message - The message to log to the console
- * 
+ *
  * @example
  * console("Script execution started");
  * console("Final calculated price: $" + finalPrice);

package/v1/SessionItem/Session.d.ts

@@ -13,9 +13,11 @@
  * The session object available in pricing scripts.
  * Represents session-level data and provides access to customer information
  * and shopping cart items that are available during the current session.
- * 
+ *
  * This object provides session-wide context for pricing calculations that
  * may need to consider multiple items or customer session data.
+ *
+ * @category Global Objects
  */
 declare interface Session {
     /**