prosebook 0.3.0 → 0.4.0

package/README.md

@@ -38,7 +38,7 @@ const { t } = useCopy();
   string, periods, sentence case, banned filler, and `{count} files` outside a plural. Plugins add your
   own rules, scoped by kind, surface and locale, and translations are held to their source.
 - **Native too.** The same catalog generates Rust, Swift and Kotlin for a tray, a menu bar or a CLI,
-  with plurals and number formats that say what the browser says.
+  with plurals and number formats that say what the browser says, and the string resources Android and Apple read.
 
 ## Quick start
 
@@ -238,7 +238,7 @@ function Ready({ copy, children }: { copy: Copy; children: ReactNode }) {
 }
 ```
 
-### Outside the browser: Rust, Swift and Kotlin
+### Outside the browser: Rust, Swift, Kotlin, Android and Apple
 
 The parts of an app the browser doesn't draw, a tray, a menu bar, a CLI, an Android shell, can read
 the same catalog. `generate` writes one file per target in `native`, holding every locale:
@@ -295,6 +295,77 @@ What can't be written that way fails `generate`, with the fix: a date (pass it f
 count (`unitDisplay: 'long'`), and an MF2 option read from an argument. Leave such keys out of the
 target's `keys`.
 
+#### Android resources
+
+An Android app needs string resources even with the Kotlin target: its manifest, launcher shortcuts,
+an accessibility service's description and every other XML resource name strings as `@string/…`, and
+only a resource answers that. The `android` target writes them, with `out` naming the `res` folder:
+
+```ts
+native: [{ language: 'android', out: 'android/app/src/main/res', keys: ['android'] }],
+```
+
+`values/strings.xml` holds the source locale, and each other locale gets a folder named as Android
+names it (`values-de`, `values-pt-rBR`, `values-b+sr+Latn` for a script), holding what that locale
+shows, every fallback resolved. `name` renames the file, `strings` by default, so it can sit beside
+strings you write yourself. A resource is named for its key, less the prefix, with `.` and `-` as
+`_`: `android.sign-in.denied` is `R.string.sign_in_denied`. Above each is a comment with its context
+and what each argument holds.
+
+```xml
+<!-- Counts the cart. count: how many items the cart holds. -->
+<plurals name="cart_items">
+    <item quantity="one">%1$d item in the cart.</item>
+    <item quantity="other">%1$d items in the cart.</item>
+</plurals>
+<!-- Greets the person signed in. firstName: the person's first name. -->
+<string name="hello">Hello, %1$s!</string>
+```
+
+Android fills placeholders in with `String.format` and picks a plural's arm itself, so a resource
+holds less than the other targets: text, plain `{name}` placeholders, written `%1$s` by their place in
+the source so a translation can reorder them, and one plural, which becomes `<plurals>` with its count
+as `%1$d` (the text around it goes into each arm). Call it as Android does,
+`resources.getQuantityString(R.plurals.cart_items, count, count)`. `String.format` isn't `Intl`, so
+nothing here is checked against it: `%d` writes 1234 without grouping. Android picks the arm by the
+device's language, so a plural a locale doesn't translate picks among the source's arms by that
+language's rules. Escaping is done for you: quotes, apostrophes, `\`, `&`, `<`, a newline, a leading
+`@` or `?`, `%` where the string is formatted, and spaces Android would collapse or trim.
+
+What a resource can't hold fails `generate`, with the fix: a select, a date, a formatted number, a
+second plural, an ordinal, an offset, an exact arm such as `=0` (Android's `zero` is a category, which
+English never picks), a selector other than a bare `:number` or `:integer`, and a tag.
+
+#### Apple string tables
+
+An Apple app has the same gap: macOS and iOS read the permission prompts, the app's name and other
+Info.plist strings from the bundle, never from Swift. The `apple` target writes `.strings` tables, a
+`<locale>.lproj/<name>.strings` per locale under `out`, each holding what that locale shows. They are
+plain `.strings` files, not a String Catalog, which only Xcode compiles: an app bundled by Tauri or a
+script copies the `.lproj` folders into `Contents/Resources` as they are.
+
+With `plist`, the table is `InfoPlist` and translates that Info.plist. A catalog key can't be written
+`NSCameraUsageDescription`, so its words spell the plist key: `macos.ns-camera-usage-description` is
+`NSCameraUsageDescription`. The key must be in the plist, since the system reads only the keys there,
+and the plist's own text must be the source's, since it shows where no `.lproj` matches. Either way
+round, `generate` fails with the fix:
+
+```ts
+native: [{ language: 'apple', out: 'src-tauri/Resources', keys: ['macos'], plist: 'src-tauri/Info.plist' }],
+```
+
+```c
+/* Asks for the camera. */
+"NSCameraUsageDescription" = "Corner Shop scans a product's barcode with the camera.";
+```
+
+Without `plist`, the table is `Localizable`, for what the system looks up by key, such as a push
+notification's `loc-key`. An entry is named for its key less the prefix, as written (`tray.quit` is
+`"quit"` under `['tray']`), and placeholders are written `%1$@` by their place in the source, filled
+in by `String(format:)`, not `Intl`. A table holds text and plain `{name}` placeholders; a plural (it
+would take a `.stringsdict`), a select, a date, a formatted number and a tag fail `generate`, and an
+Info.plist string takes no placeholders at all. Show those from the Swift target.
+
 ## The catalog
 
 One file per area, `copy/catalog/<area>.yaml`. A key's first segment names its file, so
@@ -815,7 +886,7 @@ export default defineConfig({
     properNouns: [],
     pathSeparator: '›',
   },
-  native: [], // Rust, Swift or Kotlin files: { language: 'rust', out: 'src/copy.rs', keys: ['tray'] }
+  native: [], // Rust, Swift or Kotlin files, Android's res or Apple's .lproj: { language: 'rust', out: 'src/copy.rs', keys: ['tray'] }
   scan: { dirs: ['src'] },
 });
 ```

