shopify-accelerate-app 1.0.0

package/src/scaffold-theme/generate-liquid-files.ts

@@ -0,0 +1,995 @@
+import chalk from "chalk";
+import fs from "fs";
+import path from "path";
+import { PresetSchema, ShopifySectionPreset } from "../../@types/shopify";
+import { config, root_dir } from "../../shopify-accelerate-app";
+import { deleteFile, writeCompareFile, writeOnlyNew } from "../utils/fs";
+import { isObject } from "../utils/is-object";
+import { JSONParse } from "../utils/json";
+import { toCamelCase } from "../utils/to-camel-case";
+import { toLocaleFriendlySnakeCase, toSnakeCase } from "../utils/to-snake-case";
+import { generateBlockFiles } from "./generate-block-files";
+import { generateSectionFiles } from "./generate-section-files";
+import { generateSectionPresetFiles } from "./generate-section-preset-files";
+import { generateSettingsFile } from "./generate-settings-file";
+
+export const generateLiquidFiles = () => {
+  const {
+    theme_path,
+    folders,
+    sources,
+    targets,
+    delete_external_blocks,
+    delete_external_layouts,
+    delete_external_sections,
+    delete_external_snippets,
+    disabled_theme_blocks,
+  } = config;
+
+  const translations: any = {};
+  const snippets = sources.snippets;
+  const giftCards = sources.giftCards;
+  const layouts = sources.layouts;
+  const sectionsSchemas = sources.sectionSchemas;
+  const sectionPresetSchemas = sources.sectionPresetSchemas;
+  const blockSchemas = sources.blockSchemas;
+
+  generateSettingsFile();
+
+  for (const key in sectionsSchemas) {
+    const schema = sectionsSchemas[key];
+
+    const sectionName = `${schema.folder}.liquid`;
+    const sectionPath = path.join(process.cwd(), theme_path, "sections", sectionName);
+
+    if (schema.disabled) {
+      const targetFile = targets.sections.find(
+        (target) => target.split(/[\\/]/gi).at(-1) === sectionName
+      );
+      if (targetFile) {
+        config.targets.sections = config.targets.sections.filter((target) => target !== targetFile);
+        deleteFile(path.join(root_dir, targetFile));
+      }
+      const snippetTargets = targets.snippets.filter(
+        (target) => `${target.split(/[\\/]/gi).at(-1).split(".")[0]}.liquid` === sectionName
+      );
+
+      if (snippetTargets.length) {
+        config.targets.snippets = config.targets.snippets.filter((target) => {
+          if (snippetTargets.includes(target)) {
+            deleteFile(path.join(root_dir, target));
+            return false;
+          }
+          return true;
+        });
+      }
+      continue;
+    }
+
+    schema?.blocks?.forEach((block) => {
+      if (block.disabled) {
+        const targetFile = targets.snippets.find(
+          (target) =>
+            target.split(/[\\/]/gi).at(-1) ===
+            `${sectionName.replace(".liquid", "")}.${block.type}.liquid`
+        );
+        if (targetFile) {
+          config.targets.snippets = config.targets.snippets.filter(
+            (target) => target !== targetFile
+          );
+          deleteFile(path.join(root_dir, targetFile));
+        }
+      }
+    });
+
+    let translationArray = [];
+
+    const rawContent = fs.readFileSync(path.join(folders.sections, schema.folder, sectionName), {
+      encoding: "utf-8",
+    });
+
+    if (rawContent) {
+      let translatedContent = rawContent.replace(
+        /<t(\s+[^>]*)*>((.|\r|\n)*?)<\/t>/gi,
+        (str, group1, group2) => {
+          const group = toLocaleFriendlySnakeCase(schema.folder);
+          const content = toLocaleFriendlySnakeCase(
+            group2?.split(" ")?.slice(0, 2)?.join("_") ?? ""
+          ).trim();
+          const backupContent = toLocaleFriendlySnakeCase(group2).trim();
+          const id = toLocaleFriendlySnakeCase(group1?.replace(/id="(.*)"/gi, "$1") ?? "").trim();
+
+          if (!(group in translations)) {
+            translations[group] = {};
+          }
+
+          if (id && !(id in translations[group])) {
+            translations[group][id] = group2;
+            return `{{ "${group}.${id}" | t }}`;
+          }
+
+          if (!(content in translations[group])) {
+            translations[group][content] = group2;
+            return `{{ "${group}.${content}" | t }}`;
+          }
+
+          if (translations[group][content] !== group2) {
+            if (!(backupContent in translations[group])) {
+              translations[group][backupContent] = group2;
+              return `{{ "${group}.${backupContent}" | t }}`;
+            }
+            if (translations[group][backupContent] !== group2) {
+              translations[group][`${content}_2`] = group2;
+              return `{{ "${group}.${content}_2" | t }}`;
+            }
+          }
+
+          if (translations[group][content] === group2) {
+            return `{{ "${group}.${content}" | t }}`;
+          }
+
+          return group2;
+        }
+      );
+      if (disabled_theme_blocks) {
+        translatedContent = translatedContent?.replace(
+          /\n(\s*){%-?\s*content_for\s*['"]blocks["']\s*-?%}/gi,
+          (str, match) => {
+            match = match.replace(/\n/gi, "");
+            const arr = [`\n${match}{% liquid`];
+            arr.push(`${match}  for block in section.blocks`);
+            for (const key in blockSchemas) {
+              const schema = blockSchemas[key];
+              if (schema.disabled) continue;
+              arr.push(`${match}    if block.type == "${schema.folder}"`);
+              arr.push(
+                `${match}      render "_blocks.${schema.folder}", block: block, forloop: forloop, section_type: section_type, form: form`
+              );
+              arr.push(`${match}    endif`);
+            }
+            arr.push(`${match}  endfor`);
+            arr.push(`${match}%}`);
+
+            return arr.join("\n");
+          }
+        );
+
+        translatedContent = translatedContent?.replace(
+          /\n(\s*)content_for\s*['"]blocks["']\s*\n/gi,
+          (str, match) => {
+            match = match.replace(/\n/gi, "");
+            const arr = [`\n${match}`];
+            arr.push(`${match}for block in section.blocks`);
+            for (const key in blockSchemas) {
+              const schema = blockSchemas[key];
+              if (schema.disabled) continue;
+              arr.push(`${match}  if block.type == "${schema.folder}"`);
+              arr.push(
+                `${match}    render "_blocks.${schema.folder}", block: block, forloop: forloop, section_type: section_type, form: form`
+              );
+              arr.push(`${match}  endif`);
+            }
+            arr.push(`${match}endfor`);
+            arr.push(``);
+
+            return arr.join("\n");
+          }
+        );
+
+        translatedContent = translatedContent?.replace(
+          /\n(\s*){%-?\s*content_for\s*['"]block["']\s*-?%}/gi,
+          (str, match) => {
+            match = match.replace(/\n/gi, "");
+            const arr = [`\n${match}{% liquid`];
+            for (const key in blockSchemas) {
+              const schema = blockSchemas[key];
+              if (schema.disabled) continue;
+              arr.push(`${match}  if block.type == "${schema.folder}"`);
+              arr.push(
+                `${match}    render "_blocks.${schema.folder}", block: block, forloop: forloop, section_type: section_type, form: form`
+              );
+              arr.push(`${match}  endif`);
+            }
+            arr.push(`${match}%}`);
+
+            return arr.join("\n");
+          }
+        );
+        translatedContent = translatedContent?.replace(
+          /\n(\s*)content_for\s*['"]block["']\s*\n/gi,
+          (str, match) => {
+            match = match.replace(/\n/gi, "");
+            const arr = [`\n${match}`];
+            for (const key in blockSchemas) {
+              const schema = blockSchemas[key];
+              if (schema.disabled) continue;
+              arr.push(`${match}if block.type == "${schema.folder}"`);
+              arr.push(
+                `${match}  render "_blocks.${schema.folder}", block: block, forloop: forloop, section_type: section_type, form: form`
+              );
+              arr.push(`${match}endif`);
+            }
+            arr.push(``);
+            return arr.join("\n");
+          }
+        );
+      }
+      translationArray.push(translatedContent);
+    }
+
+    const snippetPath = path.join(process.cwd(), theme_path, "snippets", sectionName);
+
+    if (config.ignore_snippets?.includes(snippetPath.split(/[/\\]/)?.at(-1))) {
+      console.log(
+        `[${chalk.gray(new Date().toLocaleTimeString())}]: ${chalk.greenBright(
+          `Ignored: ${snippetPath.replace(process.cwd(), "")}`
+        )}`
+      );
+      writeOnlyNew(snippetPath, translationArray.join("\n"));
+    } else {
+      writeCompareFile(snippetPath, translationArray.join("\n"));
+    }
+
+    snippets.push(snippetPath);
+
+    translationArray = [`{%- render "${schema.folder}" -%}`];
+
+    translationArray.push(generateSectionFiles(schema));
+
+    if (config.ignore_sections?.includes(sectionPath.split(/[/\\]/)?.at(-1))) {
+      console.log(
+        `[${chalk.gray(new Date().toLocaleTimeString())}]: ${chalk.greenBright(
+          `Ignored: ${sectionPath.replace(process.cwd(), "")}`
+        )}`
+      );
+      writeOnlyNew(sectionPath, translationArray.join("\n"));
+    } else {
+      writeCompareFile(sectionPath, translationArray.join("\n"));
+    }
+  }
+
+  for (const key in sectionPresetSchemas) {
+    const presets =
+      sectionPresetSchemas[key]?.presets
+        ?.filter(
+          (preset) =>
+            config.all_presets ||
+            !preset.enabled_on ||
+            preset.enabled_on?.includes(process.env.SHOPIFY_ACCELERATE_STORE)
+        )
+        ?.map((preset, index, arr) => {
+          let currentPreset = {
+            name:
+              arr?.length === 1
+                ? sectionPresetSchemas[key]?.name
+                : preset.enabled_on &&
+                  !preset.enabled_on?.includes(process.env.SHOPIFY_ACCELERATE_STORE)
+                ? `${sectionPresetSchemas[key]?.name} - ${
+                    index + 1
+                  }` /*`${sectionPresetSchemas[key]?.name} - ${preset.enabled_on?.[0]}`*/
+                : `${sectionPresetSchemas[key]?.name} - ${index + 1}`,
+            settings: preset?.settings,
+            blocks: Array.isArray(preset?.blocks)
+              ? preset?.blocks
+              : Object.values(preset?.blocks ?? {}) ?? [],
+          } as unknown as ShopifySectionPreset;
+
+          if (
+            preset.enabled_on &&
+            !preset.enabled_on?.includes(process.env.SHOPIFY_ACCELERATE_STORE)
+          ) {
+            const matchList = {
+              content_class: ["richtext-md"],
+              button_class: [
+                "button-primary",
+                "button-tabs",
+                "button-secondary",
+                "button-primary-outline",
+              ],
+              scrollbar_class: ["scrollbar-no-buttons", "scrollbar"],
+              article_card_class: ["article-card"],
+              title_class: ["richtext-md"],
+              product_card_class: ["product-card", "product-card-flat"],
+              select_class: ["input-select"],
+              subscription_label_class: ["label-primary"],
+              legend_class: ["richtext-md"],
+              savings_highlight_class: ["richtext-md"],
+              label_class: ["richtext-md"],
+              price_class: ["richtext-md"],
+              incomplete_button_class: [
+                "button-primary",
+                "button-tabs",
+                "button-secondary",
+                "button-primary-outline",
+              ],
+              collection_card_class: ["collection-card"],
+              input_class: ["input-text", "input-text-inline"],
+              accordion_class: ["accordion"],
+              text_over_image_class: ["richtext-md"],
+              link_class: ["richtext-md"],
+              color_scheme: ["color_scheme_1"],
+            };
+            let string_content = JSON.stringify(currentPreset, null, 2);
+            for (const key in matchList) {
+              const regexp = new RegExp(`("${key}": )"([^"]*)"`, "gi");
+              string_content = string_content.replace(regexp, (totalMatch, _1, _2) => {
+                const value = _2;
+                const isValid = matchList[key].some(
+                  (className) =>
+                    new RegExp(`^${className}$`, "gi").test(value) ||
+                    new RegExp(` ${className}$`, "gi").test(value) ||
+                    new RegExp(`^${className} `, "gi").test(value) ||
+                    new RegExp(` ${className} `, "gi").test(value)
+                );
+                if (!isValid) {
+                  return `${_1}"${matchList[key][0]}"`;
+                }
+                return `${_1}"${value}"`;
+              });
+            }
+
+            currentPreset = JSONParse(string_content) || currentPreset;
+          }
+
+          return currentPreset;
+        }) ?? [];
+
+    if (!presets?.length) {
+      const targetFile = targets.sections.find(
+        (target) => target.split(/[\\/]/gi).at(-1) === `preset__${toSnakeCase(key)}.liquid`
+      );
+      if (targetFile) {
+        config.targets.sections = config.targets.sections.filter((target) => target !== targetFile);
+        deleteFile(path.join(root_dir, targetFile));
+      }
+      continue;
+    }
+    const schema = Object.values(sectionsSchemas)?.find(
+      (val) => val.folder === sectionPresetSchemas[key]?.type
+    );
+
+    if (!schema) {
+      continue;
+    }
+
+    const translationArray = [`{%- render "${schema.folder}" -%}`];
+
+    translationArray.push(
+      generateSectionPresetFiles({ schema, preset_name: sectionPresetSchemas[key].name, presets })
+    );
+
+    const sectionName = `preset__${toSnakeCase(key)}.liquid`;
+    const sectionPath = path.join(process.cwd(), theme_path, "sections", sectionName);
+    writeCompareFile(sectionPath, translationArray.join("\n"));
+  }
+
+  for (const key in blockSchemas) {
+    const schema = blockSchemas[key];
+
+    const sectionName = `${schema.folder}.liquid`;
+    const blockPath = disabled_theme_blocks
+      ? path.join(process.cwd(), theme_path, "snippets", sectionName)
+      : path.join(process.cwd(), theme_path, "blocks", sectionName);
+
+    if (schema.disabled) {
+      const targetFile = targets.blocks.find(
+        (target) => target.split(/[\\/]/gi).at(-1) === sectionName
+      );
+      if (targetFile) {
+        config.targets.blocks = config.targets.blocks.filter((target) => target !== targetFile);
+        deleteFile(path.join(root_dir, targetFile));
+      }
+
+      const snippetTargets = targets.snippets.filter((target) => {
+        return (
+          target
+            .split(/[\\/]/gi)
+            .at(-1)
+            .replace(/_blocks\./gi, "") === sectionName
+        );
+      });
+
+      if (snippetTargets.length) {
+        config.targets.snippets = config.targets.snippets.filter((target) => {
+          if (snippetTargets.includes(target)) {
+            deleteFile(path.join(root_dir, target));
+            return false;
+          }
+          return true;
+        });
+      }
+      continue;
+    }
+
+    const translationArray = [];
+
+    const rawContent = fs.readFileSync(path.join(folders.blocks, schema.folder, sectionName), {
+      encoding: "utf-8",
+    });
+
+    if (rawContent) {
+      const translatedContent = rawContent.replace(
+        /<t(\s+[^>]*)*>((.|\r|\n)*?)<\/t>/gi,
+        (str, group1, group2) => {
+          const group = toLocaleFriendlySnakeCase(schema.folder);
+          const content = toLocaleFriendlySnakeCase(
+            group2?.split(" ")?.slice(0, 2)?.join("_") ?? ""
+          ).trim();
+          const backupContent = toLocaleFriendlySnakeCase(group2).trim();
+          const id = toLocaleFriendlySnakeCase(group1?.replace(/id="(.*)"/gi, "$1") ?? "").trim();
+
+          if (!(group in translations)) {
+            translations[group] = {};
+          }
+
+          if (id && !(id in translations[group])) {
+            translations[group][id] = group2;
+            return `{{ "${group}.${id}" | t }}`;
+          }
+
+          if (!(content in translations[group])) {
+            translations[group][content] = group2;
+            return `{{ "${group}.${content}" | t }}`;
+          }
+
+          if (translations[group][content] !== group2) {
+            if (!(backupContent in translations[group])) {
+              translations[group][backupContent] = group2;
+              return `{{ "${group}.${backupContent}" | t }}`;
+            }
+            if (translations[group][backupContent] !== group2) {
+              translations[group][`${content}_2`] = group2;
+              return `{{ "${group}.${content}_2" | t }}`;
+            }
+          }
+
+          if (translations[group][content] === group2) {
+            return `{{ "${group}.${content}" | t }}`;
+          }
+
+          return group2;
+        }
+      );
+
+      translationArray.push(translatedContent);
+    }
+
+    translationArray.push(generateBlockFiles(schema));
+    if (disabled_theme_blocks) continue;
+
+    if (config.ignore_blocks?.includes(blockPath.split(/[/\\]/)?.at(-1))) {
+      console.log(
+        `[${chalk.gray(new Date().toLocaleTimeString())}]: ${chalk.greenBright(
+          `Ignored: ${blockPath.replace(process.cwd(), "")}`
+        )}`
+      );
+      writeOnlyNew(blockPath, translationArray.join("\n"));
+    } else {
+      writeCompareFile(blockPath, translationArray.join("\n"));
+    }
+  }
+
+  for (let i = 0; i < snippets.length; i++) {
+    const snippet = snippets[i];
+    const snippetName = snippet.split(/[\\/]/gi).at(-1);
+
+    const section = Object.values(sectionsSchemas).find((section) =>
+      section.path.includes(snippet.replace(snippetName, ""))
+    );
+    const blockSchema = section?.blocks?.find((block) =>
+      new RegExp(`\\.${block.type}\\.`, "gi").test(snippetName)
+    );
+
+    if (section && (section.disabled || blockSchema?.disabled)) {
+      continue;
+    }
+    const block = Object.values(blockSchemas).find((section) =>
+      section.path.includes(snippet.replace(snippetName, ""))
+    );
+    if (block && block.disabled) {
+      continue;
+    }
+    const snippetPath =
+      disabled_theme_blocks && snippet?.includes(folders.blocks)
+        ? path.join(process.cwd(), theme_path, "snippets", `_blocks.${snippetName}`)
+        : path.join(process.cwd(), theme_path, "snippets", snippetName);
+
+    const returnArr = [];
+
+    const rawContent = fs.readFileSync(snippet, {
+      encoding: "utf-8",
+    });
+
+    if (rawContent) {
+      let translatedContent = rawContent.replace(
+        /<t(\s+[^>]*)*>((.|\r|\n)*?)<\/t>/gi,
+        (_, group1, group2) => {
+          const group = toLocaleFriendlySnakeCase(
+            snippet.split(/[\\/]/gi).at(-1).split(".").at(0)
+          ).trim();
+          const content = toLocaleFriendlySnakeCase(
+            group2?.split(" ")?.slice(0, 2)?.join("_") ?? ""
+          ).trim();
+          const backupContent = toLocaleFriendlySnakeCase(group2).trim();
+          const id = toLocaleFriendlySnakeCase(group1?.replace(/id="(.*)"/gi, "$1") ?? "").trim();
+
+          if (!(group in translations)) {
+            translations[group] = {};
+          }
+
+          if (id && !(id in translations[group])) {
+            translations[group][id] = group2;
+            return `{{ "${group}.${id}" | t }}`;
+          }
+
+          if (!(content in translations[group])) {
+            translations[group][content] = group2;
+            return `{{ "${group}.${content}" | t }}`;
+          }
+
+          if (translations[group][content] !== group2) {
+            if (!(backupContent in translations[group])) {
+              translations[group][backupContent] = group2;
+              return `{{ "${group}.${backupContent}" | t }}`;
+            }
+            if (translations[group][backupContent] !== group2) {
+              translations[group][`${content}_2`] = group2;
+              return `{{ "${group}.${content}_2" | t }}`;
+            }
+          }
+          if (translations[group][content] === group2) {
+            return `{{ "${group}.${content}" | t }}`;
+          }
+
+          return group2;
+        }
+      );
+
+      if (disabled_theme_blocks) {
+        translatedContent = translatedContent?.replace(
+          /\n(\s*){%-?\s*content_for\s*['"]blocks["']\s*-?%}/gi,
+          (str, match) => {
+            match = match.replace(/\n/gi, "");
+            const arr = [`\n${match}{% liquid`];
+            arr.push(`${match}  for block in section.blocks`);
+            for (const key in blockSchemas) {
+              const schema = blockSchemas[key];
+              if (schema.disabled) continue;
+              arr.push(`${match}    if block.type == "${schema.folder}"`);
+              arr.push(
+                `${match}      render "_blocks.${schema.folder}", block: block, forloop: forloop, section_type: section_type, form: form`
+              );
+              arr.push(`${match}    endif`);
+            }
+            arr.push(`${match}  endfor`);
+            arr.push(`${match}%}`);
+
+            return arr.join("\n");
+          }
+        );
+
+        translatedContent = translatedContent?.replace(
+          /\n(\s*)content_for\s*['"]blocks["']\s*\n/gi,
+          (str, match) => {
+            match = match.replace(/\n/gi, "");
+            const arr = [`\n${match}`];
+            arr.push(`${match}for block in section.blocks`);
+            for (const key in blockSchemas) {
+              const schema = blockSchemas[key];
+              if (schema.disabled) continue;
+              arr.push(`${match}  if block.type == "${schema.folder}"`);
+              arr.push(
+                `${match}    render "_blocks.${schema.folder}", block: block, forloop: forloop, section_type: section_type, form: form`
+              );
+              arr.push(`${match}  endif`);
+            }
+            arr.push(`${match}endfor`);
+            arr.push(``);
+
+            return arr.join("\n");
+          }
+        );
+
+        translatedContent = translatedContent?.replace(
+          /\n(\s*){%-?\s*content_for\s*['"]block["']\s*-?%}/gi,
+          (str, match) => {
+            match = match.replace(/\n/gi, "");
+            const arr = [`\n${match}{% liquid`];
+            for (const key in blockSchemas) {
+              const schema = blockSchemas[key];
+              if (schema.disabled) continue;
+              arr.push(`${match}  if block.type == "${schema.folder}"`);
+              arr.push(
+                `${match}    render "_blocks.${schema.folder}", block: block, forloop: forloop, section_type: section_type, form: form`
+              );
+              arr.push(`${match}  endif`);
+            }
+            arr.push(`${match}%}`);
+
+            return arr.join("\n");
+          }
+        );
+        translatedContent = translatedContent?.replace(
+          /\n(\s*)content_for\s*['"]block["']\s*\n/gi,
+          (str, match) => {
+            match = match.replace(/\n/gi, "");
+            const arr = [`\n${match}`];
+            for (const key in blockSchemas) {
+              const schema = blockSchemas[key];
+              if (schema.disabled) continue;
+              arr.push(`${match}if block.type == "${schema.folder}"`);
+              arr.push(
+                `${match}  render "_blocks.${schema.folder}", block: block, forloop: forloop, section_type: section_type, form: form`
+              );
+              arr.push(`${match}endif`);
+            }
+            arr.push(``);
+            return arr.join("\n");
+          }
+        );
+      }
+
+      returnArr.push(translatedContent);
+    }
+
+    if (config.ignore_snippets?.includes(snippetPath.split(/[/\\]/)?.at(-1))) {
+      console.log(
+        `[${chalk.gray(new Date().toLocaleTimeString())}]: ${chalk.greenBright(
+          `Ignored: ${snippetPath.replace(process.cwd(), "")}`
+        )}`
+      );
+      writeOnlyNew(snippetPath, returnArr.join("\n"));
+    } else {
+      writeCompareFile(snippetPath, returnArr.join("\n"));
+    }
+  }
+
+  for (let i = 0; i < giftCards.length; i++) {
+    const giftCard = giftCards[i];
+    const giftCardName = giftCard.split(/[\\/]/gi).at(-1);
+
+    const giftCardPath = path.join(process.cwd(), theme_path, "templates", giftCardName);
+
+    const returnArr = [];
+
+    const rawContent = fs.readFileSync(giftCard, {
+      encoding: "utf-8",
+    });
+
+    if (rawContent) {
+      const translatedContent = rawContent.replace(
+        /<t(\s+[^>]*)*>((.|\r|\n)*?)<\/t>/gi,
+        (_, group1, group2) => {
+          const group = toLocaleFriendlySnakeCase(
+            giftCard.split(/[\\/]/gi).at(-1).split(".").at(0)
+          ).trim();
+          const content = toLocaleFriendlySnakeCase(
+            group2?.split(" ")?.slice(0, 2)?.join("_") ?? ""
+          ).trim();
+          const backupContent = toLocaleFriendlySnakeCase(group2).trim();
+          const id = toLocaleFriendlySnakeCase(group1?.replace(/id="(.*)"/gi, "$1") ?? "").trim();
+
+          if (!(group in translations)) {
+            translations[group] = {};
+          }
+
+          if (id && !(id in translations[group])) {
+            translations[group][id] = group2;
+            return `{{ "${group}.${id}" | t }}`;
+          }
+
+          if (!(content in translations[group])) {
+            translations[group][content] = group2;
+            return `{{ "${group}.${content}" | t }}`;
+          }
+
+          if (translations[group][content] !== group2) {
+            if (!(backupContent in translations[group])) {
+              translations[group][backupContent] = group2;
+              return `{{ "${group}.${backupContent}" | t }}`;
+            }
+            if (translations[group][backupContent] !== group2) {
+              translations[group][`${content}_2`] = group2;
+              return `{{ "${group}.${content}_2" | t }}`;
+            }
+          }
+          if (translations[group][content] === group2) {
+            return `{{ "${group}.${content}" | t }}`;
+          }
+
+          return group2;
+        }
+      );
+      returnArr.push(translatedContent);
+    }
+
+    writeCompareFile(giftCardPath, returnArr.join("\n"));
+  }
+
+  for (let i = 0; i < layouts.length; i++) {
+    const layout = layouts[i];
+    const layoutName = layout.split(/[\\/]/gi).at(-1);
+    const layoutPath = path.join(process.cwd(), theme_path, "layout", layoutName);
+
+    const returnArr = [];
+
+    const rawContent = fs.readFileSync(layout, {
+      encoding: "utf-8",
+    });
+
+    if (rawContent) {
+      const translatedContent = rawContent.replace(
+        /<t(\s+[^>]*)*>((.|\r|\n)*?)<\/t>/gi,
+        (_, group1, group2) => {
+          const group = toLocaleFriendlySnakeCase(
+            layout.split(/[\\/]/gi).at(-1).split(".").at(0)
+          ).trim();
+          const content = toLocaleFriendlySnakeCase(
+            group2?.split(" ")?.slice(0, 2)?.join("_") ?? ""
+          ).trim();
+          const backupContent = toLocaleFriendlySnakeCase(group2).trim();
+          const id = toLocaleFriendlySnakeCase(group1?.replace(/id="(.*)"/gi, "$1") ?? "").trim();
+
+          if (!(group in translations)) {
+            translations[group] = {};
+          }
+
+          if (id && !(id in translations[group])) {
+            translations[group][id] = group2;
+            return `{{ "${group}.${id}" | t }}`;
+          }
+
+          if (!(content in translations[group])) {
+            translations[group][content] = group2;
+            return `{{ "${group}.${content}" | t }}`;
+          }
+
+          if (translations[group][content] !== group2) {
+            if (!(backupContent in translations[group])) {
+              translations[group][backupContent] = group2;
+              return `{{ "${group}.${backupContent}" | t }}`;
+            }
+            if (translations[group][backupContent] !== group2) {
+              translations[group][`${content}_2`] = group2;
+              return `{{ "${group}.${content}_2" | t }}`;
+            }
+          }
+          if (translations[group][content] === group2) {
+            return `{{ "${group}.${content}" | t }}`;
+          }
+
+          return group2;
+        }
+      );
+      returnArr.push(translatedContent);
+    }
+
+    if (config.ignore_layouts?.includes(layoutPath.split(/[/\\]/)?.at(-1))) {
+      console.log(
+        `[${chalk.gray(new Date().toLocaleTimeString())}]: ${chalk.greenBright(
+          `Ignored: ${layoutPath.replace(process.cwd(), "")}`
+        )}`
+      );
+      if (layoutPath.split(/[/\\]/)?.at(-1) === "theme.liquid") {
+        writeCompareFile(
+          layoutPath.replace("theme.liquid", "theme.dev.liquid"),
+          returnArr.join("\n")
+        );
+      }
+      writeOnlyNew(layoutPath, returnArr.join("\n"));
+    } else {
+      writeCompareFile(layoutPath, returnArr.join("\n"));
+    }
+  }
+
+  const transformTranslations = (input, prevKey = "") => {
+    if (isObject(input)) {
+      return Object.entries(input).reduce<any>((acc, [key, val]) => {
+        acc[key] = transformTranslations(val, `${prevKey ? `${prevKey}.` : ""}${key}`);
+        return acc;
+      }, {});
+    }
+    if (typeof input === "string") {
+      return `{{ '${prevKey}' | t }}`;
+    }
+  };
+
+  const translationsJs = `<script data-no-block>
+  window.translations = ${JSON.stringify(transformTranslations(translations), undefined, 2)};
+</script>
+  `;
+
+  const translationTypes = `export type Translations = ${JSON.stringify(translations, undefined, 2)
+    .replace(/(\s+)([^\n:]*):([^\n{]*?),?\n/gi, "$1/* $3 */\n$1$2: string;\n")
+    .replace(/"/gi, "")
+    .replace(/,/gi, ";")
+    .replace(/}\n/gi, "};\n")
+    .replace(/\n\n/gi, "\n")};
+declare global {
+  interface Window {
+    translations?: Translations;
+  }
+}
+`;
+
+  writeCompareFile(
+    path.join(process.cwd(), theme_path, "locales", "en.default.json"),
+    JSON.stringify(translations, undefined, 2)
+  );
+  writeCompareFile(
+    path.join(process.cwd(), theme_path, "snippets", "_layout.translations.liquid"),
+    translationsJs
+  );
+  writeCompareFile(path.join(folders.types, "translations.ts"), translationTypes);
+
+  const dynamicJsImports = [];
+
+  sources.sectionsJs.forEach((name) => {
+    const filename = name.split(/[\\/]/gi).at(-1);
+    const section = Object.values(sectionsSchemas).find((section) =>
+      section.path.includes(name.replace(filename, ""))
+    );
+    const targetName = `__section--${filename.replace(/\.(ts)x?$/gi, ".js")}`;
+    const targetFile = targets.dynamicJs.find((file) => file.includes(targetName));
+
+    if (section && !section.disabled) {
+      dynamicJsImports.push(
+        `<link rel="preload" as="script" href="{{ '${targetName}' | asset_url }}">`
+      );
+      dynamicJsImports.push(
+        `<script type="module" src="{{ '${targetName}' | asset_url }}" defer></script>`
+      );
+    } else if (targetFile) {
+      deleteFile(path.join(root_dir, targetFile));
+      config.targets.dynamicJs = config.targets.dynamicJs.filter((target) => target !== targetFile);
+    }
+  });
+
+  sources.blocksJs.forEach((name) => {
+    const filename = name.split(/[\\/]/gi).at(-1);
+    const block = Object.values(blockSchemas).find((section) =>
+      section.path.includes(name.replace(filename, ""))
+    );
+    const targetName = `__block--${filename.replace(/\.(ts)x?$/gi, ".js")}`;
+    const targetFile = targets.dynamicJs.find((file) => file.includes(targetName));
+
+    if (block && !block.disabled) {
+      dynamicJsImports.push(
+        `<link rel="preload" as="script" href="{{ '${targetName}' | asset_url }}">`
+      );
+      dynamicJsImports.push(
+        `<script type="module" src="{{ '${targetName}' | asset_url }}" defer></script>`
+      );
+    } else if (targetFile) {
+      deleteFile(path.join(root_dir, targetFile));
+      config.targets.dynamicJs = config.targets.dynamicJs.filter((target) => target !== targetFile);
+    }
+  });
+
+  targets.dynamicJs.forEach((name) => {
+    const targetName = name.split(/[\\/]/gi).at(-1).replace(/\.js$/gi, "");
+
+    const sectionFile = sources.sectionsJs.find(
+      (section) =>
+        section.includes(`\\${targetName.replace(/__section--/gi, "")}.ts`) ||
+        section.includes(`/${targetName.replace(/__section--/gi, "")}.ts`)
+    );
+
+    if (sectionFile) {
+      const filename = sectionFile?.split(/[\\/]/gi)?.at(-1);
+
+      const section = Object.values(sectionsSchemas).find((section) =>
+        section.path.includes(sectionFile.replace(filename, ""))
+      );
+
+      if (!section || section.disabled) {
+        deleteFile(path.join(root_dir, name));
+        config.targets.dynamicJs = config.targets.dynamicJs.filter((target) => target !== name);
+      }
+      return;
+    }
+
+    const blockFile = sources.blocksJs.find((section) =>
+      section.includes(targetName.replace(/__block--/gi, ""))
+    );
+
+    if (blockFile) {
+      const filename = blockFile?.split(/[\\/]/gi)?.at(-1);
+
+      const block = Object.values(blockSchemas).find((section) =>
+        section.path.includes(blockFile.replace(filename, ""))
+      );
+
+      if (!block || block.disabled) {
+        deleteFile(path.join(root_dir, name));
+        config.targets.dynamicJs = config.targets.dynamicJs.filter((target) => target !== name);
+      }
+      return;
+    }
+    deleteFile(path.join(root_dir, name));
+    config.targets.dynamicJs = config.targets.dynamicJs.filter((target) => target !== name);
+  });
+
+  writeCompareFile(
+    path.join(process.cwd(), theme_path, "snippets", "_layout.dynamic-imports.liquid"),
+    dynamicJsImports.join("\n")
+  );
+
+  if (delete_external_snippets) {
+    targets.snippets.forEach((file) => {
+      const fileName = file.split(/[\\/]/gi).at(-1);
+      const targetFile = snippets.find((sourcePath) =>
+        disabled_theme_blocks && sourcePath?.includes(folders.blocks)
+          ? `_blocks.${sourcePath.split(/[\\/]/gi).at(-1)}` === fileName
+          : sourcePath.split(/[\\/]/gi).at(-1) === fileName
+      );
+      if (
+        fileName.includes("_layout.translations.liquid") ||
+        fileName.includes("_layout.dynamic-imports.liquid") ||
+        /^replo/gi.test(fileName) ||
+        /^pandectes/gi.test(fileName) ||
+        /^locksmith/gi.test(fileName) ||
+        /^shogun/gi.test(fileName)
+      ) {
+        return;
+      }
+      if (!targetFile) {
+        deleteFile(path.join(process.cwd(), file));
+      }
+    });
+  }
+
+  if (delete_external_sections) {
+    targets.sections.forEach((file) => {
+      const fileName = file.split(/[\\/]/gi).at(-1);
+      const targetFile =
+        sources.sectionsLiquid.find(
+          (sourcePath) => sourcePath.split(/[\\/]/gi).at(-1) === fileName
+        ) ||
+        Object.entries(sources.sectionPresetSchemas).find(
+          ([key, val]) =>
+            val.presets?.filter(
+              (preset) =>
+                config.all_presets ||
+                !preset.enabled_on ||
+                preset.enabled_on?.includes(process.env.SHOPIFY_ACCELERATE_STORE)
+            )?.length && fileName === `preset__${toSnakeCase(key)}.liquid`
+        );
+      if (
+        /^replo/gi.test(fileName) ||
+        /^pandectes/gi.test(fileName) ||
+        /^locksmith/gi.test(fileName) ||
+        /^shogun/gi.test(fileName)
+      ) {
+        return;
+      }
+      if (!targetFile) {
+        deleteFile(path.join(process.cwd(), file));
+      }
+    });
+  }
+
+  if (delete_external_layouts) {
+    targets.layout.forEach((file) => {
+      const fileName = file.split(/[\\/]/gi).at(-1);
+      const targetFile = sources.layouts.find(
+        (sourcePath) => sourcePath.split(/[\\/]/gi).at(-1) === fileName
+      );
+      if (!targetFile) {
+        deleteFile(path.join(process.cwd(), file));
+      }
+    });
+  }
+
+  if (delete_external_blocks) {
+    targets.blocks.forEach((file) => {
+      const fileName = file.split(/[\\/]/gi).at(-1);
+      const targetFile = sources.blocksLiquid.find(
+        (sourcePath) => sourcePath.split(/[\\/]/gi).at(-1) === fileName
+      );
+      if (!targetFile) {
+        deleteFile(path.join(process.cwd(), file));
+      }
+    });
+  }
+};