@intentius/chant 0.6.0 → 0.8.0

package/src/codegen/post-synth-barrel-guards.test.ts

@@ -0,0 +1,63 @@
+import { describe, test, expect } from "vitest";
+import { build } from "esbuild";
+import { readFileSync, readdirSync, existsSync } from "fs";
+import { fileURLToPath } from "url";
+import { join } from "path";
+import { renderPostSynthBarrelForDir } from "./generate-post-synth-barrel";
+
+const repoRoot = fileURLToPath(new URL("../../../../", import.meta.url));
+const lexiconsDir = join(repoRoot, "lexicons");
+const lexiconDirs = readdirSync(lexiconsDir).filter((name) =>
+  existsSync(join(lexiconsDir, name, "src", "lint", "post-synth", "index.ts")),
+);
+
+describe("post-synth barrel freshness", () => {
+  test.each(lexiconDirs)("%s barrel is up to date (run npm run generate)", (lexicon) => {
+    const dir = join(lexiconsDir, lexicon, "src", "lint", "post-synth");
+    const committed = readFileSync(join(dir, "index.ts"), "utf-8");
+    const regenerated = renderPostSynthBarrelForDir(dir, import.meta.url);
+    expect(committed, `${lexicon} barrel is stale — run \`npm run generate\``).toBe(regenerated);
+  });
+});
+
+describe("post-synth barrel is exported", () => {
+  // A lexicon that ships a barrel must export it so consumers can import
+  // `@intentius/chant-lexicon-<lex>/lint/post-synth` without `/index` (#417).
+  test.each(lexiconDirs)("%s exports ./lint/post-synth", (lexicon) => {
+    const pkg = JSON.parse(readFileSync(join(lexiconsDir, lexicon, "package.json"), "utf-8"));
+    const entry = pkg.exports?.["./lint/post-synth"];
+    // Lexicons shipping .d.ts use a conditional export — `types` resolves to the
+    // emitted declaration for external consumers; `development`/`default` keep
+    // runtime resolution on source (in-repo and published alike). Lexicons not
+    // yet building dist keep the plain source string.
+    if (typeof entry === "string") {
+      expect(entry).toBe("./src/lint/post-synth/index.ts");
+    } else {
+      expect(entry?.development).toBe("./src/lint/post-synth/index.ts");
+      expect(entry?.types).toBe("./dist/lint/post-synth/index.d.ts");
+      expect(entry?.default).toBe("./src/lint/post-synth/index.ts");
+    }
+  });
+});
+
+describe("post-synth barrel is edge-bundle clean", () => {
+  // The barrel is the entry an edge/bundled deployment imports. It must not drag
+  // in the TypeScript compiler or the fs/tsx runtime loader (#409).
+  test("github barrel bundles without typescript or the fs loader", async () => {
+    const entry = join(lexiconsDir, "github", "src", "lint", "post-synth", "index.ts");
+    const result = await build({
+      entryPoints: [entry],
+      bundle: true,
+      format: "esm",
+      platform: "node",
+      metafile: true,
+      write: false,
+      outfile: "out.js",
+      logLevel: "silent",
+    });
+    const inputs = Object.keys(result.metafile.inputs);
+    expect(inputs.some((p) => p.includes("node_modules/typescript"))).toBe(false);
+    // The runtime fs+tsx loader must not be in the graph.
+    expect(inputs.some((p) => p.includes("lint/discover"))).toBe(false);
+  }, 30_000);
+});

package/src/codegen/validate.ts

@@ -25,6 +25,14 @@ export interface LexiconValidationConfig {
   lexiconJsonFilename: string;
   /** Required backward-compatible export names to check in lexicon JSON */
   requiredNames: string[];
+  /**
+   * When true, a required name is satisfied if it appears as a substring of any
+   * lexicon JSON key (not only as an exact key). Lexicons that bound their
+   * generated type expansion (e.g. azure, #438) emit shared types under
+   * resource-prefixed/variant names, so the bare curated name is present only
+   * as a substring. Defaults to false (exact-key match).
+   */
+  requiredNamesMatchSubstring?: boolean;
   /** Base path of the lexicon package */
   basePath: string;
   /** Path to the generated directory (defaults to basePath/src/generated) */
@@ -70,7 +78,11 @@ export async function validateLexiconArtifacts(config: LexiconValidationConfig):
 
   // Check 3: Required backward-compatible names present in lexicon JSON
   if (lexiconData && config.requiredNames.length > 0) {
-    const missing = config.requiredNames.filter((name) => !(name in lexiconData!));
+    const keys = Object.keys(lexiconData);
+    const present = config.requiredNamesMatchSubstring
+      ? (name: string) => keys.some((k) => k.includes(name))
+      : (name: string) => name in lexiconData!;
+    const missing = config.requiredNames.filter((name) => !present(name));
     if (missing.length > 0) {
       checks.push({
         name: "required-names",

package/src/lint/discover.ts

@@ -84,7 +84,7 @@ export function discoverPostSynthChecks(dir: string, importMetaUrl: string): Pos
 /**
  * List rule files in a directory (excluding tests, helpers, index).
  */
-function listRuleFiles(dir: string): string[] {
+export function listRuleFiles(dir: string): string[] {
   try {
     return readdirSync(dir).filter((f) => {
       if (!f.endsWith(".ts")) return false;

package/src/meta/peer-deps.test.ts

@@ -0,0 +1,29 @@
+import { describe, test, expect } from "vitest";
+import { readFileSync, readdirSync, existsSync } from "fs";
+import { fileURLToPath } from "url";
+import { join } from "path";
+
+/**
+ * The lexicon packages are published in lockstep with core, so their
+ * `@intentius/*` peerDependencies must track the current core version. They were
+ * once frozen at `^0.1.0` while shipping at 0.7.0, which made a clean
+ * `npm install` fail (#411). This locks the invariant so it can't drift again.
+ */
+const repoRoot = fileURLToPath(new URL("../../../../", import.meta.url));
+const coreVersion = JSON.parse(readFileSync(join(repoRoot, "packages/core/package.json"), "utf-8")).version as string;
+const expected = `^${coreVersion}`;
+
+const lexiconsDir = join(repoRoot, "lexicons");
+const lexicons = readdirSync(lexiconsDir).filter((name) => existsSync(join(lexiconsDir, name, "package.json")));
+
+describe("lexicon peerDependencies track the core version", () => {
+  test.each(lexicons)("%s pins @intentius/* peers to the current version", (lexicon) => {
+    const pkg = JSON.parse(readFileSync(join(lexiconsDir, lexicon, "package.json"), "utf-8"));
+    const peers: Record<string, string> = pkg.peerDependencies ?? {};
+    for (const [dep, range] of Object.entries(peers)) {
+      if (dep.startsWith("@intentius/")) {
+        expect(range, `${lexicon}: peer ${dep} should be ${expected}`).toBe(expected);
+      }
+    }
+  });
+});