create-procode 1.0.0 → 1.1.0

package/templates/tests-multi-language/src/multiLanguage/enText.ts

@@ -0,0 +1,68 @@
+import {
+  candidateKeys,
+  flattenMessages,
+  interpolate,
+  parseMessageRef,
+} from "procode-lowcode-core";
+
+/**
+ * Test helper: the English text of an "@t:" reference, read straight from this
+ * app's public/locales/en/*.json (no Core, no async loading) and formatted by
+ * core's own engine — the same plural suffixes (`_one` / `_other`) and `{name}`
+ * placeholders `translate` applies. Once a screen's text is moved into the
+ * translation files its schema holds references, not English; a test that
+ * asserts what a user sees reads it back through this:
+ *
+ *   expect(enText(result.message)).toBe("Please enter a name");
+ *
+ * Plain text is returned unchanged. Library keys (core.*, widget.*, kendo.*,
+ * template.*) are not in these files; a key with no English THROWS, so a typo
+ * fails its test loudly instead of passing on a raw key.
+ */
+const bundles = import.meta.glob<Record<string, unknown>>("/public/locales/en/*.json", {
+  eager: true,
+  import: "default",
+});
+
+// One flat table, `<namespace>.<key>` → text, built the way core builds it from
+// the same files (each file's content sits under its namespace).
+const english: Record<string, string> = {};
+Object.entries(bundles).forEach(([file, messages]) => {
+  const namespace = file.replace(/^.*\//, "").replace(/\.json$/, "");
+  flattenMessages({ [namespace]: messages as Record<string, string> }, "", english);
+});
+
+/** Is this key (or a plural form of it) in the English files? */
+export const hasEnglish = (key: string, params?: Record<string, unknown>): boolean =>
+  candidateKeys(key, "en", params as never).some((k) => k in english);
+
+export const enText = (value: unknown): unknown => {
+  if (typeof value !== "string") return value;
+  const ref = parseMessageRef(value);
+  if (!ref) return value;
+  const key = candidateKeys(ref.key, "en", ref.params).find((k) => k in english);
+  if (key === undefined) throw new Error(`enText: no English for "${ref.key}"`);
+  return interpolate(english[key], ref.params, "en");
+};
+
+/**
+ * For a schema test that asserts the English copy: every "@t:" reference in the
+ * given schema object is replaced, in place, by its English. Vitest gives each
+ * test file its own module graph, so the change stays inside that file.
+ */
+export const withEnglishText = <T>(value: T): T => {
+  const seen = new WeakSet<object>();
+  const walk = (node: unknown): void => {
+    if (!node || typeof node !== "object" || seen.has(node as object)) return;
+    seen.add(node as object);
+    Object.entries(node as Record<string, unknown>).forEach(([key, item]) => {
+      if (typeof item === "string" && item.startsWith("@t:")) {
+        (node as Record<string, unknown>)[key] = enText(item);
+      } else {
+        walk(item);
+      }
+    });
+  };
+  walk(value);
+  return value;
+};

package/templates/tests-multi-language/src/multiLanguage/translations.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, it } from "vitest";
+import { parseMessageRef } from "procode-lowcode-core";
+import Header from "../Module/Header.json";
+import { hasEnglish } from "./enText";
+
+/**
+ * Nothing missing, in any language. A gap is silent at runtime — the screen shows
+ * the English (or, for a typo'd key, the raw key) with one console warning — so
+ * these turn it into a failing test:
+ *
+ *   1. every "@t:" reference in a screen JSON has English text;
+ *   2. every language offered in Header.json has every key English has, in
+ *      every namespace the app owns;
+ *   3. a translation uses only {placeholders} its English has — a misspelt
+ *      one is printed literally. (Dropping one is allowed: English's plural
+ *      "contact{s}" needs no {s} in Hindi.)
+ *
+ * The library namespaces (core, widget, kendo, template) are not checked: the
+ * libraries carry their own English, and an untranslated library key falls back
+ * to it.
+ */
+
+const LIBRARY = new Set(["core", "widget", "kendo", "template"]);
+const settings = (Header as any).multiLanguage;
+const codes: string[] = settings.locales.map((l: { code: string }) => l.code);
+const appNamespaces: string[] = settings.resources.namespaces.filter((ns: string) => !LIBRARY.has(ns));
+
+const files = import.meta.glob<Record<string, string>>("/public/locales/*/*.json", {
+  eager: true,
+  import: "default",
+});
+const bundle = (code: string, ns: string): Record<string, string> | undefined =>
+  files[`/public/locales/${code}/${ns}.json`];
+
+const screens = Object.entries(
+  import.meta.glob<Record<string, any>>("../Module/**/*.json", { eager: true, import: "default" }),
+).filter(([, schema]) => schema && typeof schema === "object" && "rootScreenElement" in schema);
+
+/** Every "@t:" string anywhere in a value. */
+const references = (value: unknown, out: string[] = []): string[] => {
+  if (typeof value === "string") {
+    if (value.startsWith("@t:")) out.push(value);
+  } else if (value && typeof value === "object") {
+    Object.values(value).forEach((item) => references(item, out));
+  }
+  return out;
+};
+
+const placeholders = (text: string) => (text.match(/\{\s*[A-Za-z0-9_.-]+/g) ?? []).map((p) => p.replace(/[{\s]/g, "")).sort();
+
+describe("translations", () => {
+  it("every reference in a screen has English text", () => {
+    const missing = screens.flatMap(([file, schema]) =>
+      references(schema)
+        .map((ref) => parseMessageRef(ref))
+        .filter((ref) => ref && !LIBRARY.has(ref.key.split(".")[0]) && !hasEnglish(ref.key, ref.params))
+        .map((ref) => `${file}: ${ref!.key}`),
+    );
+    expect(missing).toEqual([]);
+  });
+
+  it("every language has every key English has", () => {
+    const gaps = codes
+      .filter((code) => code !== "en")
+      .flatMap((code) =>
+        appNamespaces.flatMap((ns) => {
+          const english = bundle("en", ns) ?? {};
+          const other = bundle(code, ns) ?? {};
+          return Object.keys(english)
+            .filter((key) => !(key in other))
+            .map((key) => `${code}/${ns}.json: ${key}`);
+        }),
+      );
+    expect(gaps).toEqual([]);
+  });
+
+  it("a translation uses no {placeholder} its English lacks", () => {
+    const changed = codes
+      .filter((code) => code !== "en")
+      .flatMap((code) =>
+        appNamespaces.flatMap((ns) => {
+          const english = bundle("en", ns) ?? {};
+          const other = bundle(code, ns) ?? {};
+          return Object.keys(english)
+            .filter((key) => key in other)
+            .filter((key) => placeholders(other[key]).some((p) => !placeholders(english[key]).includes(p)))
+            .map((key) => `${code}/${ns}.json: ${key}`);
+        }),
+      );
+    expect(changed).toEqual([]);
+  });
+});