create-procode 0.0.0-stage → 1.1.0

package/templates/multi-language/sample/fr.json

@@ -0,0 +1,55 @@
+{
+  "activate": "Activer",
+  "active": "Actif",
+  "addContact": "Ajouter un contact",
+  "anythingTheTeamShouldKnow": "Tout ce que l'équipe doit savoir",
+  "asiaPacific": "Asie-Pacifique",
+  "cancel": "Annuler",
+  "changeTheStatusOfTheSelectedContacts": "Modifier le statut des contacts sélectionnés ?",
+  "city": "Ville",
+  "confirmation": "Confirmation",
+  "contactDetails": "Coordonnées du contact",
+  "contacts": "Contacts",
+  "contactSaved": "Contact enregistré",
+  "countContactSWillBeUpdated": "{count} contact{s} vont être mis à jour.",
+  "deactivate": "Désactiver",
+  "delete": "Supprimer",
+  "deleteTheSelectedContacts": "Supprimer les contacts sélectionnés ?",
+  "department": "Service",
+  "departments": "Services",
+  "eGCtA1b2": "ex. CT_A1B2",
+  "email": "E-mail",
+  "engineering": "Ingénierie",
+  "europe": "Europe",
+  "finance": "Finance",
+  "fullName": "Nom complet",
+  "joined": "Arrivée",
+  "keepThem": "Les conserver",
+  "keepTheNameUnder40Characters": "Le nom doit faire moins de 40 caractères",
+  "name": "Nom",
+  "nameCompanyCom": "nom@entreprise.com",
+  "no": "Non",
+  "northAmerica": "Amérique du Nord",
+  "notes": "Notes",
+  "notesAreLimitedTo200Characters": "Les notes sont limitées à 200 caractères",
+  "onlyAskedForTheSalesDepartment": "Demandé uniquement pour le service Ventes",
+  "pleaseChooseADepartment": "Veuillez choisir un service",
+  "pleaseEnterAName": "Veuillez saisir un nom",
+  "pleaseEnterAnEmailAddress": "Veuillez saisir une adresse e-mail",
+  "referenceCode": "Code de référence",
+  "sales": "Ventes",
+  "salesRegion": "Région commerciale",
+  "save": "Enregistrer",
+  "saved": "Enregistré",
+  "selectADepartment": "Sélectionnez un service",
+  "selectARegion": "Sélectionnez une région",
+  "selectRowsForBulkActionsClickA": "Sélectionnez des lignes pour les actions groupées, cliquez sur un nom pour le modifier, ou ajoutez un contact. Tout le comportement de cette page est déclaré dans src/Module/Sample/Contacts.json.",
+  "status": "Statut",
+  "support": "Support",
+  "thatDoesNotLookLikeAnEmail": "Cette adresse e-mail ne semble pas valide",
+  "totalContacts": "Total des contacts",
+  "useCapitalsDigitsAndUnderscoreOnly": "Utilisez uniquement des majuscules, des chiffres et le trait de soulignement",
+  "yesChangeIt": "Oui, modifier",
+  "youAreAboutToDeleteCountContact": "Vous allez supprimer {count} contact{s}. Cette action est irréversible.",
+  "yyyyMmDd": "aaaa-mm-jj"
+}

package/templates/multi-language/sample/hi.json

