@lionrapid/cli 0.5.0 → 0.6.0

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 All notable changes to `@lionrapid/cli`. Format based on
 [Keep a Changelog](https://keepachangelog.com/); this package follows semver.
 
+## 0.6.0 (2026-11-04)
+
+### Changed
+
+- **Node.js 22 or newer is required** (`engines.node` is now `>=22`, was
+  `>=18.0.0`). Node 18 and 20 are past end of life; the package is tested on
+  Node 22, 24 and 26.
+
+### Fixed
+
+- **`pull` keeps the source file's shape.** A source with flat dotted keys
+  (`"cta.start": …`) no longer comes back nested (`"cta": {"start": …}`) in
+  the pulled locale files, and a nested source stays nested. JSON and YAML.
+  `files[].flat` in `lionrapid.yml` still decides when it is set.
+
 ## 0.5.0
 
 ### Changed — behaviour

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LionRapid
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/adapters/json.d.ts

@@ -7,6 +7,8 @@ import type { FormatAdapter, SerializeOptions, TranslationEntry } from './types.
 export declare class JsonAdapter implements FormatAdapter {
     readonly format: "json";
     parse(content: string): TranslationEntry[];
+    isFlat(content: string): boolean | undefined;
+    private root;
     serialize(entries: TranslationEntry[], options?: SerializeOptions): string;
 }
 //# sourceMappingURL=json.d.ts.map

package/dist/adapters/json.js

@@ -3,13 +3,25 @@
  * node backends). Nested objects flatten to dot-notation keys (`home.cta`) and
  * unflatten back on serialize, preserving insertion order.
  */
