@dialexjs/cli 0.7.2 → 0.9.2

package/README.md

@@ -32,7 +32,7 @@ Binaries installed: `dialex` and the shorter alias `dx` (handy in package.json s
 
 Initialize or configure Dialex in any project:
 
-- **Automatic Framework Detection**: Identifies Next.js, Fastify, Koa, Hono, Express, NestJS, Elysia, SvelteKit, Astro, Vue, Nuxt, and React/Vite.
+- **Automatic Framework Detection**: Identifies Next.js, React Router, React/Vite, Preact, Solid, Svelte, SvelteKit, Vue, Nuxt, Qwik, Lit, React Native, Astro, Hono, Express, Fastify, Koa, NestJS, Elysia, Hapi, AdonisJS and tRPC from `package.json`.
 - **Magicast AST Injection**: Manipulates `dialex.config.ts` and registers the module in `nuxt.config.ts` (Nuxt) cleanly.
 - **Starter Dictionaries**: Emits typed starter dictionary and TypeScript declaration file.
 
@@ -70,6 +70,15 @@ dialex import translations/tr.xlf
 
 Fills missing (or `[TODO]`) strings with a provider you configure in `dialex.config.ts`. Built-in providers for Claude, OpenAI (ChatGPT), Gemini and DeepL are exported from `@dialexjs/cli/translate`. `--dry-run` lists what would be sent without calling anything.
 
+### `dialex lock`
+
+Records the translations you have as up to date with their current source text (`dialex.lock.json`), so a later edit of the source is noticed. `dialex translate` and `dialex import` record what they write; `dialex check` warns about translations whose source changed, and `--fail-on-stale` makes that an error.
+
+```bash
+dialex lock
+dialex lock --all   # also accept translations that are already out of date
+```
+
 ### `dialex check` (alias: `lint`)
 
 CI verification command:
@@ -86,6 +95,16 @@ dialex check
 
 ---
 
+## Exit codes
+
+`0` on success; `1` when the command fails. `dialex check` exits with `1` when it finds errors (warnings never fail it). `dialex import` exits with `0` even when it rejected values; read `success` in its `--json` output. Every command except `init` accepts `--json`.
+
+## Documentation
+
+[Commands and options](https://dialex.awaiden.com/cli/) and the [diagnostics reference](https://dialex.awaiden.com/guide/diagnostics.html).
+
+---
+
 ## 📝 Changelog
 
 See what changed in each release in the [changelog](https://github.com/awaiden/dialex/blob/main/CHANGELOG.md), or on [GitHub Releases](https://github.com/awaiden/dialex/releases).

package/dist/api.d.mts

@@ -1,22 +1,13 @@
 import { loadFile } from "magicast";
-import { DialexConfig } from "dialexjs";
-//#region src/utils/dictionary-edit.d.ts
-/**
- * AST-level helpers for reading and editing `.content.ts` dictionary files.
- *
- * Magicast's proxy layer cannot represent every value (for example template-literal
- * functions), so these helpers work on the underlying AST nodes and use Magicast only
- * to parse and print, which preserves the rest of the file's formatting.
- *
- * Supported shapes:
- * - `export default defineDictionary("name", { en: {...}, tr: {...} })`
- * - `export default defineDictionary({ name: "name", dictionary: { ... } })`
- * - `export default { name: "name", dictionary: { ... } }`
- */
-type Node = {
+import { DialexConfig, LintRuleSetting } from "dialexjs";
+//#region src/utils/ast.d.ts
+/** A syntax-tree node as magicast (recast/babel) and oxc-style ESTree nodes both look. */
+type AstNode = {
   type: string;
   [key: string]: any;
 };
+//#endregion
+//#region src/utils/dictionary/types.d.ts
 export declare const TODO_PREFIX = "[TODO] ";
 interface DictionaryFile {
   file: string;
@@ -24,7 +15,7 @@ interface DictionaryFile {
   name?: string;
   mod: Awaited<ReturnType<typeof loadFile>>;
   /** The object whose keys are locales. */
-  localesObj: Node;
+  localesObj: AstNode;
   /** Whether the file ended with a newline when loaded; restored on save. */
   endsWithNewline: boolean;
   /**
@@ -52,6 +43,8 @@ interface Leaf {
   /** Present when `kind` is `"string"`. */
   value?: string;
 }
+//#endregion
+//#region src/utils/dictionary/io.d.ts
 /**
  * Parses dictionary source text (for example an unsaved editor buffer). Returns `undefined` when
  * the file does not have an editable shape; throws on syntax errors.
@@ -62,11 +55,15 @@ export declare function loadDictionaryFile(file: string): Promise<DictionaryFile
 /** The source text with all edits applied, without writing anything. */
 export declare function renderDictionaryFile(df: DictionaryFile): string;
 export declare function saveDictionaryFile(df: DictionaryFile): Promise<void>;
+//#endregion
+//#region src/utils/dictionary/read.d.ts
 export declare function listLocales(df: DictionaryFile): string[];
 /** Lists every leaf (string, function, or other value) of a locale, in source order. */
 export declare function listLeaves(df: DictionaryFile, locale: string): Leaf[];
 export declare function hasPath(df: DictionaryFile, locale: string, path: string[]): boolean;
 export declare function getString(df: DictionaryFile, locale: string, path: string[]): string | undefined;
+//#endregion
+//#region src/utils/dictionary/write.d.ts
 type SetResult = "created" | "updated" | "skipped";
 /**
  * Sets a string value at `path`. Existing function or non-string values are left alone
@@ -79,6 +76,8 @@ export declare function setString(df: DictionaryFile, locale: string, path: stri
  * Returns `false` when the source has no such leaf or the target already has one.
  */
 export declare function copyLeaf(df: DictionaryFile, fromLocale: string, toLocale: string, path: string[], mapString?: (value: string) => string): boolean;
+//#endregion
+//#region src/utils/dictionary/locations.d.ts
 /**
  * Where a locale (no `path`) or a key within it is written. The range covers the property key, so
  * it is a good place to attach a diagnostic or jump to.
@@ -89,15 +88,7 @@ export declare function dictionaryLocation(df: DictionaryFile): SourceRange | un
 /** The source code of a leaf's value (a function's source, or a string with its quotes). */
 export declare function getLeafSource(df: DictionaryFile, locale: string, path: string[]): string | undefined;
 //#endregion
-//#region src/analysis.d.ts
-/**
- * Project analysis shared by `dialex check` and the editor extension.
- *
- * It reads dictionaries from the syntax tree, so it never runs project code. Dictionaries that
- * cannot be read that way (spreads, computed keys, imported values) are skipped with an `info`
- * issue, unless `runtime: true` is passed, in which case they are imported and read from the
- * evaluated module (the CLI does this; editors must not).
- */
+//#region src/analysis/types.d.ts
 type IssueLevel = "error" | "warning" | "info";
 type IssueCode = "invalid-dictionary" | "unanalyzable" | "missing-locale" | "missing-key" | "invalid-locale" | "todo-placeholder" | "stale-translation" | "invalid-icu" | "icu-args-mismatch" | "icu-plural-categories" | "unknown-dictionary" | "unknown-path" | "unused-key" | "unused-dictionary";
 interface AnalysisIssue {
@@ -121,7 +112,14 @@ interface AnalysisConfig {
   locales?: string[];
   include?: string | string[];
   exclude?: string[];
+  /** `lint.rules` of the config: `"off"` drops an issue, `"warn"` and `"error"` set its level. */
+  lint?: {
+    rules?: Record<string, LintSetting>;
+  };
 }
+type LintLevel = "off" | "warn" | "error";
+/** A rule as written in the config: `"warn"` or `["warn", { ...options }]`. */
+type LintSetting = LintLevel | readonly [LintLevel, unknown?];
 /**
  * Remembers parsed dictionaries and scanned source files between `analyzeProject` calls, keyed by
  * modification time and size, so a long-lived caller (the editor extension) only re-reads what
@@ -139,9 +137,6 @@ interface AnalysisCache {
   /** The `.gitignore` filter, reused until {@link clearGitignore} is called. */
   gitignore: Map<string, (absolutePath: string) => boolean>;
 }
-export declare function createAnalysisCache(): AnalysisCache;
-/** Forget the cached `.gitignore` rules, for example after a `.gitignore` file changed. */
-export declare function clearGitignore(cache: AnalysisCache): void;
 interface SourceScan {
   /** Distinct word-like tokens, for the unused-key heuristic. */
   tokens: string[];
@@ -149,6 +144,8 @@ interface SourceScan {
     ref: Reference;
     range: SourceRange;
   }[];
+  /** Dictionary names registered inline with `dictionaries: { name: ... }`. */
+  inline: string[];
 }
 interface AnalysisOptions {
   root: string;
@@ -165,6 +162,8 @@ interface AnalysisOptions {
   lock?: boolean;
   /** Reuse work between calls. Ignored when `runtime` is set, because that evaluates code. */
   cache?: AnalysisCache;
+  /** Unsaved text of files, by absolute path, used instead of reading them from disk. */
+  contents?: ReadonlyMap<string, string>;
 }
 interface LeafInfo {
   kind: "string" | "function" | "other";
@@ -189,8 +188,9 @@ interface AnalysisResult {
   /** Absolute paths of every dictionary file that matched. */
   files: string[];
   sourceFilesScanned: number;
+  /** Dictionary names registered in code with `dictionaries: { name: ... }`. Empty without `src`. */
+  inlineDictionaries: string[];
 }
-export declare const DEFAULT_SOURCE_GLOB = "**/*.{ts,tsx,js,jsx,mjs,cjs,vue,svelte,astro,mdx}";
 interface Reference {
   /** A dictionary name, or a full `dictionary.key.path`. */
   kind: "dictionary" | "path";
@@ -199,8 +199,6 @@ interface Reference {
   start: number;
   end: number;
 }
-/** Finds `getDictionary("x")`-style and `t("x.y.z")` references in source text. */
-export declare function scanReferences(text: string): Reference[];
 interface DictionaryData {
   name: string;
   locales: string[];
@@ -216,7 +214,33 @@ type Loaded = {
   code: IssueCode;
   message: string;
 };
+//#endregion
+//#region src/analysis/cache.d.ts
+export declare function createAnalysisCache(): AnalysisCache;
+/** Forget the cached `.gitignore` rules, for example after a `.gitignore` file changed. */
+export declare function clearGitignore(cache: AnalysisCache): void;
+//#endregion
+//#region src/analysis/source-scan.d.ts
+export declare const DEFAULT_SOURCE_GLOB = "**/*.{ts,tsx,js,jsx,mjs,cjs,vue,svelte,astro,mdx}";
+/** References and inline dictionary names found in one source file. */
+export declare function scanText(text: string): {
+  references: Reference[];
+  inline: string[];
+};
+/**
+ * Finds `getDictionary("x")`-style and `t("x.y.z")` references in source text. References inside
+ * comments, and on lines a `dialex-ignore` comment covers, are skipped.
+ */
+export declare function scanReferences(text: string): Reference[];
+//#endregion
+//#region src/analysis/index.d.ts
+/** Analyzes a project. With `runtime: true`, dictionaries the syntax tree cannot describe are imported. */
 export declare function analyzeProject(options: AnalysisOptions): Promise<AnalysisResult>;
+/**
+ * `analyzeProject` for callers that cannot await, such as lint rules. Reads dictionaries from the
+ * syntax tree only: `runtime` is ignored, so project code is never executed.
+ */
+export declare function analyzeProjectSync(options: AnalysisOptions): AnalysisResult;
 /** Project root-relative path with forward slashes, for display. */
 export declare function relativeFile(root: string, file: string): string;
 //#endregion
@@ -287,9 +311,15 @@ interface StaticConfig {
   locales: string[];
   include: string | string[];
   exclude: string[];
+  /** Where the generated file goes, when the config sets it. */
+  output?: string;
   fallbacks: Record<string, string[]>;
   prefixDefault: boolean;
   lazy: boolean | "locale";
+  /** Severity and options of each check, by diagnostic code. */
+  lint: {
+    rules: Record<string, LintRuleSetting>;
+  };
 }
 interface StaticConfigResult {
   config: StaticConfig;
@@ -297,6 +327,11 @@ interface StaticConfigResult {
   file?: string;
   /** Things that could not be read statically, for example `locales: getLocales()`. */
   notes: string[];
+  /**
+   * The config object has a spread or a computed key, so it may set things this reader cannot
+   * see. Only running the file gives a trustworthy answer.
+   */
+  opaque: boolean;
 }
 export declare const DEFAULT_STATIC_CONFIG: StaticConfig;
 /** Reads a config file's source text. Exposed for tests and for unsaved buffers. */
@@ -333,7 +368,7 @@ export declare function loadStaticProject(root: string, configFile?: string): Pr
 /** `home` + `["nav", "about"]` -> `home.nav.about` */
 export declare const toKey: (dictionary: string, keyPath: string[]) => string;
 //#endregion
-//#region src/commands/generate.d.ts
+//#region src/commands/generate/types.d.ts
 interface GenerateOptions {
   cwd?: string;
   watch?: boolean;
@@ -365,6 +400,8 @@ interface RenderedGenerate {
   /** Things worth telling the user, such as a dictionary that could not be split by locale. */
   notes: string[];
 }
+//#endregion
+//#region src/commands/generate/render.d.ts
 /**
  * Works out `dialex.generated.ts` and `dialex-env.d.ts` for a project without writing anything,
  * so `check` can tell whether they are up to date.
@@ -373,6 +410,8 @@ interface RenderedGenerate {
  * back to the locales the dictionaries define.
  */
 export declare function renderGenerated(root: string, options?: GenerateOptions): RenderedGenerate;
+//#endregion
+//#region src/commands/generate/write.d.ts
 export declare function generateDictionaries(root: string, options?: GenerateOptions): {
   files: string[];
   outputPath: string;
@@ -380,6 +419,8 @@ export declare function generateDictionaries(root: string, options?: GenerateOpt
   configFile?: string;
   notes: string[];
 };
+//#endregion
+//#region src/commands/generate/watch.d.ts
 /**
  * Regenerates when a dictionary or config file is added, edited or removed. chokidar 4+ no longer
  * understands globs, so this watches the project directory and decides for itself which events

package/dist/api.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"api.d.mts","names":[],"sources":["../src/utils/dictionary-edit.ts","../src/analysis.ts","../src/utils/files.ts","../src/utils/lockfile.ts","../src/utils/static-config.ts","../src/utils/project.ts","../src/commands/generate.ts"],"mappings":"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"}
+{"version":3,"file":"api.d.mts","names":["Node"],"sources":["../src/utils/ast.ts","../src/utils/dictionary/types.ts","../src/utils/dictionary/io.ts","../src/utils/dictionary/read.ts","../src/utils/dictionary/write.ts","../src/utils/dictionary/locations.ts","../src/analysis/types.ts","../src/analysis/cache.ts","../src/analysis/source-scan.ts","../src/analysis/index.ts","../src/utils/files.ts","../src/utils/lockfile.ts","../src/utils/static-config.ts","../src/utils/project.ts","../src/commands/generate/types.ts","../src/commands/generate/render.ts","../src/commands/generate/write.ts","../src/commands/generate/watch.ts"],"mappings":"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"}

package/dist/api.mjs

@@ -1,2 +1,2 @@
-import { A as scanFiles, B as locationOf, D as BUILTIN_IGNORE, E as writeLock, F as getString, H as renderDictionaryFile, I as hasPath, L as listLeaves, M as copyLeaf, N as dictionaryLocation, O as SOURCE_BUILTIN_IGNORE, P as getLeafSource, R as listLocales, U as saveDictionaryFile, V as parseDictionaryText, W as setString, _ as relativeFile, a as renderGenerated, b as hashSource, c as DEFAULT_STATIC_CONFIG, g as createAnalysisCache, h as clearGitignore, i as generateDictionaries, j as TODO_PREFIX, k as createGitignoreFilter, l as parseStaticConfig, m as analyzeProject, n as loadStaticProject, p as DEFAULT_SOURCE_GLOB, r as toKey, s as startGenerateWatcher, t as loadProject, u as readStaticConfig, v as scanReferences, w as readLock, x as isStale, y as LOCK_FILE, z as loadDictionaryFile } from "./project-Dz0FbydQ.mjs";
-export { BUILTIN_IGNORE, DEFAULT_SOURCE_GLOB, DEFAULT_STATIC_CONFIG, LOCK_FILE, SOURCE_BUILTIN_IGNORE, TODO_PREFIX, analyzeProject, clearGitignore, copyLeaf, createAnalysisCache, createGitignoreFilter, dictionaryLocation, generateDictionaries, getLeafSource, getString, hasPath, hashSource, isStale, listLeaves, listLocales, loadDictionaryFile, loadProject, loadStaticProject, locationOf, parseDictionaryText, parseStaticConfig, readLock, readStaticConfig, relativeFile, renderDictionaryFile, renderGenerated, saveDictionaryFile, scanFiles, scanReferences, setString, startGenerateWatcher, toKey, writeLock };
+import { A as scanFiles, B as listLeaves, D as BUILTIN_IGNORE, E as writeLock, F as locationOf, G as saveDictionaryFile, H as loadDictionaryFile, I as copyLeaf, K as TODO_PREFIX, L as setString, M as createAnalysisCache, N as dictionaryLocation, O as SOURCE_BUILTIN_IGNORE, P as getLeafSource, R as getString, U as parseDictionaryText, V as listLocales, W as renderDictionaryFile, _ as scanReferences, a as generateDictionaries, b as hashSource, c as DEFAULT_STATIC_CONFIG, g as DEFAULT_SOURCE_GLOB, h as relativeFile, j as clearGitignore, k as createGitignoreFilter, l as parseStaticConfig, m as analyzeProjectSync, n as loadStaticProject, o as startGenerateWatcher, p as analyzeProject, r as toKey, s as renderGenerated, t as loadProject, u as readStaticConfig, v as scanText, w as readLock, x as isStale, y as LOCK_FILE, z as hasPath } from "./project-BTpZGNjh.mjs";
+export { BUILTIN_IGNORE, DEFAULT_SOURCE_GLOB, DEFAULT_STATIC_CONFIG, LOCK_FILE, SOURCE_BUILTIN_IGNORE, TODO_PREFIX, analyzeProject, analyzeProjectSync, clearGitignore, copyLeaf, createAnalysisCache, createGitignoreFilter, dictionaryLocation, generateDictionaries, getLeafSource, getString, hasPath, hashSource, isStale, listLeaves, listLocales, loadDictionaryFile, loadProject, loadStaticProject, locationOf, parseDictionaryText, parseStaticConfig, readLock, readStaticConfig, relativeFile, renderDictionaryFile, renderGenerated, saveDictionaryFile, scanFiles, scanReferences, scanText, setString, startGenerateWatcher, toKey, writeLock };