@@ -0,0 +1,55 @@
+{
+  "activate": "सक्रिय करें",
+  "active": "सक्रिय",
+  "addContact": "संपर्क जोड़ें",
+  "anythingTheTeamShouldKnow": "टीम को जो कुछ भी जानना चाहिए",
+  "asiaPacific": "एशिया-प्रशांत",
+  "cancel": "रद्द करें",
+  "changeTheStatusOfTheSelectedContacts": "चुने गए संपर्कों की स्थिति बदलें?",
+  "city": "शहर",
+  "confirmation": "पुष्टि",
+  "contactDetails": "संपर्क विवरण",
+  "contacts": "संपर्क",
+  "contactSaved": "संपर्क सहेजा गया",
+  "countContactSWillBeUpdated": "{count} संपर्क अपडेट किए जाएँगे।",
+  "deactivate": "निष्क्रिय करें",
+  "delete": "हटाएँ",
+  "deleteTheSelectedContacts": "चुने गए संपर्क हटाएँ?",
+  "department": "विभाग",
+  "departments": "विभाग",
+  "eGCtA1b2": "उदा. CT_A1B2",
+  "email": "ईमेल",
+  "engineering": "इंजीनियरिंग",
+  "europe": "यूरोप",
+  "finance": "वित्त",
+  "fullName": "पूरा नाम",
+  "joined": "शामिल होने की तिथि",
+  "keepThem": "रहने दें",
+  "keepTheNameUnder40Characters": "नाम 40 अक्षरों से कम रखें",
+  "name": "नाम",
+  "nameCompanyCom": "name@company.com",
+  "no": "नहीं",
+  "northAmerica": "उत्तरी अमेरिका",
+  "notes": "टिप्पणियाँ",
+  "notesAreLimitedTo200Characters": "टिप्पणियाँ 200 अक्षरों तक सीमित हैं",
+  "onlyAskedForTheSalesDepartment": "केवल बिक्री विभाग के लिए पूछा जाता है",
+  "pleaseChooseADepartment": "कृपया एक विभाग चुनें",
+  "pleaseEnterAName": "कृपया एक नाम दर्ज करें",
+  "pleaseEnterAnEmailAddress": "कृपया एक ईमेल पता दर्ज करें",
+  "referenceCode": "संदर्भ कोड",
+  "sales": "बिक्री",
+  "salesRegion": "बिक्री क्षेत्र",
+  "save": "सहेजें",
+  "saved": "सहेजा गया",
+  "selectADepartment": "एक विभाग चुनें",
+  "selectARegion": "एक क्षेत्र चुनें",
+  "selectRowsForBulkActionsClickA": "सामूहिक कार्रवाई के लिए पंक्तियाँ चुनें, संपादित करने के लिए किसी नाम पर क्लिक करें, या नया संपर्क जोड़ें। इस पृष्ठ का हर व्यवहार src/Module/Sample/Contacts.json में घोषित है।",
+  "status": "स्थिति",
+  "support": "सहायता",
+  "thatDoesNotLookLikeAnEmail": "यह ईमेल पता सही नहीं लगता",
+  "totalContacts": "कुल संपर्क",
+  "useCapitalsDigitsAndUnderscoreOnly": "केवल बड़े अक्षर, अंक और अंडरस्कोर का उपयोग करें",
+  "yesChangeIt": "हाँ, बदलें",
+  "youAreAboutToDeleteCountContact": "आप {count} संपर्क हटाने वाले हैं। यह पूर्ववत नहीं किया जा सकता।",
+  "yyyyMmDd": "yyyy-mm-dd"
+}

package/templates/tests/src/Module/schemas.test.ts

@@ -0,0 +1,50 @@
+import { beforeAll, describe, expect, it } from "vitest";
+
+/**
+ * Wiring guards for every screen under src/Module.
+ *
+ * Each failure this file catches is SILENT at runtime: a slug with no branch in
+ * getSchemaBySlugService is "page not found" with nothing in the console, and two
+ * screens sharing a screenId share one adapter. Add a screen JSON and these run
+ * against it with no edit here.
+ */
+
+// constant.ts reads the auth cookie when it loads, and the registries reach it
+// through their imports. Stub the two browser globals before anything loads —
+// hence the dynamic import in beforeAll rather than a static one (that would be
+// hoisted above these lines; top-level await is unavailable at the es2020 target
+// vite.config.ts keeps for Kendo).
+(globalThis as any).document ??= { cookie: "" };
+(globalThis as any).window ??= { location: { search: "" } };
+
+let getSchemaBySlugService: (slug: string, appCode: string) => unknown;
+beforeAll(async () => {
+  ({ getSchemaBySlugService } = await import("./index"));
+});
+
+/** Every JSON under src/Module that is a screen (has a rootScreenElement). */
+const screens = Object.entries(
+  import.meta.glob<Record<string, any>>("./**/*.json", { eager: true, import: "default" }),
+).filter(([, schema]) => schema && typeof schema === "object" && "rootScreenElement" in schema);
+
+describe("screens under src/Module", () => {
+  it("each declares a slug and a screenId", () => {
+    const missing = screens
+      .filter(([, schema]) => !schema.slug || !schema.screenId)
+      .map(([file]) => file);
+    expect(missing).toEqual([]);
+  });
+
+  it("each slug is registered in getSchemaBySlugService (else the URL is page-not-found)", () => {
+    const unregistered = screens
+      .filter(([, schema]) => schema.slug && getSchemaBySlugService(schema.slug, "") !== schema)
+      .map(([file, schema]) => `${file} (slug "${schema.slug}")`);
+    expect(unregistered).toEqual([]);
+  });
+
+  it("no two screens share a screenId (they would share one adapter)", () => {
+    const ids = screens.map(([, schema]) => schema.screenId).filter(Boolean);
+    const duplicates = ids.filter((id, i) => ids.indexOf(id) !== i);
+    expect(duplicates).toEqual([]);
+  });
+});

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([]);
+  });
+});