@akqa-denmark/shopify-theme-build 0.1.0

package/dist/prepare-APTEPBMX.js

@@ -0,0 +1,701 @@
+#!/usr/bin/env node
+import {
+  getStorePaths,
+  resolveConfig,
+  resolveStore
+} from "./chunk-IHCJ6PUT.js";
+
+// src/core/orchestrator.ts
+import { globSync as globSync2 } from "fs";
+import { resolve as resolve3, basename, parse as pathParse } from "path";
+
+// src/config/conventions.ts
+var SCHEMA_TYPES = [
+  "settings",
+  "configs",
+  "sections",
+  "blocks",
+  "section-blocks",
+  "section-groups"
+];
+var LIQUID_SCHEMA_TYPES = ["sections", "blocks", "section-blocks"];
+var LOCALE_SCHEMA_TYPES = [
+  "settings",
+  "configs",
+  "sections",
+  "blocks",
+  "section-blocks"
+];
+
+// src/core/schema-builder.ts
+import { readFile, writeFile } from "fs/promises";
+import { statSync, existsSync } from "fs";
+import { resolve, join } from "path";
+
+// src/utils/objects.ts
+function deepSortObjectKeys(value) {
+  if (Array.isArray(value)) {
+    return value.map((v) => deepSortObjectKeys(v));
+  }
+  if (value && typeof value === "object") {
+    const obj = value;
+    const sorted = {};
+    for (const key of Object.keys(obj).sort((a, b) => a.localeCompare(b))) {
+      sorted[key] = deepSortObjectKeys(obj[key]);
+    }
+    return sorted;
+  }
+  return value;
+}
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var isDebug = process.argv.includes("--debug") || process.env.NODE_ENV === "development" || process.env.NODE_ENV === "dev";
+var npmVerboseLogLevels = /* @__PURE__ */ new Set(["verbose", "silly"]);
+var isVerbose = process.argv.includes("--verbose") || process.env.BUILD_VERBOSE === "true" || npmVerboseLogLevels.has((process.env.npm_config_loglevel || "").toLowerCase());
+var ESC = String.fromCharCode(27);
+var ANSI_PATTERN = new RegExp(`${ESC}\\[[0-9;]*[a-zA-Z]`, "g");
+var CONTROL_CHAR_PATTERN = new RegExp(
+  `[${String.fromCharCode(0)}-${String.fromCharCode(31)}${String.fromCharCode(127)}-${String.fromCharCode(159)}\u2028\u2029]`,
+  "g"
+);
+var getChalkColor = (type) => {
+  switch (type) {
+    case "error":
+      return "red";
+    case "warn":
+      return "yellow";
+    case "info":
+      return "blue";
+    case "debug":
+      return "gray";
+    case "success":
+      return "green";
+    default:
+      return "white";
+  }
+};
+var log = (type = "log", ...args) => {
+  const shouldPrint = type === "error" || type === "warn" || type === "success" || isDebug || isVerbose && type === "info" || (isDebug || isVerbose) && type === "debug";
+  if (!shouldPrint) return;
+  const color = getChalkColor(type);
+  try {
+    if (type === "debug" || type === "success") {
+      console.log(chalk[color](...args));
+    } else {
+      console[type](
+        chalk[color](...args)
+      );
+    }
+  } catch {
+    console.log(chalk[color](...args));
+  }
+};
+
+// src/core/schema-builder.ts
+var SAFETY_COMMENT = "{% comment %} DON'T TOUCH - THIS WILL BE AUTO-GENERATED {% endcomment %}";
+var SAFETY_COMMENT_REGEX = /{%\s*comment\s*%}\s*DON'T TOUCH - THIS WILL BE AUTO-GENERATED\s*{%\s*endcomment\s*%}(\r?\n)?/g;
+function removeLabels(obj) {
+  const unwantedKeys = ["originalLabel", "defaultLabel", "fieldType"];
+  const removeKeys = (input) => {
+    if (Array.isArray(input)) {
+      return input.map(removeKeys);
+    } else if (typeof input === "object" && input !== null) {
+      const result = {};
+      Object.keys(input).forEach((key) => {
+        if (!unwantedKeys.includes(key) && input[key] !== "") {
+          result[key] = removeKeys(input[key]);
+        }
+      });
+      return result;
+    }
+    return input;
+  };
+  return removeKeys(obj);
+}
+function addTranslationKeys(obj, sectionName, type) {
+  const addKeys = (input, context = { path: [] }) => {
+    if (Array.isArray(input)) {
+      return input.map(
+        (item, index) => addKeys(item, { ...context, path: [...context.path, index.toString()] })
+      );
+    } else if (typeof input === "object" && input !== null) {
+      const result = { ...input };
+      if (result.name && context.path.length === 0) {
+        result.name = `t:${type}.${sectionName}.name`;
+      }
+      if (result.name && context.path.includes("blocks") && result.type) {
+        result.name = `t:${type}.${sectionName}.blocks.${result.type}.name`;
+      }
+      if (result.label && context.path.includes("settings") && result.id) {
+        if (context.blockType) {
+          result.label = `t:${type}.${sectionName}.blocks.${context.blockType}.settings.${result.id}.label`;
+        } else {
+          result.label = `t:${type}.${sectionName}.settings.${result.id}.label`;
+        }
+      }
+      if (result.info && context.path.includes("settings") && result.id) {
+        if (context.blockType) {
+          result.info = `t:${type}.${sectionName}.blocks.${context.blockType}.settings.${result.id}.info`;
+        } else {
+          result.info = `t:${type}.${sectionName}.settings.${result.id}.info`;
+        }
+      }
+      if (result.options && Array.isArray(result.options) && result.id) {
+        result.options = result.options.map((option, index) => {
+          if (typeof option === "object" && option !== null && "label" in option) {
+            const optionPath = context.blockType ? `${type}.${sectionName}.blocks.${context.blockType}.settings.${result.id}.options.option_${index + 1}` : `${type}.${sectionName}.settings.${result.id}.options.option_${index + 1}`;
+            return { ...option, label: `t:${optionPath}` };
+          }
+          return option;
+        });
+      }
+      Object.keys(result).forEach((key) => {
+        if (typeof result[key] === "object" && result[key] !== null) {
+          if (key === "blocks" && Array.isArray(result[key])) {
+            result[key] = result[key].map((block) => {
+              if (typeof block === "object" && block !== null && "type" in block) {
+                return addKeys(block, {
+                  path: [...context.path, "blocks"],
+                  blockType: block.type
+                });
+              }
+              return block;
+            });
+          } else if (key === "settings" && Array.isArray(result[key])) {
+            result[key] = result[key].map(
+              (setting) => addKeys(setting, {
+                path: [...context.path, "settings"],
+                blockType: context.blockType
+              })
+            );
+          } else {
+            result[key] = addKeys(result[key], context);
+          }
+        }
+      });
+      return result;
+    }
+    return input;
+  };
+  return addKeys(obj);
+}
+var stringifyCompact = (obj, indent = 0) => {
+  const spaces = "  ".repeat(indent);
+  if (Array.isArray(obj)) {
+    if (obj.length === 0) return "[]";
+    const allStrings = obj.every((item) => typeof item === "string");
+    const totalLength = obj.reduce((sum, item) => {
+      return sum + (typeof item === "string" ? item.length : 0);
+    }, 0);
+    if (allStrings && totalLength < 60) {
+      return `[${obj.map((item) => `"${item}"`).join(", ")}]`;
+    }
+    const items = obj.map((item) => `
+${spaces}  ${stringifyCompact(item, indent + 1)}`).join(",");
+    return `[${items}
+${spaces}]`;
+  }
+  if (obj && typeof obj === "object") {
+    const entries = Object.entries(obj);
+    if (entries.length === 0) return "{}";
+    const formatted = entries.map(([key, value]) => {
+      const formattedValue = stringifyCompact(value, indent + 1);
+      return `
+${spaces}  "${key}": ${formattedValue}`;
+    }).join(",");
+    return `{${formatted}
+${spaces}}`;
+  }
+  return JSON.stringify(obj);
+};
+var LIQUID_DIR_MAP = {
+  sections: "sections",
+  blocks: "blocks",
+  "section-blocks": "snippets"
+};
+async function buildLiquidSchema(filePath, schema, type, name, themeDir) {
+  const directory = LIQUID_DIR_MAP[type];
+  if (!directory) return;
+  const liquidFilePath = resolve(join(themeDir, directory, `${name}.liquid`));
+  if (!existsSync(liquidFilePath)) return;
+  try {
+    const inputMtime = statSync(filePath).mtimeMs;
+    const outputMtime = statSync(liquidFilePath).mtimeMs;
+    if (outputMtime > inputMtime) return;
+  } catch {
+  }
+  try {
+    const cleanedSchema = removeLabels(schema);
+    const translatedSchema = addTranslationKeys(cleanedSchema, name, type);
+    const sortedSchema = deepSortObjectKeys(translatedSchema);
+    const fileContent = await readFile(liquidFilePath, "utf-8");
+    const schemaIndex = fileContent.indexOf("{% schema %}");
+    const contentBeforeSchema = schemaIndex === -1 ? fileContent : fileContent.substring(0, schemaIndex);
+    const jsonString = stringifyCompact(sortedSchema);
+    const schemaJsonIndented = jsonString.split("\n").map((line) => `  ${line}`).join("\n");
+    const finalContent = `${contentBeforeSchema.trim()}
+
+{% schema %}
+${schemaJsonIndented}
+{% endschema %}
+`;
+    await writeFile(liquidFilePath, finalContent, "utf-8");
+    await addSafetyComment(liquidFilePath);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code !== "ENOENT") {
+      log("error", `Error processing schema file ${filePath}:`, error.message);
+    }
+  }
+}
+async function addSafetyComment(filePath) {
+  try {
+    let data = await readFile(filePath, "utf8");
+    if (data.indexOf("{% schema %}") === -1) return;
+    data = data.replace(SAFETY_COMMENT_REGEX, "");
+    const schemaIndex = data.indexOf("{% schema %}");
+    const contentBeforeSchema = data.slice(0, schemaIndex);
+    const contentAfterSchema = data.slice(schemaIndex);
+    const newData = `${contentBeforeSchema.trimEnd()}
+
+${SAFETY_COMMENT}
+${contentAfterSchema.trimEnd()}
+`;
+    await writeFile(filePath, newData, "utf8");
+  } catch (error) {
+    log("error", "Error adding safety comment:", error);
+  }
+}
+
+// src/core/config-builder.ts
+import { writeFile as writeFile2 } from "fs/promises";
+import { existsSync as existsSync2, globSync, readFileSync } from "fs";
+import { resolve as resolve2, join as join2 } from "path";
+
+// src/utils/schema-comment.ts
+var SCHEMA_COMMENT_HEADER = `/*
+ * ------------------------------------------------------------
+ * IMPORTANT: The contents of this file are auto-generated.
+ *
+ * This file may be updated by the Shopify admin language editor
+ * or related systems. Please exercise caution as any changes
+ * made to this file may be overwritten.
+ * ------------------------------------------------------------
+ */`;
+var addSchemaCommentHeader = (jsonContent) => {
+  return `${SCHEMA_COMMENT_HEADER}
+${jsonContent}`;
+};
+var createSchemaFileContent = (data) => {
+  const jsonContent = JSON.stringify(data, null, 2);
+  return addSchemaCommentHeader(jsonContent);
+};
+
+// src/utils/version.ts
+import { execSync } from "child_process";
+function resolveVersion() {
+  const envTag = process.env.RELEASE_TAG;
+  if (envTag) {
+    return stripVPrefix(envTag);
+  }
+  const tag = tryGitDescribe();
+  if (process.env.CI === "true") {
+    return tag ? stripVPrefix(tag) : "dev";
+  }
+  if (tag) {
+    return `${stripVPrefix(tag)}-dev`;
+  }
+  return "dev";
+}
+function tryGitDescribe() {
+  try {
+    const tag = execSync("git describe --tags --abbrev=0", {
+      encoding: "utf-8",
+      stdio: "pipe"
+    }).trim();
+    return tag || null;
+  } catch {
+    return null;
+  }
+}
+function stripVPrefix(tag) {
+  return tag.startsWith("v") ? tag.slice(1) : tag;
+}
+
+// src/core/config-builder.ts
+function removeLabels2(obj) {
+  const unwantedKeys = ["originalLabel", "defaultLabel", "fieldType"];
+  const removeKeys = (input) => {
+    if (Array.isArray(input)) {
+      return input.map(removeKeys);
+    } else if (typeof input === "object" && input !== null) {
+      const result = {};
+      Object.keys(input).forEach((key) => {
+        if (!unwantedKeys.includes(key) && input[key] !== "") {
+          result[key] = removeKeys(input[key]);
+        }
+      });
+      return result;
+    }
+    return input;
+  };
+  return removeKeys(obj);
+}
+function addTranslationKeys2(obj, configName) {
+  const addKeys = (input, context = { path: [] }) => {
+    if (Array.isArray(input)) {
+      return input.map(
+        (item, index) => addKeys(item, { ...context, path: [...context.path, index.toString()] })
+      );
+    } else if (typeof input === "object" && input !== null) {
+      const result = { ...input };
+      if (result.name && context.path.length === 0) {
+        result.name = `t:theme_settings.${configName}.name`;
+      }
+      if (result.label && context.path.includes("settings") && result.id) {
+        result.label = `t:theme_settings.${configName}.settings.${result.id}.label`;
+      }
+      if (result.info && context.path.includes("settings") && result.id) {
+        result.info = `t:theme_settings.${configName}.settings.${result.id}.info`;
+      }
+      if (result.options && Array.isArray(result.options) && result.id) {
+        result.options = result.options.map((option, index) => {
+          if (typeof option === "object" && option !== null && "label" in option) {
+            return {
+              ...option,
+              label: `t:theme_settings.${configName}.settings.${result.id}.options.option_${index + 1}`
+            };
+          }
+          return option;
+        });
+      }
+      Object.keys(result).forEach((key) => {
+        if (typeof result[key] === "object" && result[key] !== null) {
+          if (key === "settings" && Array.isArray(result[key])) {
+            result[key] = result[key].map(
+              (setting) => addKeys(setting, { path: [...context.path, "settings"] })
+            );
+          } else {
+            result[key] = addKeys(result[key], context);
+          }
+        }
+      });
+      return result;
+    }
+    return input;
+  };
+  return addKeys(obj);
+}
+function toPascalCamel(name) {
+  return name.charAt(0).toUpperCase() + name.slice(1).replace(/-([a-z])/g, (_, l) => l.toUpperCase());
+}
+function readExistingSchema(filePath) {
+  try {
+    const raw = readFileSync(filePath, "utf8");
+    const trimmed = raw.trimStart();
+    let jsonOnly = raw;
+    if (trimmed.startsWith("/*")) {
+      const end = trimmed.indexOf("*/");
+      if (end !== -1) jsonOnly = trimmed.slice(end + 2).trimStart();
+    }
+    const parsed = JSON.parse(jsonOnly);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+async function buildConfigs(paths, store, config) {
+  const configsDir = join2(paths.schemasDir, "configs");
+  const settingsSchemaPath = resolve2(join2(paths.configDir, "settings_schema.json"));
+  const pattern = join2(configsDir, "**/*.ts");
+  let files;
+  try {
+    files = globSync(pattern).filter((f) => !f.includes("index.ts")).sort();
+  } catch {
+    files = [];
+  }
+  const processedConfigs = [];
+  await Promise.all(
+    files.map(async (file) => {
+      const name = file.split("/").pop()?.replace(/\.ts$/, "") || "";
+      if (name === "theme-info") return;
+      try {
+        const module = await import(`${resolve2(file)}?t=${Date.now()}`);
+        const configFunctionName = `${toPascalCamel(name)}Config`;
+        const configFunction = module[configFunctionName];
+        if (!configFunction || typeof configFunction !== "function") {
+          log("warn", `No ${configFunctionName} function found in ${file}`);
+          return;
+        }
+        const schema = configFunction();
+        if (!schema || typeof schema !== "object") return;
+        const cleaned = removeLabels2(schema);
+        const translated = addTranslationKeys2(cleaned, name);
+        const sorted = deepSortObjectKeys(translated);
+        processedConfigs.push(sorted);
+      } catch (error) {
+        if (error instanceof Error && "code" in error && error.code !== "ENOENT") {
+          log("error", `Error processing config ${file}:`, error.message);
+        }
+      }
+    })
+  );
+  const themeInfoPath = resolve2(join2(configsDir, "theme-info"));
+  let themeInfo;
+  try {
+    const mod = await import(`${themeInfoPath}?t=${Date.now()}`);
+    if (!mod.ThemeInfoConfig || typeof mod.ThemeInfoConfig !== "function") {
+      throw new Error("ThemeInfoConfig not found");
+    }
+    themeInfo = mod.ThemeInfoConfig();
+  } catch {
+    log("warn", `Could not load ThemeInfoConfig; using default for store: ${store}`);
+    themeInfo = {
+      name: "theme_info",
+      theme_name: `${store} Theme`,
+      theme_author: "AKQA Denmark",
+      theme_version: "1.0.0",
+      theme_documentation_url: "https://akqa.com",
+      theme_support_email: "support@akqa.com"
+    };
+  }
+  themeInfo.theme_version = resolveVersion();
+  const storeConfig = config.stores.find((s) => s.slug === store);
+  if (storeConfig?.name) {
+    themeInfo.theme_name = storeConfig.name;
+  }
+  log("info", `\u2713 Injected theme info: ${themeInfo.theme_name} v${themeInfo.theme_version}`);
+  const hasProcessed = processedConfigs.length > 0;
+  let allConfigs;
+  if (hasProcessed) {
+    const sortedRest = processedConfigs.filter((c) => c.name !== "theme_info").sort((a, b) => (a?.name || "").localeCompare(b?.name || ""));
+    allConfigs = [themeInfo, ...sortedRest];
+  } else {
+    const existing = existsSync2(settingsSchemaPath) ? readExistingSchema(settingsSchemaPath) : [];
+    const rest = existing.filter((c) => c?.name !== "theme_info");
+    allConfigs = [themeInfo, ...rest];
+  }
+  const finalContent = createSchemaFileContent(deepSortObjectKeys(allConfigs));
+  await writeFile2(settingsSchemaPath, finalContent, "utf-8");
+  log("info", `\u2705 Generated settings_schema.json with ${allConfigs.length} config sections`);
+}
+
+// src/core/section-group-builder.ts
+import { readFile as readFile2, writeFile as writeFile3, mkdir } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { join as join3, dirname } from "path";
+var COMMENT_HEADER = `/*
+ * ------------------------------------------------------------
+ * IMPORTANT: The contents of this file are auto-generated.
+ *
+ * This file may be updated by the Shopify admin theme editor
+ * or related systems. Please exercise caution as any changes
+ * made to this file may be overwritten.
+ * ------------------------------------------------------------
+ */`;
+async function buildSectionGroupFile(schema, name, themeDir) {
+  try {
+    const sg = schema;
+    if (!sg?.type || !sg?.name) {
+      log("warn", `Section group "${name}" missing required 'type' or 'name'`);
+      return;
+    }
+    const outputPath = join3(themeDir, "sections", `${name}-group.json`);
+    await mkdir(dirname(outputPath), { recursive: true });
+    let existingSections = {};
+    let existingOrder = [];
+    if (existsSync3(outputPath)) {
+      try {
+        const raw = await readFile2(outputPath, "utf-8");
+        const jsonOnly = raw.trimStart().startsWith("/*") ? raw.slice(raw.indexOf("*/") + 2).trimStart() : raw;
+        const parsed = JSON.parse(jsonOnly);
+        existingSections = parsed.sections ?? {};
+        existingOrder = parsed.order ?? [];
+      } catch {
+        log("warn", `Could not parse existing ${name}-group.json \u2014 will create fresh`);
+      }
+    }
+    const output = {
+      type: sg.type,
+      name: sg.name,
+      sections: existingSections,
+      order: existingOrder
+    };
+    const fileContent = `${COMMENT_HEADER}
+${JSON.stringify(output, null, 2)}
+`;
+    await writeFile3(outputPath, fileContent, "utf-8");
+    log("info", `\u2713 Section group: ${name}-group.json`);
+  } catch (error) {
+    log("error", `Error building section group "${name}":`, error.message);
+  }
+}
+
+// src/utils/strings.ts
+function capitalizeFirstLetter(string) {
+  return string.charAt(0).toUpperCase() + string.slice(1);
+}
+function snakifyString(inputString) {
+  return inputString ? inputString.replace(/["\\/]/g, "").replace(/[\s-]+/g, "_").toLowerCase() : "";
+}
+function formatToName(fileName, type) {
+  const pascalCase = fileName.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+  if (type === "section-blocks") {
+    return `${pascalCase}Block`;
+  }
+  const suffix = capitalizeFirstLetter(type).slice(0, -1);
+  return `${pascalCase}${suffix}`;
+}
+
+// src/core/locale-extractor.ts
+function simplifyObject(obj) {
+  if (!obj || typeof obj !== "object") return void 0;
+  const o = obj;
+  const newObj = {};
+  if (o.name) newObj.name = o.name;
+  if (o.label) newObj.label = o.label;
+  if (o.info) newObj.info = o.info;
+  if (o.placeholder) newObj.placeholder = o.placeholder;
+  if (Array.isArray(o.options)) {
+    const options = {};
+    o.options.forEach((opt, index) => {
+      if (opt.label) {
+        options[`option_${index + 1}`] = opt.label;
+      }
+    });
+    if (Object.keys(options).length > 0) newObj.options = options;
+  }
+  if (Array.isArray(o.settings)) {
+    const settings = {};
+    o.settings.forEach((setting) => {
+      const id = setting.id || snakifyString(setting.label || "unknown");
+      if (id) {
+        const simplified = simplifyObject(setting);
+        if (simplified && Object.keys(simplified).length > 0) {
+          settings[id] = simplified;
+        }
+      }
+    });
+    if (Object.keys(settings).length > 0) newObj.settings = settings;
+  }
+  if (Array.isArray(o.blocks)) {
+    const blocks = {};
+    o.blocks.forEach((block) => {
+      const type = block.type || snakifyString(block.name || "unknown");
+      if (type) {
+        const simplified = simplifyObject(block);
+        if (simplified && Object.keys(simplified).length > 0) {
+          blocks[type] = simplified;
+        }
+      }
+    });
+    if (Object.keys(blocks).length > 0) newObj.blocks = blocks;
+  }
+  return Object.keys(newObj).length > 0 ? newObj : void 0;
+}
+function extractLocaleData(schema) {
+  return simplifyObject(schema) || {};
+}
+
+// src/core/locale-merger.ts
+import { writeFile as writeFile4 } from "fs/promises";
+import { join as join4 } from "path";
+async function mergeAndWriteLocales(accumulator, localesDir) {
+  const mergedData = {};
+  const typeMap = [
+    { accKey: "settings", outputKey: "global" },
+    { accKey: "configs", outputKey: "theme_settings" },
+    { accKey: "section-blocks", outputKey: "section_blocks" },
+    { accKey: "sections", outputKey: "sections" },
+    { accKey: "blocks", outputKey: "blocks" }
+  ];
+  for (const { accKey, outputKey } of typeMap) {
+    const typeData = accumulator[accKey];
+    if (!typeData || Object.keys(typeData).length === 0) continue;
+    mergedData[outputKey] = typeData;
+  }
+  const sortedData = deepSortObjectKeys(mergedData);
+  const finalContent = createSchemaFileContent(sortedData);
+  const outputPath = join4(localesDir, "en.default.schema.json");
+  await writeFile4(outputPath, finalContent, "utf-8");
+  log("info", `\u2705 Generated en.default.schema.json`);
+}
+
+// src/core/orchestrator.ts
+async function orchestrate(options) {
+  const { config, skipSchemas = false, skipLocales = false } = options;
+  const store = resolveStore(config, options.store);
+  const paths = getStorePaths(config, store);
+  const startTime = Date.now();
+  log("info", `Building store: ${store}`);
+  const localeAccumulator = {};
+  for (const schemaType of SCHEMA_TYPES) {
+    const schemaDir = `${paths.schemasDir}/${schemaType}`;
+    const pattern = `${schemaDir}/**/*.ts`;
+    let files;
+    try {
+      files = globSync2(pattern).filter((f) => !basename(f).startsWith("index.")).sort();
+    } catch {
+      continue;
+    }
+    if (files.length === 0) continue;
+    const batchSize = config.build.parallel ? Math.min(16, files.length) : 1;
+    for (let i = 0; i < files.length; i += batchSize) {
+      const batch = files.slice(i, i + batchSize);
+      await Promise.all(
+        batch.map(async (file) => {
+          const { name } = pathParse(file);
+          try {
+            const module = await import(`${resolve3(file)}?t=${Date.now()}`);
+            let schema = module.default || module[formatToName(name, schemaType)];
+            if (typeof schema === "function") schema = schema();
+            if (!schema) return;
+            if (!skipSchemas && LIQUID_SCHEMA_TYPES.includes(schemaType)) {
+              await buildLiquidSchema(file, schema, schemaType, name, paths.themeDir);
+            }
+            if (!skipSchemas && schemaType === "section-groups") {
+              await buildSectionGroupFile(schema, name, paths.themeDir);
+            }
+            if (!skipLocales && LOCALE_SCHEMA_TYPES.includes(schemaType)) {
+              const localeData = extractLocaleData(schema);
+              if (localeData && Object.keys(localeData).length > 0) {
+                if (!localeAccumulator[schemaType]) {
+                  localeAccumulator[schemaType] = {};
+                }
+                localeAccumulator[schemaType][name] = localeData;
+              }
+            }
+          } catch (error) {
+            if (error instanceof Error && "code" in error && error.code !== "ENOENT") {
+              log("error", `Error processing ${file}:`, error.message);
+            }
+          }
+        })
+      );
+    }
+  }
+  if (!skipSchemas) {
+    await buildConfigs(paths, store, config);
+  }
+  if (!skipLocales) {
+    await mergeAndWriteLocales(localeAccumulator, paths.localesDir);
+  }
+  const elapsed = Date.now() - startTime;
+  log("success", `Build completed in ${elapsed}ms`);
+}
+
+// src/cli/prepare.ts
+async function runPrepare(args) {
+  const storeFlag = args.indexOf("--store");
+  const store = storeFlag !== -1 ? args[storeFlag + 1] : void 0;
+  const config = await resolveConfig();
+  await orchestrate({
+    store,
+    config,
+    skipSchemas: args.includes("--skip-schemas"),
+    skipLocales: args.includes("--skip-locales")
+  });
+}
+export {
+  runPrepare
+};

package/dist/vite.d.ts

@@ -0,0 +1,5 @@
+import { UserConfig } from 'vite';
+
+declare function createViteConfig(overrides?: UserConfig): Promise<UserConfig>;
+
+export { createViteConfig };