xcstrings-cli 1.0.0

package/dist/index.js

@@ -0,0 +1,659 @@
+#!/usr/bin/env node
+import we from "yargs";
+import { hideBin as ve } from "yargs/helpers";
+import { readFile as je, writeFile as ie, readdir as ae } from "node:fs/promises";
+import { relative as X, resolve as D } from "node:path";
+import d from "chalk";
+import { checkbox as te, confirm as Oe, select as xe } from "@inquirer/prompts";
+import { XcodeProject as Se } from "@bacons/xcode";
+import { cosmiconfig as ke } from "cosmiconfig";
+import ze from "json5";
+async function U(t) {
+  const r = await je(t, "utf-8");
+  return JSON.parse(r);
+}
+async function ce(t, r) {
+  const n = JSON.stringify(r, null, 2), s = Ee(n);
+  await ie(t, s + `
+`, "utf-8");
+}
+function Ee(t) {
+  let r = "", n = !1, s = !1;
+  for (let c = 0; c < t.length; c++) {
+    const l = t[c];
+    if (n && l === "\\" && !s) {
+      s = !0, r += l;
+      continue;
+    }
+    if (s) {
+      s = !1, r += l;
+      continue;
+    }
+    if (l === '"') {
+      n = !n, r += l;
+      continue;
+    }
+    if (!n && l === ":") {
+      r += " :";
+      continue;
+    }
+    r += l;
+  }
+  return r;
+}
+async function _e(t, r, n, s) {
+  const c = await U(t);
+  c.strings || (c.strings = {});
+  const l = {
+    ...c.strings[r],
+    extractionState: "manual"
+  };
+  if (n && (l.comment = n), s) {
+    l.localizations = l.localizations || {};
+    for (const [x, z] of Object.entries(s))
+      l.localizations[x] = {
+        stringUnit: {
+          state: "translated",
+          value: z
+        }
+      };
+  }
+  c.strings[r] = l, await ce(t, c);
+}
+async function Le(t, r) {
+  const n = await U(t);
+  n.strings && n.strings[r] && (delete n.strings[r], await ce(t, n));
+}
+const I = "xcstrings-cli.json5";
+async function Pe(t) {
+  const r = [];
+  async function n(s) {
+    try {
+      const c = await ae(s, { withFileTypes: !0 });
+      for (const l of c) {
+        const x = D(s, l.name);
+        l.isDirectory() ? !l.name.startsWith(".") && l.name !== "node_modules" && await n(x) : l.name.endsWith(".xcstrings") && r.push(x);
+      }
+    } catch {
+    }
+  }
+  return await n(t), r;
+}
+async function Fe(t) {
+  const r = [];
+  let n = t;
+  try {
+    const s = await ae(n, { withFileTypes: !0 });
+    for (const c of s)
+      c.isDirectory() && c.name.endsWith(".xcodeproj") && r.push(D(n, c.name));
+  } catch {
+  }
+  return r;
+}
+async function Ce() {
+  const t = process.cwd();
+  console.log(), console.log(d.bold.cyan("🚀 xcstrings-cli Configuration Setup")), console.log(d.dim("─".repeat(40))), console.log(), console.log(d.yellow("🔍 Searching for .xcstrings files..."));
+  const r = await Pe(t);
+  console.log(d.yellow("🔍 Searching for .xcodeproj directories..."));
+  const n = await Fe(t);
+  console.log();
+  let s = [];
+  if (r.length > 0) {
+    console.log(d.green(`✓ Found ${r.length} .xcstrings file(s)`));
+    const b = r.map((h) => ({
+      name: d.white(X(t, h)) + d.dim(` (${h})`),
+      value: X(t, h),
+      checked: !0
+    }));
+    s = await te({
+      message: d.bold("Select .xcstrings files to manage:"),
+      choices: b
+    });
+  } else
+    console.log(d.dim("  No .xcstrings files found in current directory"));
+  console.log();
+  let c = [];
+  if (n.length > 0) {
+    console.log(d.green(`✓ Found ${n.length} .xcodeproj director${n.length === 1 ? "y" : "ies"}`));
+    const b = n.map((h) => ({
+      name: d.white(X(t, h) || h) + d.dim(` (${h})`),
+      value: X(t, h) || h,
+      checked: !0
+    }));
+    c = await te({
+      message: d.bold("Select .xcodeproj directories for language detection:"),
+      choices: b
+    });
+  } else
+    console.log(d.dim("  No .xcodeproj directories found"));
+  if (console.log(), console.log(d.dim("─".repeat(40))), console.log(), console.log(d.bold("📋 Configuration Summary:")), console.log(), console.log(d.cyan("  xcstringsPaths:")), s.length > 0 ? s.forEach((b) => console.log(d.white(`    • ${b}`))) : console.log(d.dim("    (none)")), console.log(), console.log(d.cyan("  xcodeprojPaths:")), c.length > 0 ? c.forEach((b) => console.log(d.white(`    • ${b}`))) : console.log(d.dim("    (none)")), console.log(), !await Oe({
+    message: d.bold(`Create ${d.yellow(I)}?`),
+    default: !0
+  })) {
+    console.log(d.dim("  Configuration cancelled."));
+    return;
+  }
+  const x = s.map((b) => `        "${b}"`).join(`,
+`), z = c.map((b) => `        "${b}"`).join(`,
+`), _ = `{
+    // Array of paths to .xcstrings files to manage. Specify relative or absolute paths.
+    xcstringsPaths: [
+${x}
+    ],
+    // Array of paths to .xcodeproj directories. Used for discovering supported languages.
+    xcodeprojPaths: [
+${z}
+    ]
+}
+`;
+  await ie(I, _, "utf-8"), console.log(), console.log(d.bold.green(`✓ Created ${I}`)), console.log(d.dim(`   Run ${d.cyan("xcstrings --help")} to see available commands.`)), console.log();
+}
+const M = "xcstrings-cli", ne = ke(M, {
+  searchPlaces: [
+    `${M}.json`,
+    `${M}.json5`
+  ],
+  loaders: {
+    ".json5": async (t, r) => ze.parse(r)
+  },
+  cache: !1
+});
+async function le(t) {
+  if (t) {
+    const n = await ne.load(t);
+    return n ? n.config : null;
+  }
+  const r = await ne.search();
+  return r ? r.config : null;
+}
+function Te(t) {
+  const r = D(t, "project.pbxproj");
+  return Se.open(r).rootObject.props.knownRegions ?? [];
+}
+async function $e(t) {
+  const r = await U(t), n = /* @__PURE__ */ new Set();
+  for (const s of Object.keys(r.strings)) {
+    const c = r.strings[s];
+    if (c.localizations)
+      for (const l of Object.keys(c.localizations))
+        n.add(l);
+  }
+  return Array.from(n).sort();
+}
+async function Ae(t, r) {
+  const n = await le(r);
+  if (n?.xcodeprojPaths && n.xcodeprojPaths.length > 0) {
+    const s = /* @__PURE__ */ new Set();
+    for (const c of n.xcodeprojPaths)
+      Te(c).forEach((x) => s.add(x));
+    return Array.from(s).sort();
+  }
+  return await $e(t);
+}
+function Ne(t) {
+  return t && t.__esModule && Object.prototype.hasOwnProperty.call(t, "default") ? t.default : t;
+}
+var C = { exports: {} }, W, re;
+function Ve() {
+  if (re) return W;
+  re = 1;
+  function t(n) {
+    try {
+      return JSON.stringify(n);
+    } catch {
+      return '"[Circular]"';
+    }
+  }
+  W = r;
+  function r(n, s, c) {
+    var l = c && c.stringify || t, x = 1;
+    if (typeof n == "object" && n !== null) {
+      var z = s.length + x;
+      if (z === 1) return n;
+      var _ = new Array(z);
+      _[0] = l(n);
+      for (var b = 1; b < z; b++)
+        _[b] = l(s[b]);
+      return _.join(" ");
+    }
+    if (typeof n != "string")
+      return n;
+    var h = s.length;
+    if (h === 0) return n;
+    for (var w = "", y = 1 - x, g = -1, k = n && n.length || 0, f = 0; f < k; ) {
+      if (n.charCodeAt(f) === 37 && f + 1 < k) {
+        switch (g = g > -1 ? g : 0, n.charCodeAt(f + 1)) {
+          case 100:
+          // 'd'
+          case 102:
+            if (y >= h || s[y] == null) break;
+            g < f && (w += n.slice(g, f)), w += Number(s[y]), g = f + 2, f++;
+            break;
+          case 105:
+            if (y >= h || s[y] == null) break;
+            g < f && (w += n.slice(g, f)), w += Math.floor(Number(s[y])), g = f + 2, f++;
+            break;
+          case 79:
+          // 'O'
+          case 111:
+          // 'o'
+          case 106:
+            if (y >= h || s[y] === void 0) break;
+            g < f && (w += n.slice(g, f));
+            var T = typeof s[y];
+            if (T === "string") {
+              w += "'" + s[y] + "'", g = f + 2, f++;
+              break;
+            }
+            if (T === "function") {
+              w += s[y].name || "<anonymous>", g = f + 2, f++;
+              break;
+            }
+            w += l(s[y]), g = f + 2, f++;
+            break;
+          case 115:
+            if (y >= h)
+              break;
+            g < f && (w += n.slice(g, f)), w += String(s[y]), g = f + 2, f++;
+            break;
+          case 37:
+            g < f && (w += n.slice(g, f)), w += "%", g = f + 2, f++, y--;
+            break;
+        }
+        ++y;
+      }
+      ++f;
+    }
+    return g === -1 ? n : (g < k && (w += n.slice(g)), w);
+  }
+  return W;
+}
+var oe;
+function Xe() {
+  if (oe) return C.exports;
+  oe = 1;
+  const t = Ve();
+  C.exports = h;
+  const r = pe().console || {}, n = {
+    mapHttpRequest: A,
+    mapHttpResponse: A,
+    wrapRequestSerializer: q,
+    wrapResponseSerializer: q,
+    wrapErrorSerializer: q,
+    req: A,
+    res: A,
+    err: H,
+    errWithCause: H
+  };
+  function s(e, o) {
+    return e === "silent" ? 1 / 0 : o.levels.values[e];
+  }
+  const c = Symbol("pino.logFuncs"), l = Symbol("pino.hierarchy"), x = {
+    error: "log",
+    fatal: "error",
+    warn: "error",
+    info: "log",
+    debug: "log",
+    trace: "log"
+  };
+  function z(e, o) {
+    const a = {
+      logger: o,
+      parent: e[l]
+    };
+    o[l] = a;
+  }
+  function _(e, o, a) {
+    const u = {};
+    o.forEach((m) => {
+      u[m] = a[m] ? a[m] : r[m] || r[x[m] || "log"] || F;
+    }), e[c] = u;
+  }
+  function b(e, o) {
+    return Array.isArray(e) ? e.filter(function(u) {
+      return u !== "!stdSerializers.err";
+    }) : e === !0 ? Object.keys(o) : !1;
+  }
+  function h(e) {
+    e = e || {}, e.browser = e.browser || {};
+    const o = e.browser.transmit;
+    if (o && typeof o.send != "function")
+      throw Error("pino: transmit option must have a send function");
+    const a = e.browser.write || r;
+    e.browser.write && (e.browser.asObject = !0);
+    const u = e.serializers || {}, m = b(e.browser.serialize, u);
+    let j = e.browser.serialize;
+    Array.isArray(e.browser.serialize) && e.browser.serialize.indexOf("!stdSerializers.err") > -1 && (j = !1);
+    const E = Object.keys(e.customLevels || {}), p = ["error", "fatal", "warn", "info", "debug", "trace"].concat(E);
+    typeof a == "function" && p.forEach(function(O) {
+      a[O] = a;
+    }), (e.enabled === !1 || e.browser.disabled) && (e.level = "silent");
+    const v = e.level || "info", i = Object.create(a);
+    i.log || (i.log = F), _(i, p, a), z({}, i), Object.defineProperty(i, "levelVal", {
+      get: N
+    }), Object.defineProperty(i, "level", {
+      get: L,
+      set: be
+    });
+    const S = {
+      transmit: o,
+      serialize: m,
+      asObject: e.browser.asObject,
+      formatters: e.browser.formatters,
+      levels: p,
+      timestamp: me(e)
+    };
+    i.levels = w(e), i.level = v, i.setMaxListeners = i.getMaxListeners = i.emit = i.addListener = i.on = i.prependListener = i.once = i.prependOnceListener = i.removeListener = i.removeAllListeners = i.listeners = i.listenerCount = i.eventNames = i.write = i.flush = F, i.serializers = u, i._serialize = m, i._stdErrSerialize = j, i.child = ye, o && (i._logEvent = R());
+    function N() {
+      return s(this.level, this);
+    }
+    function L() {
+      return this._level;
+    }
+    function be(O) {
+      if (O !== "silent" && !this.levels.values[O])
+        throw Error("unknown level " + O);
+      this._level = O, k(this, S, i, "error"), k(this, S, i, "fatal"), k(this, S, i, "warn"), k(this, S, i, "info"), k(this, S, i, "debug"), k(this, S, i, "trace"), E.forEach((P) => {
+        k(this, S, i, P);
+      });
+    }
+    function ye(O, P) {
+      if (!O)
+        throw new Error("missing bindings for child Pino");
+      P = P || {}, m && O.serializers && (P.serializers = O.serializers);
+      const K = P.serializers;
+      if (m && K) {
+        var V = Object.assign({}, u, K), Y = e.browser.serialize === !0 ? Object.keys(V) : m;
+        delete O.serializers, $([O], Y, V, this._stdErrSerialize);
+      }
+      function Z(ee) {
+        this._childLevel = (ee._childLevel | 0) + 1, this.bindings = O, V && (this.serializers = V, this._serialize = Y), o && (this._logEvent = R(
+          [].concat(ee._logEvent.bindings, O)
+        ));
+      }
+      Z.prototype = this;
+      const J = new Z(this);
+      return z(this, J), J.level = this.level, J;
+    }
+    return i;
+  }
+  function w(e) {
+    const o = e.customLevels || {}, a = Object.assign({}, h.levels.values, o), u = Object.assign({}, h.levels.labels, y(o));
+    return {
+      values: a,
+      labels: u
+    };
+  }
+  function y(e) {
+    const o = {};
+    return Object.keys(e).forEach(function(a) {
+      o[e[a]] = a;
+    }), o;
+  }
+  h.levels = {
+    values: {
+      fatal: 60,
+      error: 50,
+      warn: 40,
+      info: 30,
+      debug: 20,
+      trace: 10
+    },
+    labels: {
+      10: "trace",
+      20: "debug",
+      30: "info",
+      40: "warn",
+      50: "error",
+      60: "fatal"
+    }
+  }, h.stdSerializers = n, h.stdTimeFunctions = Object.assign({}, { nullTime: G, epochTime: Q, unixTime: he, isoTime: ge });
+  function g(e) {
+    const o = [];
+    e.bindings && o.push(e.bindings);
+    let a = e[l];
+    for (; a.parent; )
+      a = a.parent, a.logger.bindings && o.push(a.logger.bindings);
+    return o.reverse();
+  }
+  function k(e, o, a, u) {
+    if (Object.defineProperty(e, u, {
+      value: s(e.level, a) > s(u, a) ? F : a[c][u],
+      writable: !0,
+      enumerable: !0,
+      configurable: !0
+    }), !o.transmit && e[u] === F)
+      return;
+    e[u] = T(e, o, a, u);
+    const m = g(e);
+    m.length !== 0 && (e[u] = f(m, e[u]));
+  }
+  function f(e, o) {
+    return function() {
+      return o.apply(this, [...e, ...arguments]);
+    };
+  }
+  function T(e, o, a, u) {
+    return /* @__PURE__ */ (function(m) {
+      return function() {
+        const E = o.timestamp(), p = new Array(arguments.length), v = Object.getPrototypeOf && Object.getPrototypeOf(this) === r ? r : this;
+        for (var i = 0; i < p.length; i++) p[i] = arguments[i];
+        if (o.serialize && !o.asObject && $(p, this._serialize, this.serializers, this._stdErrSerialize), o.asObject || o.formatters ? m.call(v, ue(this, u, p, E, o.formatters)) : m.apply(v, p), o.transmit) {
+          const S = o.transmit.level || e._level, N = a.levels.values[S], L = a.levels.values[u];
+          if (L < N) return;
+          de(this, {
+            ts: E,
+            methodLevel: u,
+            methodValue: L,
+            transmitValue: a.levels.values[o.transmit.level || e._level],
+            send: o.transmit.send,
+            val: s(e._level, a)
+          }, p);
+        }
+      };
+    })(e[c][u]);
+  }
+  function ue(e, o, a, u, m = {}) {
+    const {
+      level: j = () => e.levels.values[o],
+      log: E = (L) => L
+    } = m;
+    e._serialize && $(a, e._serialize, e.serializers, e._stdErrSerialize);
+    const p = a.slice();
+    let v = p[0];
+    const i = {};
+    u && (i.time = u), i.level = j(o, e.levels.values[o]);
+    let S = (e._childLevel | 0) + 1;
+    if (S < 1 && (S = 1), v !== null && typeof v == "object") {
+      for (; S-- && typeof p[0] == "object"; )
+        Object.assign(i, p.shift());
+      v = p.length ? t(p.shift(), p) : void 0;
+    } else typeof v == "string" && (v = t(p.shift(), p));
+    return v !== void 0 && (i.msg = v), E(i);
+  }
+  function $(e, o, a, u) {
+    for (const m in e)
+      if (u && e[m] instanceof Error)
+        e[m] = h.stdSerializers.err(e[m]);
+      else if (typeof e[m] == "object" && !Array.isArray(e[m]))
+        for (const j in e[m])
+          o && o.indexOf(j) > -1 && j in a && (e[m][j] = a[j](e[m][j]));
+  }
+  function de(e, o, a) {
+    const u = o.send, m = o.ts, j = o.methodLevel, E = o.methodValue, p = o.val, v = e._logEvent.bindings;
+    $(
+      a,
+      e._serialize || Object.keys(e.serializers),
+      e.serializers,
+      e._stdErrSerialize === void 0 ? !0 : e._stdErrSerialize
+    ), e._logEvent.ts = m, e._logEvent.messages = a.filter(function(i) {
+      return v.indexOf(i) === -1;
+    }), e._logEvent.level.label = j, e._logEvent.level.value = E, u(j, e._logEvent, p), e._logEvent = R(v);
+  }
+  function R(e) {
+    return {
+      ts: 0,
+      messages: [],
+      bindings: e || [],
+      level: { label: "", value: 0 }
+    };
+  }
+  function H(e) {
+    const o = {
+      type: e.constructor.name,
+      msg: e.message,
+      stack: e.stack
+    };
+    for (const a in e)
+      o[a] === void 0 && (o[a] = e[a]);
+    return o;
+  }
+  function me(e) {
+    return typeof e.timestamp == "function" ? e.timestamp : e.timestamp === !1 ? G : Q;
+  }
+  function A() {
+    return {};
+  }
+  function q(e) {
+    return e;
+  }
+  function F() {
+  }
+  function G() {
+    return !1;
+  }
+  function Q() {
+    return Date.now();
+  }
+  function he() {
+    return Math.round(Date.now() / 1e3);
+  }
+  function ge() {
+    return new Date(Date.now()).toISOString();
+  }
+  function pe() {
+    function e(o) {
+      return typeof o < "u" && o;
+    }
+    try {
+      return typeof globalThis < "u" || Object.defineProperty(Object.prototype, "globalThis", {
+        get: function() {
+          return delete Object.prototype.globalThis, this.globalThis = this;
+        },
+        configurable: !0
+      }), globalThis;
+    } catch {
+      return e(self) || e(window) || e(this) || {};
+    }
+  }
+  return C.exports.default = h, C.exports.pino = h, C.exports;
+}
+var De = Xe();
+const Re = /* @__PURE__ */ Ne(De), B = Re({
+  level: process.env.LOG_LEVEL || "info"
+});
+async function fe() {
+  return new Promise((t) => {
+    let r = "";
+    process.stdin.setEncoding("utf8"), process.stdin.on("data", (n) => {
+      r += n;
+    }), process.stdin.on("end", () => {
+      t(r);
+    }), process.stdin.readableEnded && t("");
+  });
+}
+async function qe(t, r = fe) {
+  if (t !== void 0) {
+    if (t === "") {
+      const n = await r();
+      return n.trim() ? JSON.parse(n) : void 0;
+    }
+    if (typeof t == "string")
+      return JSON.parse(t);
+    if (Array.isArray(t)) {
+      const n = {};
+      for (const s of t)
+        typeof s == "string" && Object.assign(n, JSON.parse(s));
+      return n;
+    }
+    if (typeof t == "boolean" && t === !0) {
+      const n = await r();
+      return n.trim() ? JSON.parse(n) : void 0;
+    }
+  }
+}
+async function Je(t, r, n, s, c = fe) {
+  const l = await qe(s, c);
+  await _e(t, r, n, l);
+}
+const se = D(process.cwd(), "Localizable.xcstrings");
+we(ve(process.argv)).scriptName("xcstrings").usage("$0 <cmd> [args]").option("config", {
+  type: "string",
+  describe: "Path to config file"
+}).option("path", {
+  type: "string",
+  describe: "Path to xcstrings file",
+  default: se
+}).middleware(async (t) => {
+  if (t.path !== se)
+    return;
+  const r = await le(t.config);
+  if (!(!r || !r.xcstringsPaths || r.xcstringsPaths.length === 0))
+    if (r.xcstringsPaths.length === 1) {
+      const n = r.xcstringsPaths[0];
+      t.path = typeof n == "string" ? n : n.path;
+    } else {
+      const n = r.xcstringsPaths.map((c) => typeof c == "string" ? { name: c, value: c } : { name: `${c.alias} (${c.path})`, value: c.path }), s = await xe({
+        message: "Select xcstrings file:",
+        choices: n
+      });
+      t.path = s;
+    }
+}).command(
+  "add",
+  "Add a string",
+  (t) => t.option("key", {
+    type: "string",
+    describe: "The key of the string",
+    demandOption: !0
+  }).option("comment", {
+    type: "string",
+    describe: "The comment for the string"
+  }).option("strings", {
+    type: "string",
+    describe: "The strings JSON"
+  }),
+  async (t) => {
+    await Je(t.path, t.key, t.comment, t.strings), B.info(d.green(`✓ Added key "${t.key}"`));
+  }
+).command(
+  "remove",
+  "Remove a string",
+  (t) => t.option("key", {
+    type: "string",
+    describe: "The key to remove",
+    demandOption: !0
+  }),
+  async (t) => {
+    await Le(t.path, t.key), B.info(d.green(`✓ Removed key "${t.key}"`));
+  }
+).command(
+  "init",
+  "Initialize configuration file",
+  (t) => t,
+  async () => {
+    await Ce();
+  }
+).command(
+  "languages",
+  "List supported languages from xcodeproj or xcstrings",
+  (t) => t,
+  async (t) => {
+    const r = await Ae(t.path, t.config);
+    B.info(r.join(" "));
+  }
+).demandCommand(1, "").strictCommands().recommendCommands().showHelpOnFail(!0).fail((t, r, n) => {
+  if (r)
+    throw console.error(r), r;
+  t && (console.error(d.red(t)), console.log()), n.showHelp(), process.exit(1);
+}).help().argv;

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "xcstrings-cli",
+  "version": "1.0.0",
+  "description": "A command line tool for handling xcstrings files.",
+  "type": "module",
+  "bin": {
+    "xcstrings": "./dist/index.js"
+  },
+  "keywords": [
+    "xcstrings",
+    "cli",
+    "localization",
+    "i18n",
+    "ios",
+    "macos",
+    "xcode"
+  ],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@changesets/cli": "^2.29.8",
+    "@types/json5": "^2.2.0",
+    "@types/node": "^24.10.1",
+    "@types/yargs": "^17.0.35",
+    "prettier": "^3.7.4",
+    "typescript": "^5.9.3",
+    "vite": "^7.2.6",
+    "vitest": "^4.0.15",
+    "yargs": "^18.0.0"
+  },
+  "dependencies": {
+    "@bacons/xcode": "1.0.0-alpha.27",
+    "@inquirer/prompts": "^8.0.2",
+    "chalk": "^5.6.2",
+    "cosmiconfig": "^9.0.0",
+    "json5": "^2.2.3",
+    "pino": "^8.16.0"
+  },
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "pretest": "pnpm build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "prettier --check .",
+    "format": "prettier --write .",
+    "changeset": "changeset",
+    "version": "changeset version",
+    "release": "pnpm build && changeset publish"
+  }
+}