-import { flatEntriesObject, flattenObject, unflattenEntries } from './nested.js';
+import { flatEntriesObject, flattenObject, treeIsFlat, unflattenEntries } from './nested.js';
 export class JsonAdapter {
     format = 'json';
     parse(content) {
+        const data = this.root(content);
+        if (data === null)
+            return [];
+        const out = [];
+        flattenObject(data, '', out);
+        return out;
+    }
+    isFlat(content) {
+        const data = this.root(content);
+        return data === null ? undefined : treeIsFlat(data);
+    }
+    root(content) {
         const trimmed = content.trim();
         if (trimmed === '')
-            return [];
+            return null;
         let data;
         try {
             data = JSON.parse(trimmed);
@@ -20,9 +32,7 @@ export class JsonAdapter {
         if (data === null || typeof data !== 'object' || Array.isArray(data)) {
             throw new Error('Expected a JSON object of translation keys.');
         }
-        const out = [];
-        flattenObject(data, '', out);
-        return out;
+        return data;
     }
     serialize(entries, options) {
         const tree = options?.flat ? flatEntriesObject(entries) : unflattenEntries(entries);

package/dist/adapters/nested.d.ts

@@ -10,6 +10,13 @@ export declare function flattenObject(obj: Record<string, unknown>, prefix: stri
  * Built with Object.fromEntries so a hostile key like `__proto__` lands as a
  * plain own property instead of touching the prototype.
  */
+/**
+ * The shape a key file is written in: `true` for flat dotted keys
+ * (`"cta.start": …`), `false` when any value is a nested object
+ * (`"cta": {"start": …}`), `undefined` when it says neither (no dots, no
+ * nesting), where both shapes write the same file.
+ */
+export declare function treeIsFlat(tree: Record<string, unknown>): boolean | undefined;
 export declare function flatEntriesObject(entries: TranslationEntry[]): Record<string, unknown>;
 export declare function unflattenEntries(entries: TranslationEntry[], onSkippedKey?: (key: string) => void): Record<string, unknown>;
 //# sourceMappingURL=nested.d.ts.map

package/dist/adapters/nested.js

@@ -23,6 +23,20 @@ export function flattenObject(obj, prefix, out) {
  * Built with Object.fromEntries so a hostile key like `__proto__` lands as a
  * plain own property instead of touching the prototype.
  */
+/**
+ * The shape a key file is written in: `true` for flat dotted keys
+ * (`"cta.start": …`), `false` when any value is a nested object
+ * (`"cta": {"start": …}`), `undefined` when it says neither (no dots, no
+ * nesting), where both shapes write the same file.
+ */
+export function treeIsFlat(tree) {
+    const values = Object.values(tree);
+    if (values.some((v) => v !== null && typeof v === 'object' && !Array.isArray(v)))
+        return false;
+    if (Object.keys(tree).some((k) => k.includes('.')))
+        return true;
+    return undefined;
+}
 export function flatEntriesObject(entries) {
     return Object.fromEntries(entries.map((e) => [e.key, fromContentUnit(e.value)]));
 }

package/dist/adapters/types.d.ts

@@ -37,6 +37,12 @@ export interface FormatAdapter {
     readonly format: FileFormat;
     parse(content: string, options?: ParseOptions): TranslationEntry[];
     serialize(entries: TranslationEntry[], options?: SerializeOptions): string;
+    /**
+     * The shape of an existing file (JSON/YAML), so `pull` writes targets the
+     * way the source is written: `true` flat dotted keys, `false` nested,
+     * `undefined` when it cannot tell (see treeIsFlat).
+     */
+    isFlat?(content: string, options?: ParseOptions): boolean | undefined;
     /** True for single-file, multi-locale catalogs (e.g. .xcstrings). */
     readonly multiLocale?: boolean;
     /**

package/dist/adapters/yaml.d.ts

@@ -11,6 +11,8 @@ import type { FormatAdapter, ParseOptions, SerializeOptions, TranslationEntry }
 export declare class YamlAdapter implements FormatAdapter {
     readonly format: "yaml";
     parse(content: string, options?: ParseOptions): TranslationEntry[];
+    isFlat(content: string, options?: ParseOptions): boolean | undefined;
+    private root;
     serialize(entries: TranslationEntry[], options?: SerializeOptions): string;
 }
 //# sourceMappingURL=yaml.d.ts.map

package/dist/adapters/yaml.js

@@ -8,13 +8,25 @@
  * JSON adapter; this adapter assumes the Rails/locale-rooted shape.)
  */
 import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
-import { flatEntriesObject, flattenObject, unflattenEntries } from './nested.js';
+import { flatEntriesObject, flattenObject, treeIsFlat, unflattenEntries } from './nested.js';
 function isObject(v) {
     return v !== null && typeof v === 'object' && !Array.isArray(v);
 }
 export class YamlAdapter {
     format = 'yaml';
     parse(content, options) {
+        const root = this.root(content, options);
+        if (root === null)
+            return [];
+        const out = [];
+        flattenObject(root, '', out);
+        return out;
+    }
+    isFlat(content, options) {
+        const root = this.root(content, options);
+        return root === null ? undefined : treeIsFlat(root);
+    }
+    root(content, options) {
         let data;
         try {
             data = parseYaml(content);
@@ -23,7 +35,7 @@ export class YamlAdapter {
             throw new Error(`Invalid YAML: ${err instanceof Error ? err.message : String(err)}`);
         }
         if (data === null || data === undefined)
-            return [];
+            return null;
         if (!isObject(data))
             throw new Error('Expected a YAML mapping of translation keys.');
         // Descend into the locale root: prefer the requested locale, else a single
@@ -38,9 +50,7 @@ export class YamlAdapter {
                 root = data[keys[0]];
             }
         }
-        const out = [];
-        flattenObject(root, '', out);
-        return out;
+        return root;
     }
     serialize(entries, options) {
         const tree = options?.flat ? flatEntriesObject(entries) : unflattenEntries(entries);

package/dist/commands/pull.js

@@ -170,6 +170,29 @@ export async function runPull(config, client, opts) {
     // namespace fetched on an earlier run must not be erased by this one.
     const lock = readLock(opts.cwd);
     const pulledAt = new Date().toISOString();
+    // Write each target in its source's shape: flat dotted keys stay flat,
+    // nested stays nested. `flat` in the config still decides when set.
+    // (2026-11-04: a flat `"cta.start"` source pulled into a nested fi.json.)
+    const shapes = new Map();
+    const flatFor = (file) => {
+        if (file.flat !== undefined)
+            return file.flat;
+        if (!shapes.has(file)) {
+            const sourceAbs = resolve(opts.cwd, file.source);
+            let shape;
+            try {
+                const adapter = getAdapter(file.format);
+                shape = existsSync(sourceAbs)
+                    ? adapter.isFlat?.(readFileSync(sourceAbs, 'utf8'), { locale: config.sourceLocale })
+                    : undefined;
+            }
+            catch {
+                shape = undefined; // an unreadable source: keep the adapter's default
+            }
+            shapes.set(file, shape);
+        }
+        return shapes.get(file);
+    };
     const locales = [];
     for (const locale of config.targetLocales) {
         const fileResults = [];
@@ -226,7 +249,7 @@ export async function runPull(config, client, opts) {
                     writeFileSync(absPath, adapter.serialize(toWrite, {
                         locale,
                         sourceLocale: config.sourceLocale,
-                        flat: file.flat,
+                        flat: flatFor(file),
                     }));
                 }
                 // Record what the SERVER just said. `pull` is the only writer of

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lionrapid/cli",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "LionRapid CLI — sync translation files (iOS, Android, Flutter, JSON, YAML, PO) with the LionRapid backend",
   "type": "module",
   "main": "./dist/index.js",
@@ -34,7 +34,7 @@
     "yaml": "^2.4.0"
   },
   "devDependencies": {
-    "@types/node": "^20.11.0",
+    "@types/node": "^26.0.0",
     "@vitest/coverage-v8": "^1.6.1",
     "dotenv-cli": "^7.3.0",
     "vitest": "^1.6.1"
@@ -46,7 +46,7 @@
     "CHANGELOG.md"
   ],
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=22"
   },
   "keywords": [
     "i18n",
@@ -67,7 +67,10 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/Hatamoto/tm-integration.git",
-    "directory": "packages/cli"
+    "url": "git+https://github.com/LionRapid/lionrapid-sdk.git"
+  },
+  "homepage": "https://docs.lionrapid.com",
+  "bugs": {
+    "url": "https://github.com/LionRapid/lionrapid-sdk/issues"
   }
 }