package/dist/bun.d.ts

@@ -1,5 +1,5 @@
-import { t as Prune } from "./bundle-KD-DiiFa.js";
-import { i as ProsebookConfig } from "./config-DdMkKt_N.js";
+import { t as Prune } from "./bundle-CpUIWb9j.js";
+import { i as ProsebookConfig } from "./config-CzaJJQ60.js";
 import { BunPlugin } from "bun";
 export interface ProsebookBunOptions {
   /** The config, inline. Without it, `prosebook.config.*` at `root` is read. */

package/dist/bun.js

@@ -1,7 +1,7 @@
 import { a as installInspector, c as prunedModule, f as watchCatalog, i as hotLocale, l as scanSources, n as HOT_SET, o as keeper, r as beside, t as HOT_INDEX, u as unseenMessage } from "./bundle-DboItAre.js";
-import { n as generate, x as CatalogError } from "./generate-9pR3i5Bj.js";
-import { r as loadConfig } from "./config-BPSmoYel.js";
-import { t as inspectorEndpoints } from "./endpoints-CnUfCkIk.js";
+import { n as generate, x as CatalogError } from "./generate-BW3N8EGb.js";
+import { r as loadConfig } from "./config-nWZf9QmF.js";
+import { t as inspectorEndpoints } from "./endpoints-BgG_5Vpm.js";
 import { basename, resolve } from "node:path";
 import { readFileSync } from "node:fs";
 // src/bun.ts

package/dist/{bundle-KD-DiiFa.d.ts → bundle-CpUIWb9j.d.ts}

@@ -1,6 +1,6 @@
-import "./compile-xF3F4oIp.js";
-import "./config-DdMkKt_N.js";
+import "./compile-ClK9htKr.js";
+import "./config-CzaJJQ60.js";
 /** How a build prunes: `strict` also fails on a read whose key it can't see. */
 type Prune = 'strict' | 'loose' | false;
 export { Prune as t };
-//# sourceMappingURL=bundle-KD-DiiFa.d.ts.map
+//# sourceMappingURL=bundle-CpUIWb9j.d.ts.map

package/dist/bundle-CpUIWb9j.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle-CpUIWb9j.d.ts","names":[],"sources":["../src/tools/bundle.ts"],"mappings":";;;KAiBY"}

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import { f as watchCatalog } from "./bundle-DboItAre.js";
-import { D as whereOf, O as SYNTAX_NAME, _ as applyFixes, a as render, l as changeOf, n as generate, w as entryLocator, x as CatalogError, y as importTranslations } from "./generate-9pR3i5Bj.js";
-import { p as lint, r as loadConfig, t as CONFIG_FILES } from "./config-BPSmoYel.js";
-import { a as applyExtract, c as planExtract, i as planMigrate, n as todoOf, r as applyMigrate, t as SarifReport } from "./sarif-CWyTAQ0y.js";
+import { D as whereOf, O as SYNTAX_NAME, _ as applyFixes, a as render, l as changeOf, n as generate, w as entryLocator, x as CatalogError, y as importTranslations } from "./generate-BW3N8EGb.js";
+import { p as lint, r as loadConfig, t as CONFIG_FILES } from "./config-nWZf9QmF.js";
+import { a as applyExtract, c as planExtract, i as planMigrate, n as todoOf, r as applyMigrate, t as SarifReport } from "./sarif-B5nrMqrT.js";
 import { o as scan, r as isReferenced, s as sourceFiles } from "./scan-Bx0_yDSi.js";
 import { join, relative, resolve } from "node:path";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";

package/dist/{compile-xF3F4oIp.d.ts → compile-ClK9htKr.d.ts}

@@ -1,4 +1,4 @@
-import { nt as MessageFormatElement } from "./config-DdMkKt_N.js";
+import { nt as MessageFormatElement } from "./config-CzaJJQ60.js";
 type Entry = readonly [key: string, ast: MessageFormatElement[]];
 interface CompiledLocale {
   /** `const oN = {…};` lines the messages refer to. */
@@ -13,4 +13,4 @@ declare function localeModule(compiled: CompiledLocale, banner: string, ts: bool
 /** The locale as one expression, for a bundler to inline in place of the module. */
 declare function localeExpression(compiled: CompiledLocale): string;
 export { localeModule as a, localeExpression as i, Entry as n, compileLocale as r, CompiledLocale as t };
-//# sourceMappingURL=compile-xF3F4oIp.d.ts.map
+//# sourceMappingURL=compile-ClK9htKr.d.ts.map

package/dist/{compile-xF3F4oIp.d.ts.map → compile-ClK9htKr.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"compile-xF3F4oIp.d.ts","names":[],"sources":["../src/tools/compile.ts"],"mappings":";KA0BY,kBAAkB,aAAa,KAAK;UAoG/B;;EAEf;;EAEA;;;iBAIc,cAAc,SAAS,SAAS,QAAQ,QAAQ,0BAA0B;;iBAW1E,aAAa,UAAU,gBAAgB,gBAAgB;;iBAUvD,iBAAiB,UAAU"}
+{"version":3,"file":"compile-ClK9htKr.d.ts","names":[],"sources":["../src/tools/compile.ts"],"mappings":";KA0BY,kBAAkB,aAAa,KAAK;UAoG/B;;EAEf;;EAEA;;;iBAIc,cAAc,SAAS,SAAS,QAAQ,QAAQ,0BAA0B;;iBAW1E,aAAa,UAAU,gBAAgB,gBAAgB;;iBAUvD,iBAAiB,UAAU"}

package/dist/{config-DdMkKt_N.d.ts → config-CzaJJQ60.d.ts}

@@ -467,21 +467,35 @@ interface LintConfig extends WordLists {
 }
 /**
  * Native code generated from the catalog, for the parts of an app outside the browser: a tray, a
- * menu bar, a CLI. One file, holding every locale, with a typed function per message.
+ * menu bar, a CLI. One file, holding every locale, with a typed function per message; for Android and
+ * Apple, string resources, a file per locale.
  */
 interface NativeTarget {
-  language: 'rust' | 'swift' | 'kotlin';
-  /** The file written. */
+  language: 'rust' | 'swift' | 'kotlin' | 'android' | 'apple';
+  /**
+   * The file written; for Android, the `res` folder its `values*` folders go in, and for Apple, the
+   * folder its `.lproj` folders go in.
+   */
   out: string;
   /**
    * Key prefixes the file holds: `['native']` takes every `native.*` key, which it names without the
    * prefix (`native.tray.quit` is `tray_quit`). Every key, named in full, by default.
    */
   keys?: string[];
-  /** The type holding the locales and messages: `Locale` in Rust, `Copy` in Swift and Kotlin. */
+  /**
+   * The type holding the locales and messages: `Locale` in Rust, `Copy` in Swift and Kotlin. For
+   * Android, the resource file's name: `strings`, for `values/strings.xml`. For Apple, the table's:
+   * `Localizable`, or `InfoPlist` with `plist`.
+   */
   name?: string;
   /** Kotlin's package. */
   package?: string;
+  /**
+   * For Apple, the Info.plist the table translates: each key names one of its strings, spelled in
+   * words (`ns-camera-usage-description` is `NSCameraUsageDescription`), and the source must say
+   * what the plist says.
+   */
+  plist?: string;
 }
 interface ProsebookConfig {
   /** The source-language catalog: one `<area>.yaml` per area. */
@@ -573,4 +587,4 @@ declare const CONFIG_FILES: string[];
 declare function loadConfig(root: string, inline?: ProsebookConfig): Promise<ResolvedConfig>;
 declare function resolveConfig(root: string, config: ProsebookConfig): ResolvedConfig;
 export { loadCatalog as $, RuleContext as A, DEFAULT_KINDS as B, Finding as C, Readings as D, Plugin as E, lint as F, Catalog as G, KindRule as H, phrase as I, KEY_PATTERN as J, CatalogError as K, sentences as L, applyEdits as M, compileRule as N, Report as O, definePlugin as P, entryLocation as Q, singularOf as R, ExistenceRule as S, OccurrenceRule as T, STRICT_LISTS as U, DEFAULT_SURFACES as V, Severity as W, Problem as X, Message as Y, Translation as Z, CapitalizationRule as _, ResolvedConfig as a, CoreRule as b, loadConfig as c, Mf2Function as d, previewOf as et, intlDate as f, CORE_RULES as g, toMf2 as h, ProsebookConfig as i, SubstitutionRule as j, Rule as k, resolveConfig as l, parseMf2 as m, LintConfig as n, MessageFormatElement as nt, WordLists as o, intlNumber as p, EntryLocation as q, NativeTarget as r, defineConfig as s, CONFIG_FILES as t, whereOf as tt, Isolate as u, CheckRule as v, HOLE as w, Edit as x, ConditionalRule as y, words as z };
-//# sourceMappingURL=config-DdMkKt_N.d.ts.map
+//# sourceMappingURL=config-CzaJJQ60.d.ts.map

package/dist/{config-DdMkKt_N.d.ts.map → config-CzaJJQ60.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"config-DdMkKt_N.d.ts","names":[],"sources":["../src/tools/catalog.ts","../src/tools/presets.ts","../src/tools/lint.ts","../src/tools/mf2.ts","../src/tools/config.ts"],"mappings":"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"}
+{"version":3,"file":"config-CzaJJQ60.d.ts","names":[],"sources":["../src/tools/catalog.ts","../src/tools/presets.ts","../src/tools/lint.ts","../src/tools/mf2.ts","../src/tools/config.ts"],"mappings":"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"}

package/dist/{config-BPSmoYel.js → config-nWZf9QmF.js}

@@ -917,7 +917,9 @@ const STRICT_LISTS = {
 const NATIVE_NAMES = {
 	rust: "Locale",
 	swift: "Copy",
-	kotlin: "Copy"
+	kotlin: "Copy",
+	android: "strings",
+	apple: "Localizable"
 };
 /** Typed config, for `prosebook.config.ts`. */
 function defineConfig(config) {
@@ -978,10 +980,14 @@ function resolveConfig(root, config) {
 		},
 		native: (config.native ?? []).map((target, i) => {
 			if (!(target.language in NATIVE_NAMES)) throw new Error(`native[${i}].language is "${target.language}": name one of ${Object.keys(NATIVE_NAMES).join(", ")}`);
+			if (target.plist !== void 0 && target.language !== "apple") throw new Error(`native[${i}].plist names an Info.plist, which only the apple target reads: remove it, or set language to 'apple'`);
+			const plist = target.plist === void 0 ? {} : { plist: at(target.plist) };
+			const name = target.name ?? (target.plist === void 0 ? NATIVE_NAMES[target.language] : "InfoPlist");
 			return {
 				...target,
 				out: at(target.out),
-				name: target.name ?? NATIVE_NAMES[target.language]
+				name,
+				...plist
 			};
 		}),
 		scan: {
@@ -1029,4 +1035,4 @@ function lintRules(lint) {
 }
 export { words as _, DEFAULT_KINDS as a, CORE_RULES as c, compileRule as d, definePlugin as f, singularOf as g, sentences as h, resolveConfig as i, HOLE as l, phrase as m, defineConfig as n, DEFAULT_SURFACES as o, lint as p, loadConfig as r, STRICT_LISTS as s, CONFIG_FILES as t, applyEdits as u };
 
-//# sourceMappingURL=config-BPSmoYel.js.map
+//# sourceMappingURL=config-nWZf9QmF.js.map