fix: keep DOM globals internal

Author: jderochervlk

docs/content/docs/philosophy.mdx

@@ -19,7 +19,7 @@ In other words, if you are searching for a specific JavaScript binding, begin yo
 The bindings are exposed under the `WebAPI` namespace with the same flat module structure as the original package.
 
 ```ReScript
-open WebAPI.DomGlobal
+open WebAPI.DOM
 
 let myElement: WebAPI.Element.t = document->WebAPI.Document.createElement("div")
 ```
@@ -43,7 +43,7 @@ JavaScript supports function overloads, where a function can have multiple signa
 In some cases, type conversion will be required. Subtypes can safely be cast to their base type using conversion helpers within their module.
 
 ```ReScript
-open WebAPI.DomGlobal
+open WebAPI.DOM
 
 let element: WebAPI.Element.t = document->WebAPI.Document.createElement("div")
 let node: WebAPI.Node.t = element->WebAPI.Element.asNode

docs/llm.js

@@ -96,6 +96,38 @@ Module: ${moduleName}${typeString}${functionString}
 }
 
 const specByDir = new Map(featureSpecs.map((spec) => [spec.dirName, spec]));
+const rootDir = path.join(import.meta.dirname, "..");
+const rootConfig = JSON.parse(await fs.readFile(path.join(rootDir, "rescript.json"), "utf-8"));
+const publicModulesBySourceDir = new Map(
+  rootConfig.sources
+    .filter((source) => typeof source === "object")
+    .filter((source) => source.dir?.startsWith("src/") && Array.isArray(source.public))
+    .map((source) => [source.dir, new Set(source.public)]),
+);
+
+function normalizeRelativePath(filePath) {
+  return path.relative(rootDir, filePath).split(path.sep).join("/");
+}
+
+function sourceDirForRelativePath(relativePath) {
+  for (const sourceDir of publicModulesBySourceDir.keys()) {
+    if (relativePath.startsWith(`${sourceDir}/`)) {
+      return sourceDir;
+    }
+  }
+}
+
+function isPublicFile(filePath) {
+  const relativePath = normalizeRelativePath(filePath);
+  const sourceDir = sourceDirForRelativePath(relativePath);
+
+  if (!sourceDir) {
+    return false;
+  }
+
+  const moduleName = path.basename(relativePath, ".res").replace("$", "");
+  return publicModulesBySourceDir.get(sourceDir).has(moduleName);
+}
 
 function moduleNameForFile(relativePath) {
   const [, dirName, fileName] = relativePath.split(path.sep);
@@ -113,7 +145,11 @@ function moduleNameForFile(relativePath) {
 const pattern = "../src/*/**/*.res";
 const files = [];
 for await (const file of fs.glob(pattern, { recursive: true, cwd: import.meta.dirname })) {
-  files.push(path.join(import.meta.dirname, file));
+  const filePath = path.join(import.meta.dirname, file);
+
+  if (isPublicFile(filePath)) {
+    files.push(filePath);
+  }
 }
 files.sort();
 

docs/utils.js

@@ -6,6 +6,14 @@ import { micromark } from "micromark";
 import { featureSpecs } from "../scripts/unmonorepo/feature-spec.mjs";
 
 const execAsync = promisify(exec);
+const rootDir = process.cwd();
+const rootConfig = JSON.parse(readFileSync(path.join(rootDir, "rescript.json"), "utf8"));
+const publicModulesBySourceDir = new Map(
+  rootConfig.sources
+    .filter((source) => typeof source === "object")
+    .filter((source) => source.dir?.startsWith("src/") && Array.isArray(source.public))
+    .map((source) => [source.dir, new Set(source.public)]),
+);
 
 function toKebabCase(input) {
   return input
@@ -31,10 +39,12 @@ function mapTypeModules(parentModuleLink, file, spec) {
     return [];
   }
 
+  const publicModules = publicModulesBySourceDir.get(spec.sourceDir) ?? new Set();
   const typesFileName = `${spec.internalPrefix}Types.res`;
   const files = readdirSync(folder);
   return files
     .filter((f) => f.endsWith(".res") && f !== typesFileName)
+    .filter((file) => publicModules.has(file.replace("$", "").replace(".res", "")))
     .map((file) => {
       const filePath = path.join(folder, file);
 

rescript.json

@@ -96,7 +96,6 @@
         "Document",
         "DocumentFragment",
         "DocumentTimeline",
-        "DomGlobal",
         "DomHTMLMediaElement",
         "Element",
         "ElementInternals",

scripts/unmonorepo/write-root-config.mjs

@@ -2,7 +2,14 @@ import fs from "node:fs";
 import path from "node:path";
 import { featureSpecs } from "./feature-spec.mjs";
 
-export function publicModulesForSourceDir(sourceDir) {
+export function isPublicModuleName(spec, moduleName) {
+  if (moduleName.endsWith("Types")) return false;
+  if (spec.dirName === "DOM" && moduleName === "DomGlobal") return false;
+
+  return true;
+}
+
+export function publicModulesForSourceDir(sourceDir, spec) {
   if (!fs.existsSync(sourceDir)) return [];
 
   const publicModules = new Set();
@@ -14,7 +21,7 @@ export function publicModulesForSourceDir(sourceDir) {
     if (extension !== ".res" && extension !== ".resi") continue;
 
     const moduleName = path.basename(entry.name, extension);
-    if (moduleName.endsWith("Types")) continue;
+    if (!isPublicModuleName(spec, moduleName)) continue;
 
     publicModules.add(moduleName);
   }
@@ -30,7 +37,7 @@ export function buildRootRescriptJson(specs) {
         dir: `src/${spec.dirName}`,
         subdirs: true,
         feature: spec.featureName,
-        public: (spec.publicModules ?? []).filter((moduleName) => !moduleName.endsWith("Types")),
+        public: (spec.publicModules ?? []).filter((moduleName) => isPublicModuleName(spec, moduleName)),
       })),
       {
         dir: "tests",
@@ -67,7 +74,7 @@ export function writeRootConfig(rootDir) {
   const currentPackage = JSON.parse(fs.readFileSync(packagePath, "utf8"));
   const specsWithPublicModules = featureSpecs.map((spec) => ({
     ...spec,
-    publicModules: publicModulesForSourceDir(path.join(rootDir, spec.sourceDir)),
+    publicModules: publicModulesForSourceDir(path.join(rootDir, spec.sourceDir), spec),
   }));
 
   fs.writeFileSync(rescriptPath, `${JSON.stringify(buildRootRescriptJson(specsWithPublicModules), null, 2)}\n`);

tests/unmonorepo/release-files.test.mjs

@@ -20,16 +20,21 @@ test("docs and CI point at the unified package layout", () => {
   assert.match(docsIndex, /ReScript WebAPI/);
   assert.match(docsIndex, /WebAPI\.Global/);
   assert.match(docsIndex, /location->WebAPI\.Location\.reload/);
-  assert.match(docsPhilosophy, /open WebAPI\.DomGlobal/);
+  assert.match(docsPhilosophy, /open WebAPI\.DOM/);
+  assert.doesNotMatch(docsPhilosophy, /WebAPI\.DomGlobal/);
   assert.match(docsPhilosophy, /let myElement: WebAPI\.Element\.t = document->WebAPI\.Document\.createElement/);
   assert.match(docsPhilosophy, /let node: WebAPI\.Node\.t = element->WebAPI\.Element\.asNode/);
   assert.match(docsContributing, /open WebAPI/);
   assert.doesNotMatch(docsContributing, /open WebAPI\.DOM/);
   assert.match(designSpec, /original flat public API module shape/);
   assert.match(designSpec, /Use `WebAPI\.\*` spelling, not `WebApi\.\*`\./);
-  assert.match(docsLlm, /\.\.\/src\/\*\/\*\*\/\*\.res/);
-  assert.match(docsLlm, /WebAPI\.\$\{leafName\}/);
+  assert.match(docsLlm, /rescript\.json/);
+  assert.match(docsLlm, /source\.public/);
+  assert.match(docsLlm, /isPublicFile\(filePath\)/);
   assert.match(docsUtils, /path\.resolve\(process\.cwd\(\), "src"\)/);
+  assert.match(docsUtils, /rescript\.json/);
+  assert.match(docsUtils, /source\.public/);
+  assert.match(docsUtils, /publicModules\.has/);
   assert.doesNotMatch(docsUtils, /path\.resolve\(process\.cwd\(\), "packages"\)/);
   assert.match(workflow, /npm pack\b/);
   assert.match(workflow, /npm publish --access public --tag experimental/);
@@ -50,4 +55,8 @@ test("root rescript.json keeps generated type modules internal", () => {
       `${source.dir} should not expose *Types modules`,
     );
   }
+
+  const domSource = sourceEntries.find((source) => source.dir === "src/DOM");
+  assert.ok(domSource, "src/DOM source entry should exist");
+  assert.ok(!domSource.public.includes("DomGlobal"), "src/DOM should keep DomGlobal internal");
 });

tests/unmonorepo/write-root-config.test.mjs

@@ -12,7 +12,7 @@ test("builds the unified root rescript.json and package.json", () => {
       dirName: "DOM",
       publicModule: "DOM",
       featureName: "WebAPI.DOM",
-      publicModules: ["Document", "DomTypes", "Element"],
+      publicModules: ["Document", "DomGlobal", "DomTypes", "Element"],
     },
   ];