Bolder — Components Reference

Auto-generated on 2026-07-07 · 70 modules · 47 components · JS API guide

Cart

accept_terms widget: cart_settings
Requires the customer to check a terms-and-conditions checkbox before the cart submit button is enabled.
termsUrlURL to the terms page
messageIntroductory label text
linkTextAnchor text for the terms link
containerCSS selector for the cart container
Bootic.load('AcceptTerms', {
  termsUrl: '/pages/terminos',
  container: '.bootic_cart'
})
Manages the dynamic add-to-cart button state, including quantity increase/decrease controls, stock limit enforcement, volume discount notices, and quote flow support.
productIdID of the product to manage
formSelectorCSS selector for add_to_cart forms (default: `.add_to_cart`)
Bootic.load('AddToCartButton', {
  formSelector: '.add_to_cart'
})
Scans the page for product forms marked with `data-add-to-cart` and initialises the appropriate add-to-cart component (button, dynamic variant selector, or options panel) based on each form's data attributes.
containerRoot element to scan (default: `document.body`)
productItemSelectorCSS selector for individual product items
Bootic.load('AddToCartLoader', {
  container: '.products'
})
Shows a slide-out drawer or inline panel for products that require variant selection before adding to cart (e.g. products with size or color options). Loads the product form dynamically and handles variant selection and quantity.
productUrlURL to fetch the product options form from
containerCSS selector or element to render the options panel into
Smoothly animates a numeric counter from its current value to a new target value with an easing effect. This module is called programmatically via `Bootic.call` rather than configured with options.
Bootic.require('AnimateNumber', function(err, anim) {
  anim.to(el, 42)
})
Displays a cart preview modal or slide-out panel when a product is added to the cart. Renders the live cart contents including line items, totals, and a checkout link.
showOnAddOpen the modal automatically after adding a product (default: true)
triggerSelectorCSS selector for elements that open the cart modal on click
Presents a contact form modal so a customer can request a formal quote for the current cart contents instead of placing a direct order.
formUrlURL of the quote request endpoint
triggerSelectorCSS selector for the button that opens the quote form
Bootic.load('CartQuote', {
  formUrl: '/orders/quote',
  triggerSelector: '.request-quote'
})
cart_rules widget: cart_requirements
Exposes shop-configured order requirements to other modules that need to look one up directly — currently just AddToCartButton, which caps a product's quantity stepper against a matching max_units_per_product requirement before it's ever added to the cart. Cart-page validation (disabling checkout, showing which requirements aren't met) is no longer done here: it's now declarative, computed by cart-decorator.js/cart-rules.js (the shared core module) inside cart-table-v3's beforeUpdate() and dynamic_cart_table.js's renderCart(), and rendered directly by the cart-table templates — see cart_action_buttons in cart-table-v3/template.qiq and cart-table/template.qiq.
requirementsShop's configured order requirements (widgets.cart_requirements)
Bootic.load('CartRules', { requirements: [...] })
Sends cart event data (add, remove, checkout) to the Bootic tracking endpoint for analytics and remarketing purposes. No user-facing options required.
Bootic.load('CartTracking', {
})
Updates item quantities in the cart in real time via AJAX without a page reload. Attaches increment/decrement controls to quantity inputs and syncs with the cart API. Emits cart update events that other modules (CartModal, CartBadge) can listen to.
Upgrades static add-to-cart forms to dynamic AJAX buttons that add items without a page reload, updating button state to reflect in-cart status.
formSelectorCSS selector for cart forms (default: `.add_to_cart`)
requireDeliverySetupPrompt for delivery address before adding (default: false)
Bootic.load('DynamicCartButtons', {
  formSelector: '.add_to_cart'
})
Renders and keeps the cart table in sync with live cart state. Handles quantity changes, item removal, promo codes, shipping estimates, and related product suggestions.
containerIdID of the cart table wrapper (default: `dynamic-cart-table`)
showRelatedShow related product suggestions (default: false)
Bootic.load('DynamicCartTable', {
  containerId: 'dynamic-cart-table'
})
Updates displayed prices, comparison prices, and stock status in real time when variant or quantity selections change. Also handles volume discount tier displays.
productContainerCSS selector wrapping each product (default: `.product`)
showComparisonPriceShow strikethrough comparison price (default: true)
Bootic.load('DynamicPrices', {
  productContainer: '.product'
})
Adds increase/decrease quantity controls to in-cart item rows, updating totals live via the Cart API without a page reload.
formSelectorCSS selector for cart item forms (default: `.add_to_cart`)
Bootic.load('DynamicQuantityButtons', {
})

Products

Updates price, availability status, and images in real time when a customer selects a product variant (size, color, etc.). Reads variant data from the product JSON endpoint and applies changes to the surrounding product form without a page reload.
productIdThe product ID to load variant data for
variantSelectorCSS selector for the variant option inputs
priceSelectorCSS selector for the price display element
updateImagesSwap to the variant's image on selection (default: true)
favorites widget: favorites
Lets customers save products to a favourites list, storing them locally or server-side when logged in, and toggles heart/star icons on product cards accordingly. When a logged-in session starts, locally-stored favourites are synced to the server automatically.
mainContainerProducts wrapper selector whose children are scanned for product cards (default: `.products`)
requireLoginShow a login prompt before saving a favourite when the customer is not logged in (default: true)
Bootic.load('Favorites', {
  mainContainer: '.products',
  requireLogin: false
})
Adds a CSS zoom effect to a product image on hover or touch, loading a higher-resolution version. An optional magnifier mode (WebGL) can be enabled via the `mode` option.
imageElementThe img element to make zoomable
bigImageURL of the high-resolution image to display when zooming (defaults to the parent anchor's href)
Bootic.load('ImageZoom', {
  imageElement: document.getElementById('main-img'),
  bigImage: '{{ product.image | resize: "1000x" }}'
})
Shows a modal form where customers can subscribe to receive an email notification when an out-of-stock product is restocked. Optionally fetches and displays the product's variant list in the form.
linkSelectorCSS selector for the trigger button(s) that open the modal (default: `[data-notify-restocked]`)
includeVariantsFetch and display a variant selector inside the subscription form (default: false)
Bootic.load('NotifyRestocked', {
  linkSelector: '.notify-btn',
  includeVariants: true
})
product_comparison_picker widget: compare_products_picker
Lets customers select 2–4 products to compare side by side, rendering a checkbox on each product card and navigating to the comparison page once enough products are chosen. Products of different types cannot be mixed in the same comparison.
mainContainerProducts wrapper selector (default: `.products`)
maxComparableMaximum number of products that can be selected for comparison (default: 4)
Bootic.load('ProductComparisonPicker', {
  mainContainer: '.products',
  maxComparable: 3
})
Handles faceted product filtering: listens for changes on filter form inputs and selects, then submits the form via AJAX and replaces the product list without a full page reload, optionally updating the browser URL.
formSelectorCSS selector for the filter form element
resultsContainerCSS selector for the element where AJAX results are injected
Bootic.load('ProductFilters', {
  formSelector: '#product-filters',
  resultsContainer: '#search-results'
})
Manages the main product image viewer: clicking a thumbnail swaps the main image with a fade/spinner transition, and optionally activates zoom on the displayed image.
mainContainerWrapper selector that contains both the main image and thumbnails (default: `.product-images`)
bigImageContainerSelector for the main image anchor element (default: `.main-image`)
thumbSelectorSelector for thumbnail link elements (default: `.product-image`)
enableZoomEnable image zoom; pass `'magnifier'` for WebGL magnifier mode (default: false)
<div class="product-images">
  <!-- main-image's href will be the image used for zooming -->
  <!-- nested img's src is the "small" one that is shown without zoom -->
  {% for image in product.images limit:1 %}
  <a class="main-image" href="{{ image | resize: '1000x' }}">
    <img src="{{ image | resize: '690x' }}" alt="{{ product.model }}" />
  </a>
  {% endfor %}
  {% if product.image_count > 1 %}
  <ul class="image-thumbs">
    {% for image in product.images %}
    <li>
      <a class="product-image{% for v in image.variants %} image-for-variant-{{ v.id }}{% endfor %}" title="{{ product.model }}"
         href="{{ image | resize: '1000x' }}" data-show-img="{{ image | resize: '690x' }}">
        <img src="{{ image.thumbnail }}" alt="{{ product.model }}" />
      </a>
    </li>
    {% endfor %}
  </ul>
  {% endif %}
</div>
Bootic.load('ProductImages', {
  mainContainer: '.product-images',
  bigImageContainer: '.main-image',
  thumbSelector: '.product-image',
  enableZoom: true
})
 // and optionally, we can load the VariantImages module
 // we need to make sure the thumbSelector in both modules
 // match, and that those nodes contain the 'image-for-variant-xxx' class
 Bootic.load('VariantImages', {
   imageSelector: '.product-image' // should match the one above
 })
Opens a product detail page inside a modal overlay when a product link is clicked, keeping the customer on the listing page and setting a URL hash for shareability.
selectorCSS selector for product links that trigger the modal (default: `.product-link`)
containerParent selector used to scope link event delegation (default: document.body)
Bootic.load('ProductModal', {
  selector: '.product-link',
  container: '.products'
})
product_promotions widget: promotions_info
Fetches and displays active promotion details (discount conditions, savings amount, and related product groups) for the products currently in view, updating dynamically as the cart changes.
containerElement containing the promotion card markup to scan and initialise
Bootic.load('ProductPromotions', {
  container: document.querySelector('.product')
})
products_lists_modal widget: combine_products_by_volume_discount
Opens a modal listing products that qualify for a volume discount or matching bundle, letting customers browse and add items directly from the overlay.
selectorCSS selector for the trigger elements
matchMethodMethod used to match products (required)
Bootic.load('ProductsListModal', {
  selector: '.view-bundle-products',
  matchMethod: 'volume_discount'
})
Switches the displayed product images when the customer selects a different variant (size, colour, etc.), highlighting images tagged with the chosen variant's ID. Also triggers a click on the matching thumbnail so the main image viewer updates when ProductImages is active.
containerRoot element to scan for variant inputs and images (default: document.body)
variantsContainerCSS selector for the variant inputs wrapper (default: `.cart_variants`)
imageSelectorCSS selector for product image elements (default: `.product-image`)
Bootic.load('VariantImages', {
  container: '.product',
  imageSelector: '.product-image'
})

Checkout

Enhances an address text input with Google Places-powered autocomplete suggestions, auto-filling region and locality fields on selection.
inputThe address input element
countryISO country code to bias results, e.g. `"CL"`
onChangeCallback receiving the parsed address components
Bootic.load('AddressAutocomplete', {
  input: document.querySelector('#address'),
  country: 'CL'
})
Populates region and locality `<select>` fields from the delivery API based on the selected country code.
regionSelectThe region select element
localitySelectThe locality select element
countryCodeISO country code (default: `"CL"`)
Bootic.load('AddressFields', {
  regionSelect: document.querySelector('#region'),
  localitySelect: document.querySelector('#locality')
})
Combines customer authentication and delivery address selection into a single unified flow component, mounting automatically into a managed container.
Bootic.load('AuthDelivery', {})
Shows a modal listing available store locations so the customer can select a branch for pickup or delivery.
triggerSelectorCSS selector for the trigger button
changeBranchMessageHeading text inside the modal
Bootic.load('ChooseBranchModal', {
  triggerSelector: '.choose-branch'
})
delivery_setup widget: delivery_setup
Opens a modal that guides the customer through selecting their delivery method (shipping or pickup) and address before adding items to the cart.
showAutomaticallyOpen on first visit (default: false)
triggerSelectorCSS selector for manual trigger links
Bootic.load('DeliverySetup', {
  showAutomatically: true
})
Formats and validates Chilean RUT (tax ID) inputs in real time as the customer types, automatically applying dots and a dash in the correct positions.
inputSelectorCSS selector for RUT input fields (default: input[data-rut])
Bootic.load('RutFormatter', { inputSelector: 'input.rut-field' })
Opens the shipping calculator component in a modal so the customer can estimate shipping costs before checkout.
triggerSelectorCSS selector for the "calculate shipping" link
countryDefault country code
Bootic.load('ShippingCosts', {
  triggerSelector: '.shipping-costs-link'
})

Search


UI

Manages beta user mode in the storefront. - Injects a dismissible "Beta" ribbon badge in the top-left corner when beta mode is active. - Wires `data-toggle-beta` elements for toggling beta mode on/off via AJAX. - Shows toast notifications confirming the change.
<a href="/beta/toggle" data-toggle-beta>Toggle Beta</a>
Detects exit-intent behaviour (mouse leaving the viewport towards the top) and invokes a callback, useful for triggering a last-chance offer or modal.
callbackFunction to call when exit intent is detected
sensitivityVertical pixel threshold for detection (default: 20)
delayMilliseconds to wait before activating the listener (default: 0)
cookieDaysDays to suppress the callback after first trigger (default: 7)
Bootic.load('Bounce', {
  callback: function() { Bootic.load('WelcomeModal', { always_show: true }) },
  delay: 3000,
  cookieDays: 3
})
Displays a live countdown to a target date/time, updating days, hours, minutes, and seconds every second. Optionally shows a "finished" message when the countdown reaches zero.
selectorCSS selector for countdown elements (default: `.countdown`)
containerRoot element to scope selector
timeISO date string for the target time, overrides `data-time` attribute
Bootic.load('CountdownTimer', {
  selector: '.countdown',
  container: '#content'
})
Loads and plays Lottie JSON animations on page elements, supporting event-triggered playback (hover, click, scroll).
selectorCSS selector for animation containers (default: `[data-animation]`)
animateOnTrigger event: `"hover"`, `"click"`, or `"scroll"`
Bootic.load('LottieAnimations', {
  selector: '.lottie'
})
Map integration — embed Leaflet or Google Maps for address input and delivery zone display. Access via: Bootic.call('Map', 'init', opts, callback)
Modal dialogs — create and manage overlay popups. Access via: Bootic.call('Modal', 'methodName', args, callback)
Top-of-page notification bar — display and listen for page-level notices. Access via: Bootic.call('Notice', 'methodName', args, callback)
Intercepts clicks on internal page links (collections, pages, tags) and loads the target page inside a modal overlay instead of navigating away.
linkSelectorCSS selector for intercepted links (default: `[data-page-modal]`)
Bootic.load('PageModal', {
  linkSelector: '[data-page-modal]'
})
Displays an inline promotion notice (applied discounts and free shipping status) in a designated banner element whenever the cart is updated.
templateIdID of the Liquid template used to render the notice (default: bootic-top-promo-template)
Bootic.load('PromoNotice', {})
Shows toast notifications when promotions are applied to or removed from the cart, displaying the discount name and amount saved.
Bootic.load('PromoToasts', {})
Renders a styled price-range slider input for filter forms.
inputSelectorCSS selector for the range input elements
minMinimum value
maxMaximum value
Bootic.load('RangeSlider', {
  inputSelector: 'input[type=range]'
})
Auto-generates a sticky or inline navigation menu from page `<section>` elements, inserting anchor links into `.bootic-section-menu` placeholders.
sectionSelectorCSS selector for sections (default: `section`)
stickyMake the menu sticky (default: false)
Bootic.load('SectionMenus', {})
Activates the browser's native Web Share API on a designated share button, falling back gracefully if the API is unavailable.
titleShare title
descriptionShare description text
Bootic.load('ShareButton', {
  title: document.title,
  description: '{{ product.description | strip_tags | truncate: 100 }}'
})
spin_wheel widget: spin_wheel
Renders a spin-the-wheel prize game with configurable prize tiers, probabilities, and coupon code rewards.
itemsPrize items, each with `label`, `probability`, and optional `coupon_code` and `coupon_label`
triggerSelectorCSS selector for the spin trigger button
Bootic.load('SpinWheel', {
  items: [{ probability: 30, label: '10% OFF', coupon_code: '10OFF' }, { probability: 70, label: 'Mejor suerte la próxima' }]
})
Cycles through a list of text messages in a container, fading each in and out on a configurable interval.
containerCSS selector for the ticker element
messagesList of strings to cycle through
waitSeconds between messages (default: 6)
includeEmptyInclude a pause with empty text (default: false)
Bootic.load('Ticker', {
  container: '.news-ticker',
  messages: ['Free shipping on orders over $50!', 'New arrivals every week']
})
Toast notifications — brief, auto-dismissing alerts in a corner of the page. Access via: Bootic.call('Toasts', 'show', opts)
Fetches an arbitrary internal URL and renders its content inside a modal overlay.
linkSelectorCSS selector for trigger links (default: `.show-promos-link`)
urlURL to load inside the modal
Bootic.load('ViewModal', {
  linkSelector: '.show-promos-link'
})
welcome_modal widget: welcome_popup
Shows a welcome pop-up modal on first visit (using a cookie to avoid repeat displays), optionally including a newsletter subscribe form or promotional image and message.
show_subscribe_formShow a newsletter subscription form in the modal (default: false)
subscribe_form_tagLiquid form tag name to render inside the modal
delaySeconds to wait before showing the modal (default: 3)
always_showShow on every visit regardless of cookie (default: false)
Bootic.load('WelcomeModal', {
  show_subscribe_form: true,
  subscribe_form_tag: 'subscribe_form',
  delay: 5
})

User

user_menu widget: active_user_menu
Renders the customer account drop-down menu with links to orders, profile, and favourites when the customer is logged in, or a login prompt when logged out.
triggerSelectorCSS selector for the menu toggle button (default: `.user-menu-toggle`)
menuContainerCSS selector for the menu target container (default: `.user-menu-container-target`)
Bootic.load('UserMenu', {
  triggerSelector: '.user-menu-toggle',
  menuContainer: '.user-menu'
})
Renders a customer registration / sign-in form component inside a specified container, handling submission, validation errors, and post-login redirects.
formContainerCSS selector for the container to render the form into
formUrlURL to submit the registration form to
Bootic.load('UserSignup', {
  formContainer: '#signup-container',
  formUrl: '/customer/register'
})

Misc

Loads the next page of products or blog posts via AJAX and appends them to the current page without a full reload. Works with both numbered pagination and "load more" style buttons.
containerCSS selector for the element to append results into
paginationSelectorCSS selector for the pagination links wrapper
Fetches a Liquid template partial asynchronously via AJAX and injects its HTML into a target element, with optional timezone-aware scheduling and query-param forwarding.
nameName of the partial template to fetch
targetCSS selector for the container to inject content into
paramsQuery parameters to pass to the partial endpoint
currentParamsForward the current page's query string to the partial (default: false)
Bootic.load('AsyncPartial', {
  name: 'promotions',
  target: '#promo-container'
})
Provides a consolidated API for the Buyer/Customer Console UI
Renders a floating contact widget with links to WhatsApp, email, phone, Telegram, Twitter, and other configured channels.
twitterTwitter handle
facebookFacebook page ID
telegramTelegram username
emailContact email address
smsSMS phone number
callClick-to-call phone number
Bootic.load('ContactWidget', {
  email: 'hola@tienda.com',
  call: '+56912345678',
  telegram: 'mitienda'
})
Loads and displays customer comments and a feedback form for the current page, connecting to the Bootic comments service.
containerCSS selector for the feedback container
templateIdID of the Liquid template used to render comments (default: `feedback-template`)
Bootic.load('Feedback', {
  container: '#comments'
})
Defers loading of images and iframes until they scroll near the viewport, replacing `data-src` with `src` using IntersectionObserver.
selectorCSS selector for lazy elements (default: `.lazy`)
containerRoot container (default: `document`)
rootMarginIntersectionObserver root margin (default: `"0px"`)
Bootic.load('Lazyload', {
  selector: '.lazy'
})
Bridges the web storefront with Bootic's native mobile app WebView by detecting the Capacitor runtime and adding platform-specific CSS classes to the body element.
Bootic.load('NativeClient', {})
Embeds a PDF file viewer inside the page using a PDF.js-based renderer. Sets minimum dimensions on the container if needed.
pdfUrlURL of the PDF file to display
containerCSS selector for the viewer container element
Bootic.load('PdfViewer', {
  pdfUrl: '/assets/catalogue.pdf',
  container: '#pdf-viewer'
})
Renders an interactive Google Map with markers for each store branch location. Requires branches to have latitude/longitude coordinates set.
containerCSS selector for the map container element
placesArray of branch objects with address.latlong coordinates
Bootic.load('PlacesMap', {
  container: '#store-map',
  places: {{ shop.branches | json }}
})
Sends an anonymous shop-visit beacon to Bootic analytics on every page load. No configuration required.
Bootic.load('ShopVisits', {})
Initialises embedded video players supporting direct video files and HLS (.m3u8) streams found in page content.
selectorCSS selector for video elements to initialise (default: 'video')
containerCSS selector or element scoping the search for video elements
Bootic.load('StreamingVideos', { container: '.product-description' })

Components

Custom Elements and Vue components. base components are bundled. on demand components load only when their element appears in the page.

Renders the add-to-cart form with variant selectors and quantity controls using a QiQ template. Supports product bundles, modifiers, subscription fees, volume discounts, and dynamic variant selection.
product_idID of the product to render the form for
button_typeVisual style of the add-to-cart button (e.g. 'normal', 'icon')
with_variantsWhether to display variant selectors (default: false)
available_variant_idID of the pre-selected available variant
Bootic.components.render('add-to-cart', containerEl, {
  product_id: 123,
  button_type: 'normal',
  with_variants: true,
  available_variant_id: 456
}, function(node) { ... })
age-verification on demand widget: age_verification
Renders a full-screen age verification gate that requires visitors to confirm they are of legal age before accessing the store. On confirmation the gate fades out after a brief success message; on denial it displays a rejection message with a redirect button.
logoUrlURL of the store logo displayed on the gate (default: '')
logoAltAlt text for the store logo (default: 'Logo')
questionAge-check question shown to the visitor (default: '¿Eres mayor de edad?')
yesButtonTextLabel for the confirm/yes button (default: 'Sí')
noButtonTextLabel for the deny/no button (default: 'No')
bottomTextFine-print text shown beneath the buttons (default: 'Para ingresar a nuestro sitio...')
termsTextClickable terms-and-conditions link text (default: 'términos y condiciones')
termsLinkURL for the terms-and-conditions page (default: undefined)
primaryColorAccent colour used for buttons and highlights (default: '#ff4000')
darkModeEnable dark colour scheme (default: false)
successTitleHeading shown after the visitor confirms their age (default: '¡Perfecto!')
successMessageBody text shown after confirmation (default: 'Bienvenido a nuestra tienda...')
successDelayMilliseconds to display the success screen before dismissing the gate (default: 1800)
rejectionTitleHeading shown when the visitor denies their age (default: '¡Ups! Eres muy joven aún')
rejectionMessageBody text shown on denial (default: 'Vuelve cuando seas mayor de edad...')
redirectUrlURL the visitor is sent to when they click the redirect button after denial (default: 'https://www.disney.com')
redirectButtonTextLabel for the redirect button shown on denial (default: 'Ir a Disney')
onVerifyCallback invoked after the gate is dismissed; receives no arguments (default: no-op)
Bootic.components.render('age-verification', containerEl, {
  logoUrl: 'https://myshop.com/logo.png',
  logoAlt: 'My Shop',
  primaryColor: '#c00000',
  successDelay: 2000
}, function(node) { ... })
Renders the combined authentication and delivery address selection flow. Guides customers through login/account creation and then delivery method and address setup in a modal.
welcomeTitleTitle displayed on the welcome/login step
apiAPI methods for authentication and delivery (auth + delivery methods)
validProvidersNames of OAuth providers to enable (e.g. ['google', 'facebook'])
Bootic.components.render('auth-delivery', containerEl, {
  welcomeTitle: 'Welcome back!',
  api: authAndDeliveryApi,
  validProviders: ['google']
}, function(node) { ... })
biggy-slider on demand
Renders a full-width hero image/content slider using Swiper with autoplay, navigation arrows, and pagination dots support.
autoplayAuto-advance slides (default: false)
intervalMilliseconds between slide transitions (default: 4000)
loopLoop from the last slide back to the first (default: true)
Bootic.components.render('biggy-slider', el, { autoplay: true, interval: 5000 })
Renders a product bundle option selector letting customers choose components or variants for each bundle slot. Validates that all required slots are filled and syncs selections back to the add-to-cart form.
productIdID of the bundle product
optionsArray of bundle option objects describing each slot and its available items
Bootic.components.render('bundle-option-configurator', containerEl, {
  productId: 123,
  options: bundleOptions
}, function(node) { ... })
Renders available promotion codes and discount summaries within the cart. Displays an optional promo code input field and shows applied discounts.
showApplyPromoShow the promo code input field (default: true)
Bootic.components.render('cart-promos', containerEl, {
  showApplyPromo: true
}, function(node) { ... })
Renders the full cart table with line items, quantity controls, item removal, subtotals, and a checkout button. Supports an optional progress gauge showing how far a customer is from a free-shipping threshold.
show_cart_gaugeShow the free-shipping progress gauge (default: false)
cart_gauge_limitCart total threshold for the free-shipping gauge
hide_footerHide the cart footer with totals and checkout button (default: false)
Bootic.components.render('cart-table', containerEl, {
  show_cart_gauge: true,
  cart_gauge_limit: 50000,
  hide_footer: false
}, function(node) { ... })
Renders an updated cart table layout (v3) with redesigned line items, optional cart gauge progress bar, and bundle/volume-discount action hints. Purely a renderer — doesn't wire its own clicks. Hosted themes wire it via DynamicCartTable; headless callers (e.g. ShoppingBeacon) wire it themselves after mounting.
show_cart_gaugeShow a progress gauge towards a cart goal (default: false)
cart_gauge_limitCart total amount that fills the gauge
Bootic.components.render('cart-table-v3', el, { show_cart_gauge: true, cart_gauge_limit: 50000 })
cart-table-view on demand
Renders a full standalone cart page view with all cart table functionality, suitable for embedding on a dedicated cart or checkout page.
show_cart_gaugeShow a progress gauge towards a free-shipping goal (default: false)
cart_gauge_limitCart subtotal amount that completes the gauge
Bootic.components.render('cart-table-view', el, { show_cart_gauge: true, cart_gauge_limit: 50000 })
Renders the cart summary panel showing item subtotal, discounts, taxes, shipping costs, and the grand total, with an optional related-product suggestion row.
show_suggestionsShow related product suggestions below the totals (default: false)
Bootic.components.render('cart-totals', el, { show_suggestions: true }, function(node) {})
contact-widget base widget: contact_button
Renders a floating multi-channel contact widget with configurable links to WhatsApp, email, phone, Telegram, Twitter, and other channels.
emailContact email address
callClick-to-call phone number
smsSMS phone number
telegramTelegram username
twitterTwitter handle
facebookFacebook page ID
Bootic.components.render('contact-widget', el, {
  email: 'hola@tienda.com',
  call: '+56912345678'
})
Renders a live countdown clock displaying days, hours, minutes, and seconds until a target date/time, with a configurable finished message.
startTimeISO date string for the countdown target
finishedMessageText to display when the countdown reaches zero
Bootic.components.render('countdown-timer', el, {
  startTime: '2025-12-31T23:59:59',
  finishedMessage: '¡Ya llegó!'
})
Renders a phone number input with an international country-code selector, auto-formatting the number based on the selected country's format rules.
defaultCountryISO alpha-2 country code to pre-select (default: 'CL')
valueInitial phone number value
Bootic.components.render('country-phone-input', el, { defaultCountry: 'MX' })
Renders a developer console panel for inspecting customer account data, cart state, and order history (intended for store admin or debugging use).
Bootic.components.render('customer-console', el, {})
Renders the logged-in customer navigation menu with links to orders, profile, addresses, favourites, and subscriptions, with SVG icons for each section.
userCustomer data object
linksCustom additional menu link objects
Bootic.components.render('customer-menu', el, { user: currentUser }, function(node) {})
delivery-setup base widget: delivery_setup
Renders the delivery method and address selection flow, supporting both shipping and pickup options with locality search and optional map display.
deliveryDelivery API object with getShippingOptions and related methods
showMapShow a map for pickup branch selection (default: false)
Bootic.components.render('delivery-setup', el, { delivery: deliveryApi })
Headless delivery-setup modal. Mounts DeliverySetup inside a managed overlay and exposes open()/close(). Each open() call creates a fresh modal; close() or backdrop-click dismisses it.
var deliverySetup = DeliverySetupV2Factory({}, shared)
deliverySetup.open()
feedback-button base widget: feedback_button
Renders a floating feedback/help button that opens the Help Scout Beacon or a custom feedback form when clicked. Headless-safe: form field definitions and submissions go through `shared.forms` (storefront.forms) when available, falling back to the legacy `Forms` AMD module (registered by register-amd.js) in hosted themes.
labelButton label text (default: from theme settings)
Bootic.components.render('feedback-button', el, {})
Renders a list of customer comments/reviews with ratings for the current page.
no_comments_messageMessage shown when there are no comments yet
Bootic.components.render('feedback-comments', el, {
  no_comments_message: 'Be the first to comment!'
})
Renders estimated delivery date, pickup availability, and branch stock information for a product, updating when the selected variant changes.
storeStore/branch identifier
productIdProduct ID to show fulfillment info for
variantIdInitially selected variant ID
Bootic.components.render('fulfillment-info', el, {
  productId: {{ product.id }},
  variantId: {{ product.variants.first.id }}
})
fullpage-slider on demand
Renders a full-viewport vertical scroll slider where each section occupies the entire screen height, with keyboard and swipe navigation.
loopLoop from last section back to first (default: false)
speedTransition speed in milliseconds (default: 600)
Bootic.components.render('fullpage-slider', el, { loop: true })
image-hotspots on demand
Renders an image with interactive hotspot markers that reveal product cards or tooltip details on click or hover.
imageURL of the background image
hotspotsArray of hotspot objects with x, y (percentage) and productId
Bootic.components.render('image-hotspots', el, {
  image: '/img/lookbook.jpg',
  hotspots: [{ x: 30, y: 45, productId: 123 }]
})
infobar base
Renders a dismissible announcement bar at the top of the page with configurable background colour, text colour, and message.
messageHTML message to display in the bar
bg_colorBackground colour (default: '#111')
text_colorText colour (default: 'white')
max_widthMaximum bar content width (default: '1170px')
Bootic.components.render('infobar', el, {
  message: 'Free shipping on orders over $50!',
  bg_color: '#e63946'
})
Renders a UI for selecting matching products to build a bundle (e.g. "complete the look"), showing compatible items and letting the customer add them as a set.
productIdThe anchor product ID
bundlesArray of bundle option objects to display
Bootic.components.render('matching-bundle-selector', el, {
  productId: {{ product.id }}
})
Renders a full-width dropdown mega menu with first and second level navigation links, activating second-level sub-menus on hover or focus.
linkSelectorCSS selector for first-level links (default: .first-level-menu)
secondMenuSelectorCSS selector for second-level containers (default: .second-level-menu)
Bootic.components.render('megamenu', el, {
  linkSelector: '.nav-item'
})
Renders a list of customer notifications (order updates, restock alerts, messages) with read/unread state management.
emptyMessageMessage shown when there are no notifications
Bootic.components.render('notification-list', el, {})
Renders the restock notification subscription form, letting a customer submit their email to be alerted when an out-of-stock product becomes available again.
form_urlURL of the notify-restocked POST endpoint (required)
variantsArray of variant objects to show in the variant selector
submit_cssCSS class for the submit button (default: 'primary')
Bootic.components.render('notify-restocked', el, {
  form_url: '/products/my-product/notify_restocked'
})
order-tracking on demand
Renders an order status tracking form where customers can enter their order number or email address to view real-time fulfilment and shipping status.
inModalRender in a condensed modal-friendly layout (default: false)
Bootic.components.render('order-tracking', el, {})
popover-menu on demand
Renders a floating popover navigation menu that appears near a trigger element, with configurable link items and auto-positioning.
linksArray of link objects with label and url properties
triggerSelectorCSS selector for the button that opens the menu
Bootic.components.render('popover-menu', el, {
  links: [{ label: 'My Orders', url: '/customer/orders' }]
})
product-detail on demand
Renders a mini product list (e.g. for "you may also like" or cart cross-sell suggestions) with product images, titles, prices, and inline add-to-cart buttons.
titleSection heading (default: '¡Que no se te olviden!')
productsArray of product objects to display
Bootic.components.render('product-list', el, {
  title: 'You may also like',
  products: relatedProducts
})
Renders a product option/variant picker with visual swatches or buttons, designed for embedding in listing pages or quick-buy modals.
titleProduct title
optionsVariant option definitions (name, values)
selectedVariantIdInitially selected variant ID
Bootic.components.render('product-option-selector', el, {
  title: '{{ product.name }}',
  options: {{ product.variants | json }}
})
Renders a compact product preview card with image, title, price, and a quick-add button for use in hover cards or inline listings.
productSlugProduct slug used to fetch product data
productIdProduct ID
Bootic.components.render('product-preview', el, {
  productSlug: '{{ product.slug }}'
})
Renders a full variant selection UI with add-to-cart integration, showing available options as buttons and updating price and stock status on selection.
titleProduct title
selectedVariantIdInitially selected variant ID
variantsArray of variant objects with id, options, price, and available
Bootic.components.render('product-variant-selector', el, {
  title: '{{ product.name }}',
  variants: {{ product.variants | json }}
})
Renders a dismissible promotional notice banner inside the page layout, showing active discounts or free shipping status from the cart.
messagePromotional message to display
Bootic.components.render('promo-notice', el, { message: '10% off your first order!' })
push-notifications-prompt base widget: push_notifications_prompt
Renders the push notification permission prompt with a subscribe button, asking the customer to allow browser push notifications.
promptPrompt message text (default: from theme settings)
Bootic.components.render('push-notifications-prompt', el, {
  prompt: 'Get notified about new arrivals and promotions!'
})
quick-stats on demand
Renders a dashboard-style panel with key shop metrics including order counts, revenue totals, and top products, for admin preview or store-owner contexts.
Bootic.components.render('quick-stats', el, {})
salesbot on demand
search-popover base widget: live_search
Renders a search input with a floating results popover that shows matching products, collections, and tags as the customer types, with optional images, prices, and autocomplete.
withImagesShow product thumbnails in results (default: false)
withPricesShow product prices in results (default: false)
showAutocompleteEnable search-term autocomplete suggestion (default: false)
Bootic.components.render('search-popover', el, {
  withImages: true,
  withPrices: true
})
shipping-calculator base widget: delivery_setup
Renders the shipping cost calculator form where customers enter their address to receive a real-time shipping estimate before checkout.
deliveryDelivery API object with getShippingOptions method
countryDefault country code for the address form
Bootic.components.render('shipping-calculator', el, {
  delivery: deliveryApi,
  country: 'CL'
})
Floating cart launcher with search, account menu, and a delivery-setup trigger, mounted as a persistent corner widget. Headless-safe by default: the cart badge, the cart slideout (Slideout + CartTable), and the delivery-setup trigger (Slideout + DeliverySetup) are wired directly from `shared.cart`/`shared.delivery` and work in any environment, hosted or headless. Search (`show_search`) and the account menu (`show_user_menu`) still depend on legacy-only globals (SearchIndex, search-popover, UserMenu) that don't exist in a headless/npm-only page — when the `Bootic` global isn't present those two sections are hidden automatically. Pass `show_search:false`/`show_user_menu:false` explicitly to hide them in a hosted theme too.
show_searchdefault true (forced off if legacy `Bootic` global is unavailable)
show_user_menudefault true (forced off if legacy `Bootic` global is unavailable)
show_cartdefault true (badge + cart slideout)
show_delivery_setupdefault true (location indicator opens DeliverySetup)
delivery_texttext shown next to the location indicator (default: "Elige tu forma de entrega")
position'bottom-right' (default), 'bottom-left', 'top-right', 'top-left'
signup-form on demand
Renders a customer registration form with configurable fields for name, email, password, phone, and address, handling submission and displaying validation errors.
titleForm heading text (default: 'Crea tu cuenta')
showPhoneInclude a phone number field (default: false)
showAddressInclude address fields (default: false)
submitLabelSubmit button label (default: 'Crear cuenta')
Bootic.components.render('signup-form', el, {
  title: 'Create your account',
  showPhone: true
})
Renders a slide-out drawer panel that overlays content from the right side of the screen, supporting multiple sequential steps and a programmatic open/close API.
widthDrawer width (default: '440px')
onCloseCallback invoked when the drawer is closed
Bootic.components.render('slideout', el, { width: '480px', onClose: onSlideoutClosed }, function(slideout) {
  slideout.addStep('cart', {}, function(step) { step.innerHTML = cartHtml })
  slideout.toggle()
})
Renders a persistent top navigation bar with configurable logo, background colour, text colour, and optional cart icon and customer menu integration.
bg_colorBackground colour (default: '#0071dc')
text_colorText colour (default: 'white')
logoUrlURL of the store logo image
Bootic.components.render('supernav', el, {
  bg_color: '#222',
  text_color: '#fff'
})
welcome-modal on demand widget: welcome_popup
Renders a configurable welcome pop-up modal for first-time visitors with optional subscribe form and promotional image. Loaded via modules/ui/welcome_modal.js, which maps the (snake_case) widget settings onto this component's camelCase props.
titleHeading text
textBody text
imageUrlPromotional image URL
imageLinkURL the image links to
linkTextCall-to-action link text (default: "Ver más")
linkUrlCall-to-action link URL
showSubscribeFormInclude a newsletter subscription form (default: false)
subscribeFormTagLiquid form tag name to apply to subscribers
buttonColorSubscribe button color (default: #18181b)
modalPositioncenter, top-left, top-right, bottom-left, or bottom-right (default: center)
darkModeUse dark modal styling (default: false)
showCloseButtonShow the close (x) button (default: true)
closeOnOverlayClickClose when clicking outside the modal (default: false)
Bootic.components.render('welcome-modal', el, {
  showSubscribeForm: true,
  subscribeFormTag: 'subscribe_form'
})