@el-j/google-sheet-translations 1.3.3 → 2.0.0

package/dist/index.js

@@ -1,44 +1,1291 @@
 "use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_WAIT_SECONDS: () => DEFAULT_WAIT_SECONDS,
+  convertFromDataJsonFormat: () => convertFromDataJsonFormat,
+  convertToDataJsonFormat: () => convertToDataJsonFormat,
+  createAuthClient: () => createAuthClient,
+  createLocaleMapping: () => createLocaleMapping,
+  createSpreadsheet: () => createSpreadsheet,
+  default: () => index_default,
+  filterValidLocales: () => filterValidLocales,
+  findLocalChanges: () => findLocalChanges,
+  getLanguagePrefix: () => getLanguagePrefix,
+  getLocaleDisplayName: () => getLocaleDisplayName,
+  getNormalizedLocaleForHeader: () => getNormalizedLocaleForHeader,
+  getOriginalHeaderForLocale: () => getOriginalHeaderForLocale,
+  getSpreadSheetData: () => getSpreadSheetData,
+  getTranslationSummary: () => getTranslationSummary,
+  handleBidirectionalSync: () => handleBidirectionalSync,
+  isValidLocale: () => isValidLocale,
+  mergeSheets: () => mergeSheets,
+  normalizeLocaleCode: () => normalizeLocaleCode,
+  processRawRows: () => processRawRows,
+  readPublicSheet: () => readPublicSheet,
+  resolveLocaleWithFallback: () => resolveLocaleWithFallback,
+  updateSpreadsheetWithLocalChanges: () => updateSpreadsheetWithLocalChanges,
+  validateCredentials: () => validateCredentials,
+  validateEnv: () => validateEnv,
+  wait: () => wait,
+  withRetry: () => withRetry,
+  writeLanguageDataFile: () => writeLanguageDataFile,
+  writeLocalesFile: () => writeLocalesFile,
+  writeTranslationFiles: () => writeTranslationFiles
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/getSpreadSheetData.ts
+var import_node_fs5 = __toESM(require("node:fs"));
+var import_node_path4 = __toESM(require("node:path"));
+var import_google_spreadsheet2 = require("google-spreadsheet");
+
+// src/utils/auth.ts
+var import_google_auth_library = require("google-auth-library");
+
+// src/utils/validateEnv.ts
+function validateCredentials() {
+  const requiredVars = ["GOOGLE_CLIENT_EMAIL", "GOOGLE_PRIVATE_KEY"];
+  const missing = requiredVars.filter((v) => !process.env[v]);
+  if (missing.length > 0) {
+    throw new Error(
+      `Missing required environment variables: ${missing.join(", ")}
+
+Make sure these are set in your .env file or environment.`
+    );
+  }
+  return {
+    GOOGLE_CLIENT_EMAIL: process.env.GOOGLE_CLIENT_EMAIL,
+    GOOGLE_PRIVATE_KEY: process.env.GOOGLE_PRIVATE_KEY
+  };
+}
+function validateEnv() {
+  const requiredVars = [
+    "GOOGLE_CLIENT_EMAIL",
+    "GOOGLE_PRIVATE_KEY",
+    "GOOGLE_SPREADSHEET_ID"
+  ];
+  const missingVars = requiredVars.filter((varName) => !process.env[varName]);
+  if (missingVars.length > 0) {
+    throw new Error(
+      `Missing required environment variables: ${missingVars.join(", ")}
+
+Make sure these are set in your .env file or environment.`
+    );
+  }
+  return {
+    GOOGLE_CLIENT_EMAIL: process.env.GOOGLE_CLIENT_EMAIL,
+    GOOGLE_PRIVATE_KEY: process.env.GOOGLE_PRIVATE_KEY,
+    GOOGLE_SPREADSHEET_ID: process.env.GOOGLE_SPREADSHEET_ID
+  };
+}
+
+// src/utils/auth.ts
+function createAuthClient() {
+  const { GOOGLE_CLIENT_EMAIL, GOOGLE_PRIVATE_KEY } = validateCredentials();
+  const normalizedKey = GOOGLE_PRIVATE_KEY.replace(/\\n/g, "\n");
+  return new import_google_auth_library.JWT({
+    email: GOOGLE_CLIENT_EMAIL,
+    key: normalizedKey,
+    scopes: ["https://www.googleapis.com/auth/spreadsheets"]
+  });
+}
+
+// src/utils/configurationHandler.ts
+var import_node_path = __toESM(require("node:path"));
+
+// src/constants.ts
+var DEFAULT_WAIT_SECONDS = 1;
+
+// src/utils/configurationHandler.ts
+function normalizeConfig(options = {}) {
+  return {
+    rowLimit: options.rowLimit ?? 100,
+    waitSeconds: options.waitSeconds ?? DEFAULT_WAIT_SECONDS,
+    dataJsonPath: options.dataJsonPath ?? import_node_path.default.join(process.cwd(), "src/lib/languageData.json"),
+    localesOutputPath: options.localesOutputPath ?? import_node_path.default.join(process.cwd(), "src/i18n/locales.ts"),
+    translationsOutputDir: options.translationsOutputDir ?? import_node_path.default.join(process.cwd(), "translations"),
+    syncLocalChanges: options.syncLocalChanges !== false,
+    // Default to true
+    autoTranslate: options.autoTranslate === true,
+    // Default to false
+    spreadsheetId: options.spreadsheetId,
+    publicSheet: options.publicSheet === true,
+    // Default to false
+    autoCreate: options.autoCreate !== false,
+    // Default to true
+    spreadsheetTitle: options.spreadsheetTitle ?? "google-sheet-translations",
+    sourceLocale: options.sourceLocale ?? "en",
+    targetLocales: options.targetLocales ?? ["de", "fr", "es", "it", "pt", "ja", "zh"]
+  };
+}
+
+// src/utils/rateLimiter.ts
+var import_promises = require("node:timers/promises");
+var DEFAULT_RETRIES = 3;
+var DEFAULT_MAX_DELAY_MS = 3e4;
+function isRateLimitError(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  const response = e["response"];
+  const status = typeof e["status"] === "number" ? e["status"] : typeof response?.["status"] === "number" ? response["status"] : void 0;
+  return status === 429 || status === 503;
+}
+async function withRetry(fn, label, baseDelayMs = 1e3, retries = DEFAULT_RETRIES, maxDelayMs = DEFAULT_MAX_DELAY_MS) {
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      if (!isRateLimitError(err) || attempt === retries) throw err;
+      const backoff = Math.min(baseDelayMs * 2 ** attempt, maxDelayMs);
+      console.warn(
+        `[rate-limit] ${label}: retry ${attempt + 1}/${retries} in ${backoff} ms`
+      );
+      await (0, import_promises.setTimeout)(backoff);
+    }
+  }
+  throw new Error("withRetry: unreachable");
+}
+
+// src/utils/localeFilter.ts
+var COMMON_LOCALE_PATTERNS = [
+  /^[a-z]{2}$/,
+  // en, de, fr
+  /^[a-z]{2}-[a-z]{2}$/,
+  // en-us, de-de
+  /^[a-z]{2}_[a-z]{2}$/,
+  // en_us, de_de
+  /^[a-z]{2}-[a-z]{2}-[a-z]+$/
+  // en-us-traditional
+];
+var NON_LOCALE_KEYWORDS = [
+  "key",
+  "keys",
+  "id",
+  "identifier",
+  "name",
+  "title",
+  "label",
+  "description",
+  "comment",
+  "note",
+  "context",
+  "category",
+  "type",
+  "status",
+  "updated",
+  "created",
+  "modified",
+  "version",
+  "source",
+  "i18n",
+  "translation",
+  "namespace",
+  "section"
+];
+function isValidLocale(value) {
+  if (!value || typeof value !== "string") {
+    return false;
+  }
+  const normalized = value.toLowerCase().trim();
+  if (NON_LOCALE_KEYWORDS.includes(normalized)) {
+    return false;
+  }
+  return COMMON_LOCALE_PATTERNS.some((pattern) => pattern.test(normalized));
+}
+function filterValidLocales(headerRow, keyColumn) {
+  return headerRow.filter((column) => column.toLowerCase() !== keyColumn.toLowerCase()).filter((column) => isValidLocale(column)).map((locale) => locale.toLowerCase());
+}
+
+// src/utils/localeNormalizer.ts
+function getLanguagePrefix(locale) {
+  return locale.toLowerCase().split(/[-_]/)[0];
+}
+var LANGUAGE_TO_COUNTRY_MAP = {
+  "en": "en-GB",
+  "de": "de-DE",
+  "fr": "fr-FR",
+  "es": "es-ES",
+  "it": "it-IT",
+  "pt": "pt-PT",
+  "pl": "pl-PL",
+  "ru": "ru-RU",
+  "zh": "zh-CN",
+  "ja": "ja-JP",
+  "ko": "ko-KR",
+  "ar": "ar-SA",
+  "hi": "hi-IN",
+  "th": "th-TH",
+  "vi": "vi-VN",
+  "tr": "tr-TR",
+  "nl": "nl-NL",
+  "sv": "sv-SE",
+  "da": "da-DK",
+  "no": "no-NO",
+  "fi": "fi-FI",
+  "cs": "cs-CZ",
+  "sk": "sk-SK",
+  "hu": "hu-HU",
+  "ro": "ro-RO",
+  "bg": "bg-BG",
+  "hr": "hr-HR",
+  "sl": "sl-SI",
+  "et": "et-EE",
+  "lv": "lv-LV",
+  "lt": "lt-LT",
+  "el": "el-GR",
+  "he": "he-IL",
+  "uk": "uk-UA",
+  "be": "be-BY"
+};
+function normalizeLocaleCode(locale) {
+  if (!locale || typeof locale !== "string") {
+    return "";
+  }
+  const normalized = locale.toLowerCase().trim();
+  if (normalized.includes("-") || normalized.includes("_")) {
+    return normalized;
+  }
+  const withCountry = LANGUAGE_TO_COUNTRY_MAP[normalized];
+  if (withCountry) {
+    return withCountry;
+  }
+  if (normalized.length === 2 && /^[a-z]{2}$/.test(normalized)) {
+    return `${normalized}-${normalized.toUpperCase()}`;
+  }
+  return normalized;
+}
+function createLocaleMapping(originalHeaders, keyColumn) {
+  const localeMapping = {};
+  const originalMapping = {};
+  const normalizedLocales = [];
+  for (const header of originalHeaders) {
+    const headerLower = header.toLowerCase();
+    if (headerLower === keyColumn.toLowerCase()) {
+      continue;
+    }
+    const isLocale = /^[a-z]{2}([_-][a-z]{2})?([_-][a-z]+)?$/.test(headerLower);
+    if (!isLocale) {
+      continue;
+    }
+    const normalized = normalizeLocaleCode(headerLower);
+    localeMapping[normalized] = header;
+    originalMapping[headerLower] = normalized;
+    normalizedLocales.push(normalized);
+  }
+  return {
+    normalizedLocales: [...new Set(normalizedLocales)],
+    // Remove duplicates
+    localeMapping,
+    // normalized -> original header
+    originalMapping
+    // original header (lowercase) -> normalized
+  };
+}
+function getOriginalHeaderForLocale(normalizedLocale, localeMapping) {
+  let result = localeMapping[normalizedLocale];
+  if (result) return result;
+  const lowercaseLocale = normalizedLocale.toLowerCase();
+  result = localeMapping[lowercaseLocale];
+  if (result) return result;
+  for (const [key, value] of Object.entries(localeMapping)) {
+    if (key.toLowerCase() === lowercaseLocale) {
+      return value;
+    }
+  }
+  const inputLangCode = getLanguagePrefix(normalizedLocale);
+  for (const [key, value] of Object.entries(localeMapping)) {
+    if (getLanguagePrefix(key) === inputLangCode) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function getNormalizedLocaleForHeader(originalHeader, originalMapping) {
+  return originalMapping[originalHeader.toLowerCase()];
+}
+function resolveLocaleWithFallback(locale, availableLocales) {
+  if (availableLocales.includes(locale)) return locale;
+  const lower = locale.toLowerCase();
+  const lowerMatch = availableLocales.find((l) => l === lower);
+  if (lowerMatch) return lowerMatch;
+  const langCode = getLanguagePrefix(lower);
+  return availableLocales.find((l) => getLanguagePrefix(l) === langCode);
+}
+
+// src/utils/sheetProcessor.ts
+async function processRawRows(rows, sheetTitle) {
+  const result = {
+    translations: {},
+    locales: [],
+    localeMapping: {},
+    originalMapping: {},
+    success: false
+  };
+  try {
+    if (!rows || rows.length === 0) {
+      console.warn(`No rows found in sheet "${sheetTitle}"`);
+      return result;
+    }
+    const headerRow = Object.keys(rows[0]).map((key) => key.toLowerCase());
+    console.log(`Header row for sheet "${sheetTitle}":`, headerRow);
+    const keyColumn = headerRow[0];
+    const validLocales = filterValidLocales(headerRow, keyColumn);
+    if (validLocales.length === 0) {
+      console.warn(`No valid locale columns found in sheet "${sheetTitle}"`);
+      return result;
+    }
+    const originalHeaders = Object.keys(rows[0]);
+    const { normalizedLocales, localeMapping, originalMapping } = createLocaleMapping(
+      originalHeaders,
+      keyColumn
+    );
+    result.localeMapping = localeMapping;
+    result.originalMapping = originalMapping;
+    for (const normalizedLocale of normalizedLocales) {
+      const originalHeader = localeMapping[normalizedLocale];
+      if (!originalHeader) continue;
+      const languageCells = rows.map((row) => {
+        const keyField = Object.keys(row).find((k) => k.toLowerCase() === keyColumn);
+        if (!keyField || !row[keyField] || !row[originalHeader]) {
+          return {};
+        }
+        const rowLocal = {};
+        rowLocal[row[keyField].toString().toLowerCase()] = row[originalHeader];
+        return rowLocal;
+      });
+      const nonEmptyLanguageCells = languageCells.filter(
+        (cell) => Object.keys(cell).length > 0
+      );
+      const prepareObj = {};
+      prepareObj[sheetTitle] = nonEmptyLanguageCells.reduce(
+        (acc, cell) => Object.assign(acc, cell),
+        {}
+      );
+      if (result.translations[normalizedLocale]) {
+        result.translations[normalizedLocale] = {
+          ...result.translations[normalizedLocale],
+          ...prepareObj
+        };
+      } else {
+        result.translations[normalizedLocale] = { ...prepareObj };
+      }
+    }
+    result.locales = normalizedLocales;
+    result.success = true;
+  } catch (error) {
+    console.error(`Error processing sheet "${sheetTitle}":`, error);
+  }
+  return result;
+}
+async function processSheet(sheet, sheetTitle, rowLimit, baseDelayMs = 1e3) {
+  const emptyResult = {
+    translations: {},
+    locales: [],
+    localeMapping: {},
+    originalMapping: {},
+    success: false
+  };
+  try {
+    const googleRows = await withRetry(
+      () => sheet.getRows({ limit: rowLimit }),
+      `getRows: ${sheetTitle}`,
+      baseDelayMs
+    );
+    if (!googleRows || googleRows.length === 0) {
+      console.warn(`No rows found in sheet "${sheetTitle}"`);
+      return emptyResult;
+    }
+    const rows = googleRows.map((row) => row.toObject());
+    return processRawRows(rows, sheetTitle);
+  } catch (error) {
+    console.error(`Error processing sheet "${sheetTitle}":`, error);
+    return emptyResult;
+  }
+}
+
+// src/utils/fileWriter.ts
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path2 = __toESM(require("node:path"));
+
+// src/utils/dataConverter/convertToDataJsonFormat.ts
+function convertToDataJsonFormat(translationObj, locales) {
+  const result = [];
+  console.log("Converting translation object to languageData.json format...");
+  const allSheets = /* @__PURE__ */ new Set();
+  for (const locale of Object.keys(translationObj)) {
+    if (translationObj[locale]) {
+      for (const sheet of Object.keys(translationObj[locale])) {
+        allSheets.add(sheet);
+      }
+    }
+  }
+  console.log(`Found ${allSheets.size} sheets across all locales`);
+  for (const sheetTitle of allSheets) {
+    const projectData = {};
+    projectData[sheetTitle] = {};
+    for (const locale of locales) {
+      if (translationObj?.[locale]?.[sheetTitle]) {
+        projectData[sheetTitle][locale] = {};
+        const translations = translationObj[locale][sheetTitle];
+        for (const key of Object.keys(translations)) {
+          projectData[sheetTitle][locale][key] = translations[key];
+        }
+        console.log(
+          `Found ${Object.keys(translations).length} keys for locale ${locale} in sheet ${sheetTitle}`
+        );
+      }
+    }
+    if (Object.keys(projectData[sheetTitle]).length > 0) {
+      result.push(projectData);
+    }
+  }
+  console.log(`Created ${result.length} sheet entries for languageData.json`);
+  return result;
+}
+
+// src/utils/fileWriter.ts
+function writeTranslationFiles(translations, locales, translationsOutputDir) {
+  if (!import_node_fs.default.existsSync(translationsOutputDir)) {
+    try {
+      import_node_fs.default.mkdirSync(translationsOutputDir, { recursive: true });
+    } catch (err) {
+      throw new Error(`Failed to create translations directory "${translationsOutputDir}"`, { cause: err });
+    }
+  }
+  for (const locale of locales) {
+    if (!translations[locale] || Object.keys(translations[locale]).length === 0) {
+      console.warn(`No translations found for locale "${locale}"`);
+      continue;
+    }
+    const safeName = locale.toLowerCase().replace(/[^a-z0-9_-]/g, "_");
+    if (safeName !== locale.toLowerCase()) {
+      console.warn(`Locale "${locale}" contained unsafe characters; sanitised to "${safeName}"`);
+    }
+    try {
+      import_node_fs.default.writeFileSync(
+        import_node_path2.default.join(translationsOutputDir, `${safeName}.json`),
+        JSON.stringify(translations[locale], null, 2),
+        "utf8"
+      );
+      console.log(`Successfully wrote translations for ${locale}`);
+    } catch (err) {
+      console.error(
+        `Failed to write translation file for locale "${locale}" at "${import_node_path2.default.join(translationsOutputDir, `${safeName}.json`)}":`,
+        err
+      );
+    }
+  }
+}
+function writeLocalesFile(locales, localeMapping, localesOutputPath) {
+  const localesOutputDir = import_node_path2.default.dirname(localesOutputPath);
+  if (!import_node_fs.default.existsSync(localesOutputDir)) {
+    try {
+      import_node_fs.default.mkdirSync(localesOutputDir, { recursive: true });
+    } catch (err) {
+      throw new Error(`Failed to create directory "${localesOutputDir}"`, { cause: err });
+    }
+  }
+  const validLocales = locales.filter((locale) => locale && locale.trim().length > 0);
+  const content = `/**
+ * This file is auto-generated from the Google Spreadsheet package.
+ * It contains the list of available locales and their mappings to original spreadsheet headers.
+ * Do not edit this file manually, it will be overwritten by the package.
+ */
+
+ export const locales = ${JSON.stringify(validLocales)};
+
 /**
- * Google Sheet Translation Manager Package
- * Public API surface – see package.json for current version
+ * Mapping from normalized locale codes to original spreadsheet headers
+ * Used for syncing changes back to the spreadsheet
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.filterValidLocales = exports.isValidLocale = exports.validateCredentials = exports.createSpreadsheet = exports.readPublicSheet = exports.updateSpreadsheetWithLocalChanges = exports.findLocalChanges = exports.convertFromDataJsonFormat = exports.convertToDataJsonFormat = exports.createAuthClient = exports.validateEnv = exports.withRetry = exports.wait = exports.DEFAULT_WAIT_SECONDS = exports.getSpreadSheetData = void 0;
-// Main entry point
-var getSpreadSheetData_1 = require("./getSpreadSheetData");
-Object.defineProperty(exports, "getSpreadSheetData", { enumerable: true, get: function () { return getSpreadSheetData_1.getSpreadSheetData; } });
-Object.defineProperty(exports, "DEFAULT_WAIT_SECONDS", { enumerable: true, get: function () { return getSpreadSheetData_1.DEFAULT_WAIT_SECONDS; } });
-// Utility functions required by dependents
-var wait_1 = require("./utils/wait");
-Object.defineProperty(exports, "wait", { enumerable: true, get: function () { return wait_1.wait; } });
-var rateLimiter_1 = require("./utils/rateLimiter");
-Object.defineProperty(exports, "withRetry", { enumerable: true, get: function () { return rateLimiter_1.withRetry; } });
-var validateEnv_1 = require("./utils/validateEnv");
-Object.defineProperty(exports, "validateEnv", { enumerable: true, get: function () { return validateEnv_1.validateEnv; } });
-var auth_1 = require("./utils/auth");
-Object.defineProperty(exports, "createAuthClient", { enumerable: true, get: function () { return auth_1.createAuthClient; } });
-var convertToDataJsonFormat_1 = require("./utils/dataConverter/convertToDataJsonFormat");
-Object.defineProperty(exports, "convertToDataJsonFormat", { enumerable: true, get: function () { return convertToDataJsonFormat_1.convertToDataJsonFormat; } });
-var convertFromDataJsonFormat_1 = require("./utils/dataConverter/convertFromDataJsonFormat");
-Object.defineProperty(exports, "convertFromDataJsonFormat", { enumerable: true, get: function () { return convertFromDataJsonFormat_1.convertFromDataJsonFormat; } });
-var findLocalChanges_1 = require("./utils/dataConverter/findLocalChanges");
-Object.defineProperty(exports, "findLocalChanges", { enumerable: true, get: function () { return findLocalChanges_1.findLocalChanges; } });
-var spreadsheetUpdater_1 = require("./utils/spreadsheetUpdater");
-Object.defineProperty(exports, "updateSpreadsheetWithLocalChanges", { enumerable: true, get: function () { return spreadsheetUpdater_1.updateSpreadsheetWithLocalChanges; } });
-// Public (unauthenticated) sheet reader
-var publicSheetReader_1 = require("./utils/publicSheetReader");
-Object.defineProperty(exports, "readPublicSheet", { enumerable: true, get: function () { return publicSheetReader_1.readPublicSheet; } });
-// Auto-create spreadsheet utility
-var spreadsheetCreator_1 = require("./utils/spreadsheetCreator");
-Object.defineProperty(exports, "createSpreadsheet", { enumerable: true, get: function () { return spreadsheetCreator_1.createSpreadsheet; } });
-var validateEnv_2 = require("./utils/validateEnv");
-Object.defineProperty(exports, "validateCredentials", { enumerable: true, get: function () { return validateEnv_2.validateCredentials; } });
-// Locale validation utilities (useful standalone)
-var localeFilter_1 = require("./utils/localeFilter");
-Object.defineProperty(exports, "isValidLocale", { enumerable: true, get: function () { return localeFilter_1.isValidLocale; } });
-Object.defineProperty(exports, "filterValidLocales", { enumerable: true, get: function () { return localeFilter_1.filterValidLocales; } });
-// Default export
-const getSpreadSheetData_2 = require("./getSpreadSheetData");
-exports.default = getSpreadSheetData_2.getSpreadSheetData;
-//# sourceMappingURL=index.js.map
+export const localeHeaderMapping = ${JSON.stringify(localeMapping, null, 2)};
+
+export default locales;
+`;
+  try {
+    import_node_fs.default.writeFileSync(localesOutputPath, content, "utf8");
+  } catch (err) {
+    throw new Error(`Failed to write locales file at "${localesOutputPath}"`, { cause: err });
+  }
+  console.log(`Successfully wrote locales file with ${validLocales.length} locales:`, validLocales);
+  console.log("Header mapping includes:", Object.keys(localeMapping).length, "mappings");
+}
+function writeLanguageDataFile(translations, locales, dataJsonPath) {
+  const dataJsonDir = import_node_path2.default.dirname(dataJsonPath);
+  if (!import_node_fs.default.existsSync(dataJsonDir)) {
+    try {
+      import_node_fs.default.mkdirSync(dataJsonDir, { recursive: true });
+    } catch (err) {
+      throw new Error(`Failed to create directory "${dataJsonDir}"`, { cause: err });
+    }
+  }
+  const dataJsonContent = convertToDataJsonFormat(translations, locales);
+  try {
+    import_node_fs.default.writeFileSync(
+      dataJsonPath,
+      JSON.stringify(dataJsonContent, null, 2),
+      "utf8"
+    );
+  } catch (err) {
+    throw new Error(`Failed to write language data file at "${dataJsonPath}"`, { cause: err });
+  }
+  console.log("Successfully updated languageData.json with fresh spreadsheet data");
+}
+
+// src/utils/dataConverter/findLocalChanges.ts
+function findLocalChanges(localData, spreadsheetData) {
+  const changes = {};
+  for (const locale of Object.keys(localData)) {
+    if (!localData[locale]) continue;
+    const resolvedLocale = resolveLocaleWithFallback(locale, Object.keys(spreadsheetData));
+    for (const sheet of Object.keys(localData[locale])) {
+      if (!localData[locale][sheet]) continue;
+      for (const key of Object.keys(localData[locale][sheet])) {
+        const isNewKey = !resolvedLocale || !spreadsheetData[resolvedLocale]?.[sheet] || !spreadsheetData[resolvedLocale][sheet][key];
+        if (isNewKey) {
+          if (!changes[locale]) changes[locale] = {};
+          if (!changes[locale][sheet]) changes[locale][sheet] = {};
+          changes[locale][sheet][key] = localData[locale][sheet][key];
+        }
+      }
+    }
+  }
+  return changes;
+}
+
+// src/utils/spreadsheetUpdater.ts
+function columnIndexToLetter(index) {
+  let result = "";
+  let i = index;
+  do {
+    result = String.fromCharCode(65 + i % 26) + result;
+    i = Math.floor(i / 26) - 1;
+  } while (i >= 0);
+  return result;
+}
+async function updateSpreadsheetWithLocalChanges(doc, changes, waitSeconds, autoTranslate = false, localeMapping = {}) {
+  console.log("Updating spreadsheet with local changes...");
+  const baseDelayMs = waitSeconds * 1e3;
+  for (const sheetTitle of new Set(
+    Object.values(changes).flatMap((locale) => Object.keys(locale))
+  )) {
+    console.log(`Processing sheet: ${sheetTitle}`);
+    let sheet = doc.sheetsByTitle[sheetTitle];
+    if (!sheet) {
+      const localeHeaders = Object.values(localeMapping);
+      if (localeHeaders.length === 0) {
+        console.warn(`Sheet "${sheetTitle}" not found in the document, cannot update`);
+        continue;
+      }
+      console.log(`Sheet "${sheetTitle}" not found \u2014 creating it with ${localeHeaders.length} locale column(s).`);
+      sheet = await withRetry(
+        () => doc.addSheet({ title: sheetTitle, headerValues: ["key", ...localeHeaders] }),
+        `addSheet: ${sheetTitle}`,
+        baseDelayMs
+      );
+    }
+    if (!sheet) {
+      console.warn(`Sheet "${sheetTitle}" could not be found or created, skipping.`);
+      continue;
+    }
+    const rows = await withRetry(
+      () => sheet.getRows(),
+      `getRows: ${sheetTitle}`,
+      baseDelayMs
+    );
+    let headerRow;
+    let originalHeaders;
+    if (rows.length > 0) {
+      originalHeaders = Object.keys(rows[0].toObject());
+      headerRow = originalHeaders.map((h) => h.toLowerCase());
+    } else {
+      const localeHeaders = Object.values(localeMapping);
+      if (localeHeaders.length === 0) {
+        console.warn(`No rows found in sheet "${sheetTitle}", cannot update`);
+        continue;
+      }
+      originalHeaders = ["key", ...localeHeaders];
+      headerRow = originalHeaders.map((h) => h.toLowerCase());
+    }
+    const keyColumn = headerRow[0];
+    const locales = headerRow.filter((key) => key !== keyColumn);
+    const existingKeys = /* @__PURE__ */ new Map();
+    rows.forEach((row, index) => {
+      const rowData = row.toObject();
+      const keyField = Object.keys(rowData).find((k) => k.toLowerCase() === keyColumn);
+      if (keyField && rowData[keyField]) {
+        existingKeys.set(rowData[keyField].toString().toLowerCase(), index);
+      }
+    });
+    const newKeys = /* @__PURE__ */ new Map();
+    const keyLocalesMap = /* @__PURE__ */ new Map();
+    for (const locale of Object.keys(changes)) {
+      if (!changes[locale]?.[sheetTitle]) continue;
+      const localeData = changes[locale][sheetTitle];
+      for (const key of Object.keys(localeData)) {
+        const keyLower = key.toLowerCase();
+        if (!existingKeys.has(keyLower)) {
+          if (!newKeys.has(keyLower)) {
+            newKeys.set(keyLower, { [keyColumn]: key });
+            keyLocalesMap.set(keyLower, /* @__PURE__ */ new Map());
+          }
+          let localeHeader = getOriginalHeaderForLocale(locale, localeMapping);
+          if (!localeHeader) {
+            const localeLang = getLanguagePrefix(locale);
+            localeHeader = originalHeaders.find(
+              (h) => getLanguagePrefix(h) === localeLang
+            );
+          }
+          if (localeHeader) {
+            const theKey = newKeys.get(keyLower);
+            if (!theKey) {
+              console.warn(`Key "${key}" not found in newKeys map, skipping...`);
+              continue;
+            }
+            const value = String(localeData[key]);
+            theKey[localeHeader] = value;
+            const localesForKey = keyLocalesMap.get(keyLower);
+            if (localesForKey) {
+              localesForKey.set(locale.toLowerCase(), localeHeader);
+            }
+          }
+        } else {
+          const rowIndex = existingKeys.get(keyLower);
+          const row = rows[rowIndex];
+          let localeHeader = getOriginalHeaderForLocale(locale, localeMapping);
+          if (!localeHeader) {
+            const localeLang = getLanguagePrefix(locale);
+            localeHeader = Object.keys(row.toObject()).find(
+              (h) => getLanguagePrefix(h) === localeLang
+            );
+          }
+          if (localeHeader) {
+            row.set(localeHeader, String(localeData[key]));
+            try {
+              await withRetry(
+                () => row.save(),
+                `save row ${rowIndex} in ${sheetTitle}`,
+                baseDelayMs
+              );
+            } catch (err) {
+              console.error(
+                `Failed to save row for key "${keyLower}" in sheet "${sheetTitle}":`,
+                err
+              );
+            }
+          }
+        }
+      }
+    }
+    if (newKeys.size > 0) {
+      console.log(`Adding ${newKeys.size} new keys to sheet ${sheetTitle}...`);
+      if (autoTranslate) {
+        for (const [keyLower, rowData] of newKeys.entries()) {
+          const localesWithValues = keyLocalesMap.get(keyLower);
+          if (localesWithValues && localesWithValues.size > 0) {
+            const [, sourceHeader] = [...localesWithValues.entries()][0];
+            for (const localeHeader of locales) {
+              const localeLower = localeHeader.toLowerCase();
+              const rowDataKey = Object.keys(rowData).find((k) => k.toLowerCase() === localeLower);
+              if (localesWithValues.has(localeLower) || rowDataKey && rowData[rowDataKey]) {
+                continue;
+              }
+              const exactHeaderName = headerRow.find(
+                (h) => h.toLowerCase() === localeLower
+              );
+              if (exactHeaderName) {
+                const sourceHeaderIndex = headerRow.indexOf(sourceHeader.toLowerCase());
+                const targetHeaderIndex = headerRow.indexOf(exactHeaderName);
+                if (sourceHeaderIndex < 0 || targetHeaderIndex < 0) {
+                  continue;
+                }
+                const sourceColumnLetter = columnIndexToLetter(sourceHeaderIndex);
+                const targetColumnLetter = columnIndexToLetter(targetHeaderIndex);
+                rowData[exactHeaderName] = `=GOOGLETRANSLATE(INDIRECT("${sourceColumnLetter}"&ROW());$${sourceColumnLetter}$1;${targetColumnLetter}$1)`;
+              }
+            }
+          }
+        }
+      }
+      const newRows = Array.from(newKeys.values());
+      const CHUNK_SIZE = 5;
+      for (let i = 0; i < newRows.length; i += CHUNK_SIZE) {
+        const chunk = newRows.slice(i, i + CHUNK_SIZE);
+        await withRetry(
+          () => sheet.addRows(chunk),
+          `addRows chunk ${Math.floor(i / CHUNK_SIZE) + 1} in ${sheetTitle}`,
+          baseDelayMs
+        );
+      }
+    }
+  }
+  console.log("Finished updating spreadsheet with local changes.");
+}
+
+// src/utils/isDataJsonNewer.ts
+var import_node_fs3 = __toESM(require("node:fs"));
+var import_node_path3 = __toESM(require("node:path"));
+
+// src/utils/getFileLastModified.ts
+var import_node_fs2 = __toESM(require("node:fs"));
+function getFileLastModified(filePath) {
+  try {
+    const stats = import_node_fs2.default.statSync(filePath);
+    return stats.mtime;
+  } catch (error) {
+    console.warn(`Could not read file stats for "${filePath}":`, error);
+    return null;
+  }
+}
+
+// src/utils/isDataJsonNewer.ts
+function isDataJsonNewer(dataJsonPath, translationsOutputDir) {
+  const dataJsonMtime = getFileLastModified(dataJsonPath);
+  if (!dataJsonMtime) return false;
+  try {
+    const files = import_node_fs3.default.readdirSync(translationsOutputDir).filter((file) => file.endsWith(".json")).map((file) => import_node_path3.default.join(translationsOutputDir, file));
+    if (files.length === 0) return true;
+    const mostRecentTranslationMtime = files.map((file) => getFileLastModified(file)).filter((d) => d !== null).reduce(
+      (max, d) => max === null || d > max ? d : max,
+      null
+    );
+    if (!mostRecentTranslationMtime) return true;
+    return dataJsonMtime > mostRecentTranslationMtime;
+  } catch (error) {
+    console.warn("Error comparing file modification times:", error);
+    return false;
+  }
+}
+
+// src/utils/readDataJson.ts
+var import_node_fs4 = __toESM(require("node:fs"));
+
+// src/utils/dataConverter/convertFromDataJsonFormat.ts
+function isSheetData(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function convertFromDataJsonFormat(dataJson) {
+  const result = {};
+  for (const projectData of dataJson) {
+    for (const sheetTitle of Object.keys(projectData)) {
+      const raw = projectData[sheetTitle];
+      if (!isSheetData(raw)) {
+        console.warn(`Skipping malformed entry for sheet "${sheetTitle}"`);
+        continue;
+      }
+      for (const locale of Object.keys(raw)) {
+        if (!result[locale]) {
+          result[locale] = {};
+        }
+        if (!result[locale][sheetTitle]) {
+          result[locale][sheetTitle] = {};
+        }
+        const localeData = raw[locale];
+        if (typeof localeData !== "object" || localeData === null) {
+          continue;
+        }
+        for (const key of Object.keys(localeData)) {
+          result[locale][sheetTitle][key] = localeData[key];
+        }
+      }
+    }
+  }
+  return result;
+}
+
+// src/utils/readDataJson.ts
+function readDataJson(dataJsonPath) {
+  try {
+    if (!import_node_fs4.default.existsSync(dataJsonPath)) {
+      return null;
+    }
+    const dataJsonContent = import_node_fs4.default.readFileSync(dataJsonPath, "utf8");
+    const dataJson = JSON.parse(dataJsonContent);
+    return convertFromDataJsonFormat(dataJson);
+  } catch (error) {
+    console.warn("Error reading or parsing languageData.json:", error);
+    return null;
+  }
+}
+
+// src/utils/syncManager.ts
+async function handleBidirectionalSync(doc, dataJsonPath, translationsOutputDir, syncLocalChanges, autoTranslate, spreadsheetData, waitSeconds, localeMapping = {}) {
+  const result = {
+    shouldRefresh: false,
+    hasChanges: false
+  };
+  const localData = readDataJson(dataJsonPath);
+  const dataJsonExists = localData !== null;
+  const shouldSyncToSheet = syncLocalChanges && dataJsonExists && isDataJsonNewer(dataJsonPath, translationsOutputDir);
+  if (!shouldSyncToSheet || !localData) {
+    return result;
+  }
+  console.log("Local languageData.json is newer than translation files. Checking for changes...");
+  const changes = findLocalChanges(localData, spreadsheetData);
+  const hasChanges = Object.keys(changes).length > 0 && Object.keys(changes).some(
+    (locale) => Object.keys(changes[locale]).length > 0
+  );
+  if (!hasChanges) {
+    console.log("No local changes found that need to be synced to the spreadsheet.");
+    return result;
+  }
+  const localesCount = Object.keys(changes).length;
+  const keysCount = Object.values(changes).flatMap((l) => Object.values(l)).flatMap((s) => Object.keys(s)).length;
+  console.log(`Found local changes: ${localesCount} locale(s), ~${keysCount} key(s) to sync to the spreadsheet.`);
+  try {
+    await updateSpreadsheetWithLocalChanges(doc, changes, waitSeconds, autoTranslate, localeMapping);
+    result.shouldRefresh = true;
+    result.hasChanges = true;
+  } catch (err) {
+    console.error("Failed to sync local changes to spreadsheet:", err);
+  }
+  return result;
+}
+
+// src/utils/publicSheetReader.ts
+var import_node_https = __toESM(require("node:https"));
+var import_node_http = __toESM(require("node:http"));
+function fetchUrl(url) {
+  return new Promise((resolve, reject) => {
+    const client = url.startsWith("https") ? import_node_https.default : import_node_http.default;
+    const req = client.get(url, (res) => {
+      if (res.statusCode !== void 0 && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        fetchUrl(res.headers.location).then(resolve).catch(reject);
+        return;
+      }
+      if (res.statusCode !== void 0 && res.statusCode >= 400) {
+        reject(new Error(`HTTP ${res.statusCode} while fetching ${url}`));
+        return;
+      }
+      let data = "";
+      res.on("data", (chunk) => {
+        data += chunk.toString();
+      });
+      res.on("end", () => resolve(data));
+      res.on("error", reject);
+    });
+    req.on("error", reject);
+    req.end();
+  });
+}
+function parseGvizResponse(raw) {
+  const match = raw.match(/google\.visualization\.Query\.setResponse\((\{[\s\S]*?\})\)/);
+  if (!match) {
+    throw new Error(
+      'Unexpected response format from Google Visualization API. Make sure the spreadsheet is shared as "Anyone with link can view".'
+    );
+  }
+  return JSON.parse(match[1]);
+}
+async function readPublicSheet(spreadsheetId, sheetName) {
+  const url = `https://docs.google.com/spreadsheets/d/${encodeURIComponent(spreadsheetId)}/gviz/tq?tqx=out:json&headers=1&sheet=${encodeURIComponent(sheetName)}`;
+  let raw;
+  try {
+    raw = await fetchUrl(url);
+  } catch (err) {
+    throw new Error(
+      `Failed to fetch public sheet "${sheetName}" from spreadsheet "${spreadsheetId}"`,
+      { cause: err }
+    );
+  }
+  let data;
+  try {
+    data = parseGvizResponse(raw);
+  } catch (err) {
+    throw new Error(
+      `Failed to parse response for sheet "${sheetName}" in spreadsheet "${spreadsheetId}"`,
+      { cause: err }
+    );
+  }
+  if (data.status !== "ok") {
+    const message = data.errors?.[0]?.message ?? "Unknown error";
+    throw new Error(
+      `Google Visualization API returned an error for sheet "${sheetName}": ${message}`
+    );
+  }
+  if (!data.table) {
+    return [];
+  }
+  const { cols, rows } = data.table;
+  const headers = cols.map((col) => col.label || col.id);
+  return rows.filter((row) => row && row.c).map((row) => {
+    const obj = {};
+    for (let i = 0; i < headers.length; i++) {
+      const cell = row.c?.[i];
+      obj[headers[i]] = cell?.v != null ? String(cell.v) : "";
+    }
+    return obj;
+  });
+}
+
+// src/utils/spreadsheetCreator.ts
+var import_google_spreadsheet = require("google-spreadsheet");
+function colLetter(index) {
+  let result = "";
+  let i = index;
+  do {
+    result = String.fromCharCode(65 + i % 26) + result;
+    i = Math.floor(i / 26) - 1;
+  } while (i >= 0);
+  return result;
+}
+var DEFAULT_TARGET_LOCALES = ["de", "fr", "es", "it", "pt", "ja", "zh"];
+var STARTER_KEYS = {
+  "app.name": "My App",
+  "app.description": "A great application",
+  "nav.home": "Home",
+  "nav.about": "About",
+  "nav.contact": "Contact",
+  "common.save": "Save",
+  "common.cancel": "Cancel",
+  "common.loading": "Loading\u2026",
+  "common.error": "An error occurred",
+  "common.success": "Success!"
+};
+async function createSpreadsheet(authClient, options = {}) {
+  const {
+    title = "google-sheet-translations",
+    sourceLocale = "en",
+    targetLocales = DEFAULT_TARGET_LOCALES,
+    seedKeys = STARTER_KEYS
+  } = options;
+  await authClient.authorize();
+  const createRes = await withRetry(
+    () => authClient.request({
+      url: "https://sheets.googleapis.com/v4/spreadsheets",
+      method: "POST",
+      data: {
+        properties: { title },
+        sheets: [
+          { properties: { title: "__welcome__", index: 0 } },
+          { properties: { title: "i18n", index: 1 } }
+        ]
+      }
+    }),
+    "createSpreadsheet"
+  );
+  const spreadsheetId = createRes.data.spreadsheetId;
+  const url = `https://docs.google.com/spreadsheets/d/${spreadsheetId}/edit`;
+  const doc = new import_google_spreadsheet.GoogleSpreadsheet(spreadsheetId, authClient);
+  await withRetry(() => doc.loadInfo(), "loadInfo after create");
+  const welcomeSheet = doc.sheetsByTitle["__welcome__"];
+  if (welcomeSheet) {
+    await withRetry(
+      () => welcomeSheet.loadCells("A1:B20"),
+      "loadCells welcome"
+    );
+    const lines = [
+      ["\u{1F4CA} Google Sheet Translations", ""],
+      ["", ""],
+      ["Package:", "@el-j/google-sheet-translations"],
+      ["Docs:", "https://el-j.github.io/google-sheet-translations/"],
+      ["", ""],
+      ["Your Spreadsheet ID:", spreadsheetId],
+      ["URL:", url],
+      ["", ""],
+      ["Add to your .env file:", ""],
+      ["GOOGLE_SPREADSHEET_ID=" + spreadsheetId, ""],
+      ["", ""],
+      ["How this works:", ""],
+      ['1. The "i18n" sheet (and any other sheet you add) holds your translation keys.', ""],
+      ["2. Column A = key, Column B = source language, other columns = auto-translated.", ""],
+      ["3. Run getSpreadSheetData(['i18n']) in your project to sync to local files.", ""],
+      ["4. Add more sheets for different pages/features of your app.", ""],
+      ["5. Use syncLocalChanges: true (default) to push new keys back to this spreadsheet.", ""]
+    ];
+    for (let r = 0; r < lines.length; r++) {
+      for (let c = 0; c < lines[r].length; c++) {
+        const cell = welcomeSheet.getCell(r, c);
+        cell.value = lines[r][c];
+      }
+    }
+    await withRetry(() => welcomeSheet.saveUpdatedCells(), "saveWelcome");
+  }
+  const i18nSheet = doc.sheetsByTitle["i18n"];
+  if (i18nSheet) {
+    const allLocales = [sourceLocale, ...targetLocales];
+    await withRetry(
+      () => i18nSheet.setHeaderRow(["key", ...allLocales]),
+      "setHeaderRow"
+    );
+    const sourceColLetter = colLetter(1);
+    const rows = Object.entries(seedKeys).map(([key, sourceValue]) => {
+      const row = { key, [sourceLocale]: sourceValue };
+      targetLocales.forEach((locale, idx) => {
+        const targetColLetter = colLetter(2 + idx);
+        row[locale] = `=GOOGLETRANSLATE(INDIRECT("${sourceColLetter}"&ROW());$${sourceColLetter}$1;${targetColLetter}$1)`;
+      });
+      return row;
+    });
+    await withRetry(() => i18nSheet.addRows(rows), "addRows i18n");
+  }
+  console.log("");
+  console.log("\u2705 New spreadsheet created!");
+  console.log(`   Title  : ${title}`);
+  console.log(`   URL    : ${url}`);
+  console.log(`   ID     : ${spreadsheetId}`);
+  console.log("");
+  console.log("   Add this to your .env file (or environment):");
+  console.log(`   GOOGLE_SPREADSHEET_ID=${spreadsheetId}`);
+  console.log("");
+  return { spreadsheetId, url };
+}
+
+// src/getSpreadSheetData.ts
+var MAX_SYNC_REFRESH_DEPTH = 1;
+async function persistSpreadsheetId(id) {
+  const envPath = import_node_path4.default.join(process.cwd(), ".env");
+  try {
+    let content = "";
+    if (import_node_fs5.default.existsSync(envPath)) {
+      content = import_node_fs5.default.readFileSync(envPath, "utf8");
+      if (/^GOOGLE_SPREADSHEET_ID=/m.test(content)) {
+        content = content.replace(/^GOOGLE_SPREADSHEET_ID=.*/m, `GOOGLE_SPREADSHEET_ID=${id}`);
+      } else {
+        content = content.trimEnd() + `
+GOOGLE_SPREADSHEET_ID=${id}
+`;
+      }
+    } else {
+      content = `GOOGLE_SPREADSHEET_ID=${id}
+`;
+    }
+    import_node_fs5.default.writeFileSync(envPath, content, "utf8");
+    console.log(`   Saved GOOGLE_SPREADSHEET_ID to ${envPath}`);
+  } catch (err) {
+    console.warn(`   Could not write .env: ${err.message}`);
+  }
+}
+async function getSpreadSheetData(_docTitle, options = {}, _refreshDepth = 0) {
+  const config = normalizeConfig(options);
+  const baseDelayMs = config.waitSeconds * 1e3;
+  const docTitle = _docTitle ?? [];
+  if (docTitle.length === 0) {
+    console.warn("No sheet titles provided, cannot process spreadsheet data");
+    return {};
+  }
+  if (!docTitle.includes("i18n")) {
+    docTitle.push("i18n");
+  }
+  const finalTranslations = {};
+  const allLocales = /* @__PURE__ */ new Set();
+  const localesWithContent = /* @__PURE__ */ new Set();
+  const globalLocaleMapping = {};
+  const globalOriginalMapping = {};
+  function mergeResult(result, title) {
+    if (!result.success) return;
+    for (const [normalized, original] of Object.entries(result.localeMapping)) {
+      if (!globalLocaleMapping[normalized]) globalLocaleMapping[normalized] = original;
+    }
+    for (const [original, normalized] of Object.entries(result.originalMapping)) {
+      if (!globalOriginalMapping[original]) globalOriginalMapping[original] = normalized;
+    }
+    for (const locale of result.locales) {
+      if (finalTranslations[locale]) {
+        finalTranslations[locale] = { ...finalTranslations[locale], ...result.translations[locale] };
+      } else {
+        finalTranslations[locale] = result.translations[locale];
+      }
+      allLocales.add(locale);
+      if (title !== "i18n" && result.translations[locale]) {
+        const hasActualTranslations = Object.values(result.translations[locale]).some(
+          (sheetTranslations) => Object.keys(sheetTranslations).length > 0
+        );
+        if (hasActualTranslations) localesWithContent.add(locale);
+      }
+    }
+  }
+  if (config.publicSheet) {
+    const spreadsheetId = config.spreadsheetId ?? process.env.GOOGLE_SPREADSHEET_ID;
+    if (!spreadsheetId) {
+      throw new Error(
+        "No spreadsheet ID provided. Set GOOGLE_SPREADSHEET_ID or pass spreadsheetId in options."
+      );
+    }
+    console.log(`Processing ${docTitle.length} sheets: ${docTitle.join(", ")}`);
+    await Promise.all(
+      docTitle.map(async (title) => {
+        let rows;
+        try {
+          rows = await withRetry(
+            () => readPublicSheet(spreadsheetId, title),
+            `readPublicSheet: ${title}`,
+            baseDelayMs
+          );
+        } catch (err) {
+          console.warn(`Sheet "${title}" could not be fetched: ${err.message}`);
+          return;
+        }
+        mergeResult(await processRawRows(rows, title), title);
+      })
+    );
+  } else {
+    const serviceAuthClient = createAuthClient();
+    let spreadsheetId = config.spreadsheetId ?? process.env.GOOGLE_SPREADSHEET_ID;
+    if (!spreadsheetId) {
+      if (config.autoCreate) {
+        const created = await createSpreadsheet(serviceAuthClient, {
+          title: config.spreadsheetTitle,
+          sourceLocale: config.sourceLocale,
+          targetLocales: config.targetLocales
+        });
+        spreadsheetId = created.spreadsheetId;
+        await persistSpreadsheetId(spreadsheetId);
+      } else {
+        throw new Error(
+          "No spreadsheet ID provided. Set GOOGLE_SPREADSHEET_ID or pass spreadsheetId in options."
+        );
+      }
+    }
+    console.log(`Processing ${docTitle.length} sheets: ${docTitle.join(", ")}`);
+    const doc = new import_google_spreadsheet2.GoogleSpreadsheet(spreadsheetId, serviceAuthClient);
+    try {
+      await withRetry(() => doc.loadInfo(true), "loadInfo", baseDelayMs);
+    } catch (err) {
+      throw new Error(`Failed to load spreadsheet "${spreadsheetId}"`, { cause: err });
+    }
+    await Promise.all(
+      docTitle.map(async (title) => {
+        const sheet = doc.sheetsByTitle[title];
+        if (!sheet) {
+          console.warn(`Sheet "${title}" not found in the document`);
+          return;
+        }
+        mergeResult(await processSheet(sheet, title, config.rowLimit, baseDelayMs), title);
+      })
+    );
+    const syncResult = await handleBidirectionalSync(
+      doc,
+      config.dataJsonPath,
+      config.translationsOutputDir,
+      config.syncLocalChanges,
+      config.autoTranslate,
+      finalTranslations,
+      config.waitSeconds,
+      globalLocaleMapping
+    );
+    if (syncResult.shouldRefresh && _refreshDepth < MAX_SYNC_REFRESH_DEPTH) {
+      return getSpreadSheetData(
+        _docTitle,
+        { ...options, syncLocalChanges: false },
+        _refreshDepth + 1
+      );
+    }
+  }
+  const localesForOutput = localesWithContent.size > 0 ? Array.from(localesWithContent) : Array.from(allLocales);
+  const allLocalesArray = Array.from(allLocales);
+  writeTranslationFiles(finalTranslations, allLocalesArray, config.translationsOutputDir);
+  writeLocalesFile(localesForOutput, globalLocaleMapping, config.localesOutputPath);
+  console.log(
+    `Writing locales file with ${localesForOutput.length} locales that have actual translations:`,
+    localesForOutput
+  );
+  if (Object.keys(finalTranslations).length > 0) {
+    writeLanguageDataFile(finalTranslations, allLocalesArray, config.dataJsonPath);
+  }
+  return finalTranslations;
+}
+
+// src/utils/wait.ts
+var import_promises2 = require("node:timers/promises");
+function wait(seconds, reason) {
+  console.log("wait", seconds, reason);
+  return (0, import_promises2.setTimeout)(seconds * 1e3);
+}
+
+// src/utils/translationHelpers.ts
+function getTranslationSummary(translations) {
+  const summary = {};
+  for (const locale of Object.keys(translations)) {
+    summary[locale] = Object.entries(translations[locale]).map(([sheet, keys]) => ({
+      sheet,
+      count: Object.keys(keys).length
+    }));
+  }
+  return summary;
+}
+function getLocaleDisplayName(locale, translations, i18nSheet = "i18n") {
+  const localeData = translations[locale];
+  if (!localeData) return locale;
+  const sheetData = localeData[i18nSheet];
+  if (!sheetData) return locale;
+  const name = sheetData[locale] ?? sheetData[locale.toLowerCase()];
+  return typeof name === "string" ? name : locale;
+}
+function mergeSheets(translations, locale, sheetNames) {
+  const localeData = translations[locale];
+  if (!localeData) return {};
+  const sheets = sheetNames ?? Object.keys(localeData);
+  const merged = {};
+  for (const sheetName of sheets) {
+    const sheetData = localeData[sheetName];
+    if (sheetData) {
+      Object.assign(merged, sheetData);
+    }
+  }
+  return merged;
+}
+
+// src/index.ts
+var index_default = getSpreadSheetData;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_WAIT_SECONDS,
+  convertFromDataJsonFormat,
+  convertToDataJsonFormat,
+  createAuthClient,
+  createLocaleMapping,
+  createSpreadsheet,
+  filterValidLocales,
+  findLocalChanges,
+  getLanguagePrefix,
+  getLocaleDisplayName,
+  getNormalizedLocaleForHeader,
+  getOriginalHeaderForLocale,
+  getSpreadSheetData,
+  getTranslationSummary,
+  handleBidirectionalSync,
+  isValidLocale,
+  mergeSheets,
+  normalizeLocaleCode,
+  processRawRows,
+  readPublicSheet,
+  resolveLocaleWithFallback,
+  updateSpreadsheetWithLocalChanges,
+  validateCredentials,
+  validateEnv,
+  wait,
+  withRetry,
+  writeLanguageDataFile,
+  writeLocalesFile,
+  writeTranslationFiles
+});