@o2vend/theme-cli 1.0.0

package/src/lib/liquid-filters.js

@@ -0,0 +1,589 @@
+/**
+ * O2VEND Liquid Filters
+ * Standalone implementation - copied and adapted from webstore solution
+ * Update manually when webstore solution changes
+ * 
+ * Source: o2vend-webstore/services/liquid-helper-service.js
+ */
+
+const moment = require('moment');
+const _ = require('lodash');
+
+/**
+ * Liquid Helper Service
+ * Provides additional filters and functions for liquid templates
+ */
+class LiquidHelperService {
+  constructor() {
+    this.filters = {
+      // Date filters
+      date: this.dateFilter.bind(this),
+      time_ago: this.timeAgoFilter.bind(this),
+      time_until: this.timeUntilFilter.bind(this),
+      
+      // String filters
+      truncate: this.truncateFilter.bind(this),
+      capitalize: this.capitalizeFilter.bind(this),
+      upcase: this.upcaseFilter.bind(this),
+      downcase: this.downcaseFilter.bind(this),
+      strip: this.stripFilter.bind(this),
+      lstrip: this.lstripFilter.bind(this),
+      rstrip: this.rstripFilter.bind(this),
+      split: this.splitFilter.bind(this),
+      join: this.joinFilter.bind(this),
+      replace: this.replaceFilter.bind(this),
+      remove: this.removeFilter.bind(this),
+      prepend: this.prependFilter.bind(this),
+      append: this.appendFilter.bind(this),
+      
+      // Number filters
+      plus: this.plusFilter.bind(this),
+      minus: this.minusFilter.bind(this),
+      times: this.timesFilter.bind(this),
+      divided_by: this.dividedByFilter.bind(this),
+      modulo: this.moduloFilter.bind(this),
+      round: this.roundFilter.bind(this),
+      ceil: this.ceilFilter.bind(this),
+      floor: this.floorFilter.bind(this),
+      abs: this.absFilter.bind(this),
+      
+      // Array filters
+      first: this.firstFilter.bind(this),
+      last: this.lastFilter.bind(this),
+      sort: this.sortFilter.bind(this),
+      reverse: this.reverseFilter.bind(this),
+      uniq: this.uniqFilter.bind(this),
+      map: this.mapFilter.bind(this),
+      where: this.whereFilter.bind(this),
+      size: this.sizeFilter.bind(this),
+      slice: this.sliceFilter.bind(this),
+      
+      // Object filters
+      default: this.defaultFilter.bind(this),
+      json: this.jsonFilter.bind(this),
+      
+      // Money filters
+      money: this.moneyFilter.bind(this),
+      money_with_currency: this.moneyWithCurrencyFilter.bind(this),
+      money_with_settings: this.moneyWithSettingsFilter.bind(this),
+      
+      // URL filters
+      url_encode: this.urlEncodeFilter.bind(this),
+      url_decode: this.urlDecodeFilter.bind(this),
+      
+      // HTML filters
+      escape: this.escapeFilter.bind(this),
+      strip_html: this.stripHtmlFilter.bind(this),
+      strip_newlines: this.stripNewlinesFilter.bind(this),
+      
+      // Image filters
+      img_url: this.imgUrlFilter.bind(this),
+      img_tag: this.imgTagFilter.bind(this),
+      
+      // Product filters
+      product_url: this.productUrlFilter.bind(this),
+      collection_url: this.collectionUrlFilter.bind(this),
+      page_url: this.pageUrlFilter.bind(this),
+      
+      // Utility filters
+      pluralize: this.pluralizeFilter.bind(this),
+      handleize: this.handleizeFilter.bind(this),
+      highlight: this.highlightFilter.bind(this),
+      truncatewords: this.truncateWordsFilter.bind(this),
+      newline_to_br: this.newlineToBrFilter.bind(this),
+      
+      // Asset versioning filter (adds version query parameter)
+      asset_url: this.assetUrlFilter.bind(this),
+    };
+  }
+
+  /**
+   * Get all available filters
+   * @returns {Object} Filters object
+   */
+  getFilters() {
+    return this.filters;
+  }
+
+  // Date filters
+  dateFilter(input, format) {
+    if (!input) return '';
+    
+    let date;
+    if (typeof input === 'string') {
+      const normalizedInput = input.trim();
+      const lowerInput = normalizedInput.toLowerCase();
+      
+      if (lowerInput === 'now' || lowerInput === 'today') {
+        date = moment();
+      } else if (normalizedInput.match(/^\d{4}-\d{2}-\d{2}t\d{2}:\d{2}:\d{2}/i)) {
+        date = moment(normalizedInput);
+      } else if (normalizedInput.match(/^\d{4}-\d{2}-\d{2}/)) {
+        date = moment(normalizedInput, 'YYYY-MM-DD');
+      } else {
+        if (normalizedInput.match(/[©a-zA-Z]/) && !normalizedInput.match(/^\d{4}/)) {
+          if (format && (format.includes('%Y') || format.includes('YYYY'))) {
+            return moment().format('YYYY');
+          }
+          return input;
+        }
+        
+        date = moment(normalizedInput, moment.ISO_8601, true);
+        if (!date.isValid()) {
+          try {
+            date = moment(normalizedInput);
+          } catch (e) {
+            if (format && (format.includes('%Y') || format.includes('YYYY'))) {
+              return moment().format('YYYY');
+            }
+            return input;
+          }
+        }
+      }
+    } else if (input instanceof Date) {
+      date = moment(input);
+    } else if (typeof input === 'number') {
+      date = moment.unix(input);
+    } else {
+      try {
+        date = moment(input);
+      } catch (e) {
+        if (format && (format.includes('%Y') || format.includes('YYYY'))) {
+          return moment().format('YYYY');
+        }
+        return input;
+      }
+    }
+    
+    if (!date || !date.isValid()) {
+      if (format && (format.includes('%Y') || format.includes('YYYY'))) {
+        return moment().format('YYYY');
+      }
+      return input;
+    }
+    
+    const momentFormat = (format || 'YYYY-MM-DD')
+      .replace(/%Y/g, 'YYYY')
+      .replace(/%m/g, 'MM')
+      .replace(/%d/g, 'DD')
+      .replace(/%H/g, 'HH')
+      .replace(/%M/g, 'mm')
+      .replace(/%S/g, 'ss')
+      .replace(/%y/g, 'YY');
+    
+    return date.format(momentFormat);
+  }
+
+  timeAgoFilter(input) {
+    if (!input) return '';
+    
+    let date;
+    if (typeof input === 'string') {
+      const normalizedInput = input.trim().toLowerCase();
+      if (normalizedInput === 'now' || normalizedInput === 'today') {
+        date = moment();
+      } else if (normalizedInput.match(/^\d{4}-\d{2}-\d{2}t\d{2}:\d{2}:\d{2}/)) {
+        date = moment(normalizedInput);
+      } else if (normalizedInput.match(/^\d{4}-\d{2}-\d{2}/)) {
+        date = moment(normalizedInput, 'YYYY-MM-DD');
+      } else {
+        date = moment(normalizedInput, moment.ISO_8601, true);
+        if (!date.isValid()) {
+          date = moment(normalizedInput);
+        }
+      }
+    } else if (input instanceof Date) {
+      date = moment(input);
+    } else {
+      date = moment(input);
+    }
+    
+    return date.isValid() ? date.fromNow() : input;
+  }
+
+  timeUntilFilter(input) {
+    if (!input) return '';
+    
+    let date;
+    if (typeof input === 'string') {
+      const normalizedInput = input.trim().toLowerCase();
+      if (normalizedInput === 'now' || normalizedInput === 'today') {
+        date = moment();
+      } else if (normalizedInput.match(/^\d{4}-\d{2}-\d{2}t\d{2}:\d{2}:\d{2}/)) {
+        date = moment(normalizedInput);
+      } else if (normalizedInput.match(/^\d{4}-\d{2}-\d{2}/)) {
+        date = moment(normalizedInput, 'YYYY-MM-DD');
+      } else {
+        date = moment(normalizedInput, moment.ISO_8601, true);
+        if (!date.isValid()) {
+          date = moment(normalizedInput);
+        }
+      }
+    } else if (input instanceof Date) {
+      date = moment(input);
+    } else {
+      date = moment(input);
+    }
+    
+    return date.isValid() ? date.toNow() : input;
+  }
+
+  // String filters
+  truncateFilter(input, length = 50, truncateString = '...') {
+    if (!input || typeof input !== 'string') return input;
+    return input.length > length ? 
+      input.substring(0, length) + truncateString : 
+      input;
+  }
+
+  capitalizeFilter(input) {
+    if (!input || typeof input !== 'string') return input;
+    return input.charAt(0).toUpperCase() + input.slice(1).toLowerCase();
+  }
+
+  upcaseFilter(input) {
+    return input && typeof input === 'string' ? input.toUpperCase() : input;
+  }
+
+  downcaseFilter(input) {
+    return input && typeof input === 'string' ? input.toLowerCase() : input;
+  }
+
+  stripFilter(input) {
+    return input && typeof input === 'string' ? input.trim() : input;
+  }
+
+  lstripFilter(input) {
+    return input && typeof input === 'string' ? input.replace(/^\s+/, '') : input;
+  }
+
+  rstripFilter(input) {
+    return input && typeof input === 'string' ? input.replace(/\s+$/, '') : input;
+  }
+
+  splitFilter(input, delimiter) {
+    if (!input || typeof input !== 'string') return [];
+    return input.split(delimiter || ' ');
+  }
+
+  joinFilter(input, delimiter) {
+    if (!Array.isArray(input)) return input;
+    return input.join(delimiter || ' ');
+  }
+
+  replaceFilter(input, search, replace) {
+    if (!input || typeof input !== 'string') return input;
+    return input.replace(new RegExp(search, 'g'), replace);
+  }
+
+  removeFilter(input, search) {
+    if (!input || typeof input !== 'string') return input;
+    return input.replace(new RegExp(search, 'g'), '');
+  }
+
+  prependFilter(input, prepend) {
+    if (!input) return prepend || '';
+    return (prepend || '') + input;
+  }
+
+  appendFilter(input, append) {
+    if (!input) return append || '';
+    return input + (append || '');
+  }
+
+  // Number filters
+  plusFilter(input, number) {
+    const num = parseFloat(input);
+    const add = parseFloat(number);
+    return isNaN(num) || isNaN(add) ? input : num + add;
+  }
+
+  minusFilter(input, number) {
+    const num = parseFloat(input);
+    const sub = parseFloat(number);
+    return isNaN(num) || isNaN(sub) ? input : num - sub;
+  }
+
+  timesFilter(input, number) {
+    const num = parseFloat(input);
+    const mult = parseFloat(number);
+    return isNaN(num) || isNaN(mult) ? input : num * mult;
+  }
+
+  dividedByFilter(input, number) {
+    const num = parseFloat(input);
+    const div = parseFloat(number);
+    return isNaN(num) || isNaN(div) || div === 0 ? input : num / div;
+  }
+
+  moduloFilter(input, number) {
+    const num = parseFloat(input);
+    const mod = parseFloat(number);
+    return isNaN(num) || isNaN(mod) || mod === 0 ? input : num % mod;
+  }
+
+  roundFilter(input, decimals = 0) {
+    const num = parseFloat(input);
+    return isNaN(num) ? input : Math.round(num * Math.pow(10, decimals)) / Math.pow(10, decimals);
+  }
+
+  ceilFilter(input) {
+    const num = parseFloat(input);
+    return isNaN(num) ? input : Math.ceil(num);
+  }
+
+  floorFilter(input) {
+    const num = parseFloat(input);
+    return isNaN(num) ? input : Math.floor(num);
+  }
+
+  absFilter(input) {
+    const num = parseFloat(input);
+    return isNaN(num) ? input : Math.abs(num);
+  }
+
+  // Array filters
+  firstFilter(input) {
+    return Array.isArray(input) && input.length > 0 ? input[0] : input;
+  }
+
+  lastFilter(input) {
+    return Array.isArray(input) && input.length > 0 ? input[input.length - 1] : input;
+  }
+
+  sortFilter(input, property) {
+    if (!Array.isArray(input)) return input;
+    if (property) {
+      return input.sort((a, b) => {
+        const aVal = _.get(a, property);
+        const bVal = _.get(b, property);
+        return aVal > bVal ? 1 : aVal < bVal ? -1 : 0;
+      });
+    }
+    return input.sort();
+  }
+
+  reverseFilter(input) {
+    return Array.isArray(input) ? input.slice().reverse() : input;
+  }
+
+  uniqFilter(input, property) {
+    if (!Array.isArray(input)) return input;
+    if (property) {
+      const seen = new Set();
+      return input.filter(item => {
+        const val = _.get(item, property);
+        if (seen.has(val)) return false;
+        seen.add(val);
+        return true;
+      });
+    }
+    return [...new Set(input)];
+  }
+
+  mapFilter(input, property) {
+    if (!Array.isArray(input)) return input;
+    return input.map(item => _.get(item, property));
+  }
+
+  whereFilter(input, property, value) {
+    if (!Array.isArray(input)) return input;
+    return input.filter(item => _.get(item, property) === value);
+  }
+
+  sizeFilter(input) {
+    if (Array.isArray(input)) return input.length;
+    if (typeof input === 'string') return input.length;
+    if (typeof input === 'object' && input !== null) return Object.keys(input).length;
+    return 0;
+  }
+
+  sliceFilter(input, start, length) {
+    if (!Array.isArray(input)) return input;
+    return input.slice(start, start + length);
+  }
+
+  // Object filters
+  defaultFilter(input, defaultValue) {
+    return input || defaultValue;
+  }
+
+  jsonFilter(input) {
+    try {
+      return JSON.stringify(input);
+    } catch (error) {
+      return input;
+    }
+  }
+
+  // Money filters
+  moneyFilter(input, currency = 'USD') {
+    const num = parseFloat(input);
+    if (isNaN(num)) return input;
+    
+    const formatter = new Intl.NumberFormat('en-US', {
+      style: 'currency',
+      currency: currency
+    });
+    
+    return formatter.format(num);
+  }
+
+  moneyWithCurrencyFilter(input, currency = 'USD') {
+    return this.moneyFilter(input, currency);
+  }
+
+  moneyWithSettingsFilter(input, settings = {}) {
+    const num = parseFloat(input);
+    if (isNaN(num)) return input;
+    
+    const {
+      currencySymbol = '₹',
+      currencyFormat = '#,##0.00',
+      currencyDecimalDigits = 2,
+      currencyGroupSeparator = ',',
+      currencyDecimalSeparator = '.',
+      currencyGroupSizes = [3]
+    } = settings;
+    
+    const formatNumberWithSettings = (num, settings) => {
+      const {
+        decimalDigits = 2,
+        groupSeparator = ',',
+        decimalSeparator = '.',
+        groupSizes = [3]
+      } = settings;
+      
+      let formatted = num.toFixed(decimalDigits);
+      const parts = formatted.split('.');
+      let integerPart = parts[0];
+      const decimalPart = parts[1];
+      
+      if (groupSizes.length > 0) {
+        const groupSize = groupSizes[0];
+        const regex = new RegExp(`\\B(?=(\\d{${groupSize}})+(?!\\d))`, 'g');
+        integerPart = integerPart.replace(regex, groupSeparator);
+      }
+      
+      if (decimalPart && decimalDigits > 0) {
+        return `${integerPart}${decimalSeparator}${decimalPart}`;
+      }
+      
+      return integerPart;
+    };
+    
+    const formatted = formatNumberWithSettings(num, {
+      decimalDigits: currencyDecimalDigits,
+      groupSeparator: currencyGroupSeparator,
+      decimalSeparator: currencyDecimalSeparator,
+      groupSizes: currencyGroupSizes
+    });
+    
+    return `${currencySymbol}${formatted}`;
+  }
+
+  // URL filters
+  urlEncodeFilter(input) {
+    return input && typeof input === 'string' ? encodeURIComponent(input) : input;
+  }
+
+  urlDecodeFilter(input) {
+    return input && typeof input === 'string' ? decodeURIComponent(input) : input;
+  }
+
+  // HTML filters
+  escapeFilter(input) {
+    if (!input || typeof input !== 'string') return input;
+    return input
+      .replace(/&/g, '&amp;')
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;')
+      .replace(/"/g, '&quot;')
+      .replace(/'/g, '&#39;');
+  }
+
+  stripHtmlFilter(input) {
+    if (!input || typeof input !== 'string') return input;
+    return input.replace(/<[^>]*>/g, '');
+  }
+
+  stripNewlinesFilter(input) {
+    if (!input || typeof input !== 'string') return input;
+    return input.replace(/\n/g, ' ').replace(/\r/g, '');
+  }
+
+  // Image filters
+  imgUrlFilter(input, size = 'original') {
+    if (!input) return '';
+    // In a real implementation, this would generate proper image URLs
+    return input;
+  }
+
+  imgTagFilter(input, alt = '', attributes = '') {
+    if (!input) return '';
+    return `<img src="${input}" alt="${alt}" ${attributes}>`;
+  }
+
+  // Product filters
+  productUrlFilter(product) {
+    if (!product) return '#';
+    return `/products/${product.slug || product.handle || product.id}`;
+  }
+
+  collectionUrlFilter(collection) {
+    if (!collection) return '#';
+    return `/collections/${collection.slug || collection.handle || collection.id}`;
+  }
+
+  pageUrlFilter(page) {
+    if (!page) return '#';
+    return `/pages/${page.slug || page.handle || page.id}`;
+  }
+
+  // Utility filters
+  pluralizeFilter(input, singular, plural) {
+    const count = parseInt(input);
+    if (isNaN(count)) return input;
+    return count === 1 ? singular : plural;
+  }
+
+  handleizeFilter(input) {
+    if (!input || typeof input !== 'string') return input;
+    return input
+      .toLowerCase()
+      .replace(/[^a-z0-9\s-]/g, '')
+      .replace(/\s+/g, '-')
+      .replace(/-+/g, '-')
+      .replace(/^-|-$/g, '');
+  }
+
+  highlightFilter(input, search, className = 'highlight') {
+    if (!input || !search || typeof input !== 'string') return input;
+    const regex = new RegExp(`(${search})`, 'gi');
+    return input.replace(regex, `<span class="${className}">$1</span>`);
+  }
+
+  truncateWordsFilter(input, words = 15, truncateString = '...') {
+    if (!input || typeof input !== 'string') return input;
+    const wordArray = input.split(' ');
+    if (wordArray.length <= words) return input;
+    return wordArray.slice(0, words).join(' ') + truncateString;
+  }
+
+  newlineToBrFilter(input) {
+    if (!input || typeof input !== 'string') return input;
+    return input.replace(/\n/g, '<br>');
+  }
+
+  /**
+   * Asset URL filter - returns asset URL as-is
+   * @param {string} input - Asset URL path
+   * @returns {string} Asset URL (unchanged)
+   */
+  assetUrlFilter(input) {
+    if (!input || typeof input !== 'string') return input;
+    return input;
+  }
+}
+
+module.exports = LiquidHelperService;