Get the name of the template in beforeRender?

[landoDanziger]

I am trying to export sections of rendered code to separate files.

Any ideas how to get the name of the file? I am trying to access frontmatter or the filename in vain.

events: {
    beforeRender(html, config) {
      // Get the template name from the front matter
      config.templateName = "folder_name"
    
      // must return `html`
      return html;
    },
    afterTransformers(html, config) {
      // Define the parts you want to extract
      const parts = [
        {name: 'header', start: '<header>', end: '</header>'},
        {name: 'footer', start: '<footer>', end: '</footer>'},
        // add more parts here...
      ];
  
      // Get the template name from the config object
      const templateName = config.templateName;
  
      // Create a directory for this template if it doesn't exist
      const templateDir = path.join(config.build.templates.destination.path, templateName);
      if (!fs.existsSync(templateDir)) {
        fs.mkdirSync(templateDir, { recursive: true });
      }
  
      // Extract and save each part
      for (const part of parts) {
        const startIndex = html.indexOf(part.start);
        const endIndex = html.indexOf(part.end);
  
        // If start and end tags exist, extract the part and save it
        if (startIndex !== -1 && endIndex !== -1) {
          const extractedPart = html.slice(startIndex + part.start.length, endIndex);
          fs.writeFileSync(path.join(templateDir, `${part.name}.liquid`), extractedPart);
  
          // Remove the tags from the final output
          html = html.replace(part.start, '').replace(part.end, '');
        }
      }
  
      return html;
    },
  },

[cossssmin]

We have this:

https://maizzle.com/docs/templates#current-template

[landoDanziger]

I am using it in a build config -

Me and ChatGpt are 1 million monkeys on 1 million typewriters....I am a brute force attack. Head :: monitor...

[landoDanziger]

I am guessing that the name isn't available

` events: {
beforeRender(html, config) {

  // Set the filename as the template name
  config.templateName = config.build.templates.destination.path.**name**

  return html;
},`

[cossssmin]

[landoDanziger]

I tried for maybe 4 hours, until i realised that I need to target them into a single folder in another repo.

I did trick github co pilot into doing it - but accidentally deleted it. I switched to wrapping the parts i wanted to extract with comments containing the name of the sub folder - then using regex to match, save the parts and turn them into tags, to extract and write.

It only overwrites the files that have been updated.

`events: {
beforeRender(html, config) {
// Assuming page.build.current is accessible
config.templateName = "content_blocks_TEST";
return html;
},

afterTransformers(html, config) {
  // Create a directory for this template if it doesn't exist
  const templateName = config.templateName;
  const templateDir = path.join('example/path/', templateName);
  if (!fs.existsSync(templateDir)) {
    fs.mkdirSync(templateDir, { recursive: true });
  }

  // Regular expression to match the custom comments
  const regex = /<!-- CMPNT :(.*?): START-->([\s\S]*?)<!-- CMPNT :\1: END-->/gs;

  // Array to hold the parts
  const parts = [];

  // Replace the component markers with custom tags and create the parts
  html = html.replace(regex, function(match, p1, p2) {
    const partName = p1.trim();
    parts.push({name: partName, start: `<${partName}>`, end: `</${partName}>`});
    return `<${partName}>${p2.trim()}</${partName}>`;
  });

  // Extract and save each part
  parts.forEach(part => {
    const partRegex = new RegExp(`${part.start}([\\s\\S]*?)${part.end}`, 'gs');
    let match;
    while ((match = partRegex.exec(html)) !== null) {
      const extractedPart = match[1].trim() + '\n';

      // Create a subdirectory for this part if it doesn't exist
      const partDir = path.join(templateDir, part.name);
      if (!fs.existsSync(partDir)) {
        fs.mkdirSync(partDir, { recursive: true });
      }

      // Define the path to the file
      const filePath = path.join(partDir, 'content.liquid');

      // Check if the file already exists and if its content is different from the new content
      let currentContent = '';
      if (fs.existsSync(filePath)) {
        currentContent = fs.readFileSync(filePath, 'utf8');
      }
      if (currentContent !== extractedPart) {
        // Write the extracted part to a file named 'content' in the part's subdirectory
        fs.writeFileSync(filePath, extractedPart);
      }

      // Replace the start and end tags with the content of the part
      html = html.replace(match[0], extractedPart);
    }
  });

  return html;
}

},`