@intlayer/chokidar 6.0.2 → 6.1.1

package/dist/cjs/writeContentDeclaration/transformJSFile.cjs

@@ -0,0 +1,770 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var transformJSFile_exports = {};
+__export(transformJSFile_exports, {
+  transformJSFile: () => transformJSFile
+});
+module.exports = __toCommonJS(transformJSFile_exports);
+var import_core = require("@intlayer/core");
+var import_ts_morph = require("ts-morph");
+const isTranslationNode = (value) => {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  const hasNodeTypeTranslation = v.nodeType === import_core.NodeType.Translation;
+  const hasTranslationObject = v[import_core.NodeType.Translation] && typeof v[import_core.NodeType.Translation] === "object";
+  return Boolean(hasTranslationObject || hasNodeTypeTranslation);
+};
+const isEnumerationNode = (value) => {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return v.nodeType === import_core.NodeType.Enumeration || v[import_core.NodeType.Enumeration] && typeof v[import_core.NodeType.Enumeration] === "object";
+};
+const isConditionNode = (value) => {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return v.nodeType === import_core.NodeType.Condition || v[import_core.NodeType.Condition] && typeof v[import_core.NodeType.Condition] === "object";
+};
+const isGenderNode = (value) => {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return v.nodeType === import_core.NodeType.Gender || v[import_core.NodeType.Gender] && typeof v[import_core.NodeType.Gender] === "object";
+};
+const isInsertionNode = (value) => {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return v.nodeType === import_core.NodeType.Insertion || import_core.NodeType.Insertion in v;
+};
+const isMarkdownNode = (value) => {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return v.nodeType === import_core.NodeType.Markdown || import_core.NodeType.Markdown in v;
+};
+const isFileNode = (value) => {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return v.nodeType === import_core.NodeType.File || typeof v[import_core.NodeType.File] === "string";
+};
+const isNestedNode = (value) => {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return v.nodeType === import_core.NodeType.Nested || import_core.NodeType.Nested in v;
+};
+const buildTranslationInitializer = (translationMap) => {
+  const entries = Object.entries(translationMap).sort(([a], [b]) => a.localeCompare(b));
+  const parts = [];
+  for (const [lang, val] of entries) {
+    const isValidIdentifier = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(lang);
+    const keyText = isValidIdentifier ? lang : JSON.stringify(lang);
+    if (typeof val === "string") {
+      parts.push(`${keyText}: ${JSON.stringify(val)}`);
+    } else {
+      parts.push(`${keyText}: ${JSON.stringify(val)}`);
+    }
+  }
+  return `t({ ${parts.join(", ")} })`;
+};
+const stringifyKey = (key) => {
+  const isValidIdentifier = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key);
+  if (!isValidIdentifier) return JSON.stringify(key);
+  if (key === "true" || key === "false") return JSON.stringify(key);
+  return key;
+};
+const buildEnumerationInitializer = (map) => {
+  const parts = [];
+  for (const [k, v] of Object.entries(map)) {
+    if (typeof v !== "string") return "";
+    parts.push(`${stringifyKey(k)}: ${JSON.stringify(v)}`);
+  }
+  return `enu({ ${parts.join(", ")} })`;
+};
+const buildConditionInitializer = (map) => {
+  const parts = [];
+  for (const [k, v] of Object.entries(map)) {
+    if (typeof v !== "string") return "";
+    parts.push(`${stringifyKey(k)}: ${JSON.stringify(v)}`);
+  }
+  return `cond({ ${parts.join(", ")} })`;
+};
+const buildGenderInitializer = (map) => {
+  const parts = [];
+  for (const [k, v] of Object.entries(map)) {
+    if (typeof v !== "string") return "";
+    parts.push(`${stringifyKey(k)}: ${JSON.stringify(v)}`);
+  }
+  return `gender({ ${parts.join(", ")} })`;
+};
+const buildInsertionInitializer = (content) => {
+  if (typeof content === "string") return `insert(${JSON.stringify(content)})`;
+  if (isTranslationNode(content)) {
+    const translations = content.translation ?? content["translation"] ?? {};
+    const allStrings = Object.values(translations).every(
+      (v) => typeof v === "string"
+    );
+    if (!allStrings) return void 0;
+    return `insert(${buildTranslationInitializer(
+      translations
+    )})`;
+  }
+  return void 0;
+};
+const buildFileInitializer = (path) => {
+  if (typeof path === "string") return `file(${JSON.stringify(path)})`;
+  return void 0;
+};
+const buildMarkdownInitializer = (content) => {
+  if (typeof content === "string") return `md(${JSON.stringify(content)})`;
+  if (isFileNode(content)) {
+    const p = content[import_core.NodeType.File];
+    const fileInit = buildFileInitializer(p);
+    if (!fileInit) return void 0;
+    return `md(${fileInit})`;
+  }
+  return void 0;
+};
+const buildNestedInitializer = (obj) => {
+  const data = obj?.[import_core.NodeType.Nested];
+  if (!data || typeof data.dictionaryKey !== "string") return void 0;
+  if (data.path && typeof data.path === "string") {
+    return `nest(${JSON.stringify(data.dictionaryKey)}, ${JSON.stringify(data.path)})`;
+  }
+  return `nest(${JSON.stringify(data.dictionaryKey)})`;
+};
+const readExistingTranslationMap = (contentObject, propName) => {
+  const prop = contentObject.getProperty(propName);
+  if (!prop || !import_ts_morph.Node.isPropertyAssignment(prop)) return void 0;
+  const init = prop.getInitializer();
+  if (!init) return void 0;
+  if (!import_ts_morph.Node.isCallExpression(init)) return void 0;
+  const exp = init.getExpression();
+  if (!import_ts_morph.Node.isIdentifier(exp) || exp.getText() !== "t") return void 0;
+  const arg = init.getArguments()[0];
+  if (!arg || !import_ts_morph.Node.isObjectLiteralExpression(arg)) return void 0;
+  const map = {};
+  for (const p of arg.getProperties()) {
+    if (!import_ts_morph.Node.isPropertyAssignment(p)) continue;
+    const nameNode = p.getNameNode();
+    const rawName = nameNode.getText();
+    const name = rawName.replace(/^['"]|['"]$/g, "");
+    const valueInit = p.getInitializer();
+    if (valueInit && import_ts_morph.Node.isStringLiteral(valueInit)) {
+      map[name] = valueInit.getLiteralValue();
+    }
+  }
+  return map;
+};
+const readExistingMapFromCall = (contentObject, propName, callee) => {
+  const prop = contentObject.getProperty(propName);
+  if (!prop || !import_ts_morph.Node.isPropertyAssignment(prop)) return void 0;
+  const init = prop.getInitializer();
+  if (!init || !import_ts_morph.Node.isCallExpression(init)) return void 0;
+  const exp = init.getExpression();
+  if (!import_ts_morph.Node.isIdentifier(exp) || exp.getText() !== callee) return void 0;
+  const arg = init.getArguments()[0];
+  if (!arg || !import_ts_morph.Node.isObjectLiteralExpression(arg)) return void 0;
+  const map = {};
+  for (const p of arg.getProperties()) {
+    if (!import_ts_morph.Node.isPropertyAssignment(p)) continue;
+    const nameNode = p.getNameNode();
+    const rawName = nameNode.getText();
+    const name = rawName.replace(/^['"]|['"]$/g, "");
+    const valueInit = p.getInitializer();
+    if (valueInit && import_ts_morph.Node.isStringLiteral(valueInit)) {
+      map[name] = valueInit.getLiteralValue();
+    }
+  }
+  return map;
+};
+const areStringMapsEqual = (a, b) => {
+  if (!b) return false;
+  const aEntries = Object.entries(a).filter(
+    ([, v]) => typeof v === "string"
+  );
+  if (aEntries.length !== Object.keys(a).length) return false;
+  if (aEntries.length !== Object.keys(b).length) return false;
+  for (const [k, v] of aEntries) {
+    if (!(k in b)) return false;
+    if (b[k] !== v) return false;
+  }
+  return true;
+};
+const readExistingInsertion = (contentObject, propName) => {
+  const prop = contentObject.getProperty(propName);
+  if (!prop || !import_ts_morph.Node.isPropertyAssignment(prop)) return void 0;
+  const init = prop.getInitializer();
+  if (!init || !import_ts_morph.Node.isCallExpression(init)) return void 0;
+  const exp = init.getExpression();
+  if (!import_ts_morph.Node.isIdentifier(exp) || exp.getText() !== "insert") return void 0;
+  const arg = init.getArguments()[0];
+  if (!arg) return void 0;
+  if (import_ts_morph.Node.isStringLiteral(arg)) {
+    return { kind: "string", value: arg.getLiteralValue() };
+  }
+  if (import_ts_morph.Node.isCallExpression(arg)) {
+    const aexp = arg.getExpression();
+    if (import_ts_morph.Node.isIdentifier(aexp) && aexp.getText() === "t") {
+      const tArg = arg.getArguments()[0];
+      if (tArg && import_ts_morph.Node.isObjectLiteralExpression(tArg)) {
+        const map = {};
+        for (const p of tArg.getProperties()) {
+          if (!import_ts_morph.Node.isPropertyAssignment(p)) continue;
+          const nameNode = p.getNameNode();
+          const rawName = nameNode.getText();
+          const name = rawName.replace(/^['"]|['"]$/g, "");
+          const valueInit = p.getInitializer();
+          if (valueInit && import_ts_morph.Node.isStringLiteral(valueInit)) {
+            map[name] = valueInit.getLiteralValue();
+          }
+        }
+        return { kind: "translation", map };
+      }
+    }
+  }
+  return void 0;
+};
+const readExistingMarkdown = (contentObject, propName) => {
+  const prop = contentObject.getProperty(propName);
+  if (!prop || !import_ts_morph.Node.isPropertyAssignment(prop)) return void 0;
+  const init = prop.getInitializer();
+  if (!init || !import_ts_morph.Node.isCallExpression(init)) return void 0;
+  const exp = init.getExpression();
+  if (!import_ts_morph.Node.isIdentifier(exp) || exp.getText() !== "md") return void 0;
+  const arg = init.getArguments()[0];
+  if (!arg) return void 0;
+  if (import_ts_morph.Node.isStringLiteral(arg)) {
+    return { kind: "string", value: arg.getLiteralValue() };
+  }
+  if (import_ts_morph.Node.isCallExpression(arg)) {
+    const aexp = arg.getExpression();
+    if (import_ts_morph.Node.isIdentifier(aexp) && aexp.getText() === "file") {
+      const fArg = arg.getArguments()[0];
+      if (fArg && import_ts_morph.Node.isStringLiteral(fArg)) {
+        return { kind: "file", path: fArg.getLiteralValue() };
+      }
+    }
+  }
+  return void 0;
+};
+const readExistingFilePath = (contentObject, propName) => {
+  const prop = contentObject.getProperty(propName);
+  if (!prop || !import_ts_morph.Node.isPropertyAssignment(prop)) return void 0;
+  const init = prop.getInitializer();
+  if (!init || !import_ts_morph.Node.isCallExpression(init)) return void 0;
+  const exp = init.getExpression();
+  if (!import_ts_morph.Node.isIdentifier(exp) || exp.getText() !== "file") return void 0;
+  const arg = init.getArguments()[0];
+  if (arg && import_ts_morph.Node.isStringLiteral(arg)) return arg.getLiteralValue();
+  return void 0;
+};
+const readExistingNest = (contentObject, propName) => {
+  const prop = contentObject.getProperty(propName);
+  if (!prop || !import_ts_morph.Node.isPropertyAssignment(prop)) return void 0;
+  let init = prop.getInitializer();
+  if (!init) return void 0;
+  let safetyCounter = 0;
+  while (safetyCounter++ < 5) {
+    if (import_ts_morph.Node.isCallExpression(init)) break;
+    const anyInit = init;
+    const nextExpr = anyInit.getExpression?.();
+    if (nextExpr && typeof nextExpr === "object" && nextExpr !== init) {
+      init = nextExpr;
+      continue;
+    }
+    break;
+  }
+  if (!import_ts_morph.Node.isCallExpression(init)) return void 0;
+  const exp = init.getExpression();
+  if (!import_ts_morph.Node.isIdentifier(exp) || exp.getText() !== "nest") return void 0;
+  const [arg1, arg2] = init.getArguments();
+  if (!arg1 || !import_ts_morph.Node.isStringLiteral(arg1)) return void 0;
+  const dictionaryKey = arg1.getLiteralValue();
+  let path;
+  if (arg2 && import_ts_morph.Node.isStringLiteral(arg2)) path = arg2.getLiteralValue();
+  return { dictionaryKey, path };
+};
+const unwrapToObjectLiteral = (node) => {
+  if (!node || typeof node !== "object") return void 0;
+  let current = node;
+  let safetyCounter = 0;
+  while (safetyCounter++ < 8) {
+    if (import_ts_morph.Node.isObjectLiteralExpression(current)) return current;
+    const next = current?.getExpression?.();
+    if (next && typeof next === "object" && next !== current) {
+      current = next;
+      continue;
+    }
+    break;
+  }
+  return void 0;
+};
+const readExistingArraySerialized = (contentObject, propName) => {
+  const prop = contentObject.getProperty(propName);
+  if (!prop || !import_ts_morph.Node.isPropertyAssignment(prop)) return void 0;
+  const init = prop.getInitializer();
+  if (!init || !import_ts_morph.Node.isArrayLiteralExpression(init)) return void 0;
+  const serialized = [];
+  for (const el of init.getElements()) {
+    if (import_ts_morph.Node.isStringLiteral(el)) {
+      serialized.push(JSON.stringify(el.getLiteralValue()));
+      continue;
+    }
+    if (import_ts_morph.Node.isNumericLiteral(el)) {
+      serialized.push(el.getText());
+      continue;
+    }
+    if (el.getKind() === import_ts_morph.SyntaxKind.TrueKeyword || el.getKind() === import_ts_morph.SyntaxKind.FalseKeyword) {
+      serialized.push(el.getText());
+      continue;
+    }
+    if (import_ts_morph.Node.isNullLiteral(el)) {
+      serialized.push("null");
+      continue;
+    }
+    if (import_ts_morph.Node.isCallExpression(el)) {
+      const exp = el.getExpression();
+      if (import_ts_morph.Node.isIdentifier(exp) && exp.getText() === "t") {
+        const arg = el.getArguments()[0];
+        if (arg && import_ts_morph.Node.isObjectLiteralExpression(arg)) {
+          const map = {};
+          for (const p of arg.getProperties()) {
+            if (!import_ts_morph.Node.isPropertyAssignment(p)) return void 0;
+            const nameNode = p.getNameNode();
+            const rawName = nameNode.getText();
+            const name = rawName.replace(/^['"]|['"]$/g, "");
+            const valueInit = p.getInitializer();
+            if (valueInit && import_ts_morph.Node.isStringLiteral(valueInit)) {
+              map[name] = valueInit.getLiteralValue();
+            } else {
+              return void 0;
+            }
+          }
+          serialized.push(buildTranslationInitializer(map));
+          continue;
+        }
+      }
+    }
+    return void 0;
+  }
+  return serialized;
+};
+const serializeValue = (value) => {
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  if (value === null) return "null";
+  if (isTranslationNode(value)) {
+    const translations = value.translation ?? value["translation"] ?? {};
+    const allStrings = Object.values(translations).every(
+      (v) => typeof v === "string"
+    );
+    if (!allStrings) return void 0;
+    return buildTranslationInitializer(translations);
+  }
+  if (isEnumerationNode(value)) {
+    const map = value[import_core.NodeType.Enumeration];
+    const init = buildEnumerationInitializer(map);
+    return init || void 0;
+  }
+  if (isConditionNode(value)) {
+    const map = value[import_core.NodeType.Condition];
+    const init = buildConditionInitializer(map);
+    return init || void 0;
+  }
+  if (isGenderNode(value)) {
+    const map = value[import_core.NodeType.Gender];
+    const init = buildGenderInitializer(map);
+    return init || void 0;
+  }
+  if (isInsertionNode(value)) {
+    const content = value[import_core.NodeType.Insertion];
+    return buildInsertionInitializer(content);
+  }
+  if (isMarkdownNode(value)) {
+    const content = value[import_core.NodeType.Markdown];
+    return buildMarkdownInitializer(content);
+  }
+  if (isFileNode(value)) {
+    const path = value[import_core.NodeType.File];
+    return buildFileInitializer(path);
+  }
+  if (isNestedNode(value)) {
+    return buildNestedInitializer(value);
+  }
+  return void 0;
+};
+const transformJSFile = async (fileContent, dictionary) => {
+  try {
+    if (!dictionary || typeof dictionary !== "object" || !dictionary.content) {
+      return fileContent;
+    }
+    const project = new import_ts_morph.Project({
+      useInMemoryFileSystem: true,
+      skipAddingFilesFromTsConfig: true,
+      skipFileDependencyResolution: true,
+      compilerOptions: {
+        allowJs: true,
+        jsx: import_ts_morph.ts.JsxEmit.Preserve
+      }
+    });
+    const sourceFile = project.createSourceFile("file.tsx", fileContent, {
+      overwrite: true
+    });
+    let rootObject;
+    const exportAssignment = sourceFile.getExportAssignment((_) => true);
+    if (exportAssignment) {
+      const expr = exportAssignment.getExpression();
+      if (import_ts_morph.Node.isIdentifier(expr)) {
+        const declFromSymbol = expr.getSymbol()?.getDeclarations()?.[0];
+        const declByName = declFromSymbol ?? sourceFile.getVariableDeclaration(expr.getText());
+        if (declByName && import_ts_morph.Node.isVariableDeclaration(declByName)) {
+          const initAny = declByName.getInitializer();
+          const obj = unwrapToObjectLiteral(initAny);
+          if (obj) rootObject = obj;
+        }
+      } else if (import_ts_morph.Node.isObjectLiteralExpression(expr)) {
+        rootObject = expr;
+      }
+    }
+    if (!rootObject) {
+      const varDecl = sourceFile.getVariableDeclaration((v) => {
+        try {
+          const typeText = v.getType().getText();
+          return typeText.includes("Dictionary") || v.getName() === "content" || v.getName().toLowerCase().includes("dictionary");
+        } catch {
+          return v.getName() === "content";
+        }
+      });
+      if (varDecl) {
+        const obj = unwrapToObjectLiteral(varDecl.getInitializer());
+        if (obj) rootObject = obj;
+      }
+    }
+    if (!rootObject) {
+      for (const stmt of sourceFile.getStatements()) {
+        if (!import_ts_morph.Node.isExpressionStatement(stmt)) continue;
+        const expr = stmt.getExpression();
+        if (!import_ts_morph.Node.isBinaryExpression(expr)) continue;
+        const operator = expr.getOperatorToken();
+        if (operator.getText() !== "=") continue;
+        const left = expr.getLeft();
+        if (!import_ts_morph.Node.isPropertyAccessExpression(left)) continue;
+        const leftExpr = left.getExpression();
+        const leftName = left.getName();
+        const isModuleExports = import_ts_morph.Node.isIdentifier(leftExpr) && leftExpr.getText() === "module" && leftName === "exports";
+        const isExportsDefault = import_ts_morph.Node.isIdentifier(leftExpr) && leftExpr.getText() === "exports" && leftName === "default";
+        if (!isModuleExports && !isExportsDefault) continue;
+        const right = expr.getRight();
+        if (import_ts_morph.Node.isObjectLiteralExpression(right)) {
+          rootObject = right;
+          break;
+        }
+        if (import_ts_morph.Node.isIdentifier(right)) {
+          const decl = right.getSymbol()?.getDeclarations()?.[0];
+          if (decl && import_ts_morph.Node.isVariableDeclaration(decl)) {
+            const obj = unwrapToObjectLiteral(decl.getInitializer());
+            if (obj) {
+              rootObject = obj;
+              break;
+            }
+          }
+        }
+      }
+    }
+    if (!rootObject) {
+      return fileContent;
+    }
+    const contentProp = rootObject.getProperty("content");
+    let contentObject;
+    if (contentProp && import_ts_morph.Node.isPropertyAssignment(contentProp)) {
+      contentObject = contentProp.getInitializerIfKind(
+        import_ts_morph.SyntaxKind.ObjectLiteralExpression
+      );
+    }
+    if (!contentObject || !dictionary.content) {
+      return fileContent;
+    }
+    const existingKeys = /* @__PURE__ */ new Set();
+    for (const prop of contentObject.getProperties()) {
+      if (import_ts_morph.Node.isPropertyAssignment(prop)) {
+        const name = prop.getName();
+        if (name) existingKeys.add(name.replace(/^['"]|['"]$/g, ""));
+      }
+    }
+    let changed = false;
+    const dictContent = dictionary.content || {};
+    const areTranslationsEqual = (desired, existing) => {
+      if (!existing) return false;
+      for (const [lang, val] of Object.entries(desired)) {
+        if (typeof val !== "string") return false;
+        if (!(lang in existing)) return false;
+        if (existing[lang] !== val) return false;
+      }
+      return true;
+    };
+    for (const [key, value] of Object.entries(dictContent)) {
+      if (Array.isArray(value)) {
+        const serializedElements = [];
+        let unsupported = false;
+        for (const el of value) {
+          const s = serializeValue(el);
+          if (s === void 0) {
+            unsupported = true;
+            break;
+          }
+          serializedElements.push(s);
+        }
+        if (unsupported) {
+          continue;
+        }
+        const initializerText = `[ ${serializedElements.join(", ")} ]`;
+        if (!existingKeys.has(key)) {
+          contentObject.addPropertyAssignment({
+            name: key,
+            initializer: initializerText
+          });
+          changed = true;
+          continue;
+        }
+        const prop = contentObject.getProperty(key);
+        if (prop && import_ts_morph.Node.isPropertyAssignment(prop)) {
+          const existingSerialized = readExistingArraySerialized(
+            contentObject,
+            key
+          );
+          const arraysEqual = existingSerialized !== void 0 && existingSerialized.length === serializedElements.length && existingSerialized.every((v, i) => v === serializedElements[i]);
+          if (!arraysEqual) {
+            prop.setInitializer(initializerText);
+            changed = true;
+          }
+        }
+        continue;
+      }
+      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null) {
+        if (!existingKeys.has(key)) {
+          contentObject.addPropertyAssignment({
+            name: key,
+            initializer: typeof value === "string" ? JSON.stringify(value) : String(value)
+          });
+          changed = true;
+          continue;
+        }
+        const prop = contentObject.getProperty(key);
+        if (prop && import_ts_morph.Node.isPropertyAssignment(prop)) {
+          const init = prop.getInitializer();
+          const currentText = init?.getText();
+          const desiredText = typeof value === "string" ? JSON.stringify(value) : String(value);
+          if (currentText !== desiredText) {
+            prop.setInitializer(desiredText);
+            changed = true;
+          }
+        }
+        continue;
+      }
+      if (isTranslationNode(value)) {
+        const translations = value.translation ?? value["translation"] ?? {};
+        const allStrings = Object.values(translations).every(
+          (v) => typeof v === "string"
+        );
+        if (!allStrings) {
+          continue;
+        }
+        const initializerText = buildTranslationInitializer(
+          translations
+        );
+        if (!existingKeys.has(key)) {
+          contentObject.addPropertyAssignment({
+            name: key,
+            initializer: initializerText
+          });
+          changed = true;
+          continue;
+        }
+        const existingMap = readExistingTranslationMap(contentObject, key);
+        if (!areTranslationsEqual(translations, existingMap)) {
+          const prop = contentObject.getProperty(key);
+          if (prop && import_ts_morph.Node.isPropertyAssignment(prop)) {
+            prop.setInitializer(initializerText);
+            changed = true;
+          }
+        }
+      } else if (isEnumerationNode(value)) {
+        const map = value[import_core.NodeType.Enumeration];
+        if (!Object.values(map).every((v) => typeof v === "string")) continue;
+        const initializerText = buildEnumerationInitializer(map);
+        if (!initializerText) continue;
+        if (!existingKeys.has(key)) {
+          contentObject.addPropertyAssignment({
+            name: key,
+            initializer: initializerText
+          });
+          changed = true;
+          continue;
+        }
+        const existingMap = readExistingMapFromCall(contentObject, key, "enu");
+        if (!areStringMapsEqual(map, existingMap)) {
+          const prop = contentObject.getProperty(key);
+          if (prop && import_ts_morph.Node.isPropertyAssignment(prop)) {
+            prop.setInitializer(initializerText);
+            changed = true;
+          }
+        }
+      } else if (isConditionNode(value)) {
+        const map = value[import_core.NodeType.Condition];
+        if (!Object.values(map).every((v) => typeof v === "string")) continue;
+        const initializerText = buildConditionInitializer(map);
+        if (!initializerText) continue;
+        if (!existingKeys.has(key)) {
+          contentObject.addPropertyAssignment({
+            name: key,
+            initializer: initializerText
+          });
+          changed = true;
+          continue;
+        }
+        const existingMap = readExistingMapFromCall(contentObject, key, "cond");
+        if (!areStringMapsEqual(map, existingMap)) {
+          const prop = contentObject.getProperty(key);
+          if (prop && import_ts_morph.Node.isPropertyAssignment(prop)) {
+            prop.setInitializer(initializerText);
+            changed = true;
+          }
+        }
+      } else if (isGenderNode(value)) {
+        const map = value[import_core.NodeType.Gender];
+        if (!Object.values(map).every((v) => typeof v === "string")) continue;
+        const initializerText = buildGenderInitializer(map);
+        if (!initializerText) continue;
+        if (!existingKeys.has(key)) {
+          contentObject.addPropertyAssignment({
+            name: key,
+            initializer: initializerText
+          });
+          changed = true;
+          continue;
+        }
+        const existingMap = readExistingMapFromCall(
+          contentObject,
+          key,
+          "gender"
+        );
+        if (!areStringMapsEqual(map, existingMap)) {
+          const prop = contentObject.getProperty(key);
+          if (prop && import_ts_morph.Node.isPropertyAssignment(prop)) {
+            prop.setInitializer(initializerText);
+            changed = true;
+          }
+        }
+      } else if (isInsertionNode(value)) {
+        const desired = value[import_core.NodeType.Insertion];
+        const initializerText = buildInsertionInitializer(desired);
+        if (!initializerText) continue;
+        if (!existingKeys.has(key)) {
+          contentObject.addPropertyAssignment({
+            name: key,
+            initializer: initializerText
+          });
+          changed = true;
+          continue;
+        }
+        const existing = readExistingInsertion(contentObject, key);
+        const isSame = typeof desired === "string" && existing?.kind === "string" && existing.value === desired || isTranslationNode(desired) && existing?.kind === "translation" && areStringMapsEqual(
+          desired[import_core.NodeType.Translation] ?? {},
+          existing.map
+        );
+        if (!isSame) {
+          const prop = contentObject.getProperty(key);
+          if (prop && import_ts_morph.Node.isPropertyAssignment(prop)) {
+            prop.setInitializer(initializerText);
+            changed = true;
+          }
+        }
+      } else if (isMarkdownNode(value)) {
+        const desired = value[import_core.NodeType.Markdown];
+        const initializerText = buildMarkdownInitializer(desired);
+        if (!initializerText) continue;
+        if (!existingKeys.has(key)) {
+          contentObject.addPropertyAssignment({
+            name: key,
+            initializer: initializerText
+          });
+          changed = true;
+          continue;
+        }
+        const existing = readExistingMarkdown(contentObject, key);
+        const isSame = typeof desired === "string" && existing?.kind === "string" && existing.value === desired || isFileNode(desired) && existing?.kind === "file" && existing.path === desired[import_core.NodeType.File];
+        if (!isSame) {
+          const prop = contentObject.getProperty(key);
+          if (prop && import_ts_morph.Node.isPropertyAssignment(prop)) {
+            prop.setInitializer(initializerText);
+            changed = true;
+          }
+        }
+      } else if (isFileNode(value)) {
+        const desired = value[import_core.NodeType.File];
+        const initializerText = buildFileInitializer(desired);
+        if (!initializerText) continue;
+        if (!existingKeys.has(key)) {
+          contentObject.addPropertyAssignment({
+            name: key,
+            initializer: initializerText
+          });
+          changed = true;
+          continue;
+        }
+        const existing = readExistingFilePath(contentObject, key);
+        if (existing !== desired) {
+          const prop = contentObject.getProperty(key);
+          if (prop && import_ts_morph.Node.isPropertyAssignment(prop)) {
+            prop.setInitializer(initializerText);
+            changed = true;
+          }
+        }
+      } else if (isNestedNode(value)) {
+        const initializerText = buildNestedInitializer(value);
+        if (!initializerText) continue;
+        if (!existingKeys.has(key)) {
+          contentObject.addPropertyAssignment({
+            name: key,
+            initializer: initializerText
+          });
+          changed = true;
+          continue;
+        }
+        const existing = readExistingNest(contentObject, key);
+        const desired = value[import_core.NodeType.Nested];
+        const isSame = !!desired && existing?.dictionaryKey === desired.dictionaryKey && existing?.path === desired.path;
+        if (!isSame) {
+          const prop = contentObject.getProperty(key);
+          if (prop && import_ts_morph.Node.isPropertyAssignment(prop)) {
+            prop.setInitializer(initializerText);
+            changed = true;
+          }
+        }
+      }
+    }
+    if (!changed) return fileContent;
+    return sourceFile.getFullText();
+  } catch {
+    return fileContent;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  transformJSFile
+});
+//# sourceMappingURL=transformJSFile.cjs.map