@o2vend/theme-cli 1.0.0

package/src/lib/liquid-engine.js

@@ -0,0 +1,169 @@
+/**
+ * LiquidJS Engine Setup
+ * Configures LiquidJS with all O2VEND filters and custom tags
+ */
+
+const { Liquid } = require('liquidjs');
+const path = require('path');
+const LiquidHelperService = require('./liquid-filters');
+const fs = require('fs');
+
+/**
+ * Create and configure LiquidJS engine
+ * @param {string} themePath - Path to theme directory
+ * @param {Object} options - Engine options
+ * @returns {Liquid} Configured LiquidJS engine
+ */
+function createLiquidEngine(themePath, options = {}) {
+  const {
+    cache = false, // Disable cache in dev mode
+    extname = '.liquid'
+  } = options;
+
+  // Create Liquid engine
+  const liquid = new Liquid({
+    root: themePath,
+    extname: extname,
+    cache: cache,
+    strictFilters: false,
+    strictVariables: false,
+    outputEscape: 'escape',
+    ownPropertyOnly: false
+  });
+
+  // Register all filters from LiquidHelperService
+  const liquidHelperService = new LiquidHelperService();
+  const filters = liquidHelperService.getFilters();
+  
+  Object.keys(filters).forEach(filterName => {
+    liquid.registerFilter(filterName, filters[filterName]);
+  });
+
+  // Register custom tags
+  registerCustomTags(liquid, themePath);
+
+  return liquid;
+}
+
+/**
+ * Register custom Liquid tags (section, hook, schema)
+ * @param {Liquid} liquid - LiquidJS engine instance
+ * @param {string} themePath - Theme path
+ */
+function registerCustomTags(liquid, themePath) {
+  // Register section tag
+  liquid.registerTag('section', {
+    parse: function(tagToken, remainTokens) {
+      this.sectionPath = tagToken.args.trim().replace(/^['"]|['"]$/g, '');
+    },
+    render: async function(scope, hash) {
+      const sectionPath = this.sectionPath;
+      if (!sectionPath) {
+        console.error('[SECTION] No section path provided');
+        return '';
+      }
+      
+      try {
+        const sectionFile = path.join(themePath, 'sections', `${sectionPath}.liquid`);
+        if (fs.existsSync(sectionFile)) {
+          const sectionContent = fs.readFileSync(sectionFile, 'utf8');
+          const scopeContexts = Array.isArray(scope?.contexts) ? scope.contexts : [];
+          const primaryScope = scopeContexts.length > 0
+            ? scopeContexts[0]
+            : (scope?.environments || scope?.context || {});
+          
+          const context = {
+            ...primaryScope,
+            section: primaryScope.section || {}
+          };
+          
+          return await liquid.parseAndRender(sectionContent, context);
+        } else {
+          console.warn(`[SECTION] Section file not found: ${sectionFile}`);
+          return '';
+        }
+      } catch (error) {
+        console.error(`[SECTION] Error rendering section ${sectionPath}:`, error.message);
+        return '';
+      }
+    }
+  });
+
+  // Register hook tag (simplified for CLI - plugins not supported)
+  liquid.registerTag('hook', {
+    parse: function(tagToken, remainTokens) {
+      const args = tagToken.args;
+      if (typeof args === 'string') {
+        this.hookName = args.trim().replace(/^['"]|['"]$/g, '');
+      } else {
+        this.hookName = String(args || '').trim().replace(/^['"]|['"]$/g, '');
+      }
+    },
+    render: async function(scope, hash) {
+      // In CLI, hooks are not supported (no plugin system)
+      // Return empty string
+      return '';
+    }
+  });
+
+  // Schema tag is handled by LiquidJS as a block tag
+  // No special registration needed
+}
+
+/**
+ * Render template with layout support
+ * @param {Liquid} liquid - LiquidJS engine
+ * @param {string} templatePath - Template path (relative to theme, e.g., 'templates/index')
+ * @param {Object} context - Template context
+ * @param {string} themePath - Theme path
+ * @returns {Promise<string>} Rendered HTML
+ */
+async function renderWithLayout(liquid, templatePath, context, themePath) {
+  try {
+    const fullTemplatePath = path.join(themePath, `${templatePath}.liquid`);
+    
+    if (!fs.existsSync(fullTemplatePath)) {
+      throw new Error(`Template not found: ${fullTemplatePath}`);
+    }
+    
+    const templateContent = fs.readFileSync(fullTemplatePath, 'utf-8');
+    
+    // Check for layout directive
+    const layoutMatch = templateContent.match(/\{%\s*layout\s+['"](.+?)['"]\s*%\}/);
+    
+    if (layoutMatch) {
+      const layoutPath = layoutMatch[1]; // e.g., 'theme'
+      
+      // Remove layout directive from template
+      const contentWithoutLayout = templateContent.replace(/\{%\s*layout\s+['"](.+?)['"]\s*%\}/, '').trim();
+      
+      // Render template content first
+      const renderedContent = await liquid.parseAndRender(contentWithoutLayout, context);
+      
+      // Render layout with content
+      const layoutContext = {
+        ...context,
+        content: renderedContent
+      };
+      
+      const layoutFile = path.join(themePath, 'layout', `${layoutPath}.liquid`);
+      if (fs.existsSync(layoutFile)) {
+        const layoutContent = fs.readFileSync(layoutFile, 'utf-8');
+        return await liquid.parseAndRender(layoutContent, layoutContext);
+      } else {
+        throw new Error(`Layout not found: ${layoutFile}`);
+      }
+    } else {
+      // No layout directive, render template directly
+      return await liquid.parseAndRender(templateContent, context);
+    }
+  } catch (error) {
+    console.error('Error rendering template with layout:', error);
+    throw error;
+  }
+}
+
+module.exports = {
+  createLiquidEngine,
+  renderWithLayout
+};