fix global references

2026-10-20 00:02:32 +00:00 · 2026-06-17 05:29:45 +01:00
parent ae9c46f8f0
commit 497fd04081
14 changed files with 479 additions and 42 deletions
@@ -0,0 +1,210 @@
+// Refactor global variables (setTimeout, document, navigator, etc.) to use compatGlobal.
+// Use this script by running `deno run --allow-read --allow-write --allow-run refactor-globals.ts` from the utilsdeno directory.
+// Run with --run flag to apply changes.
+import { Project, SyntaxKind, Node } from "npm:ts-morph";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const isDryRun = !Deno.args.includes("--run");
+
+if (isDryRun) {
+    console.log("=== DRY RUN MODE ===");
+    console.log(
+        "To apply changes, run with: deno run --allow-read --allow-write --allow-run refactor-globals.ts --run\n"
+    );
+} else {
+    console.log("=== RUN MODE: WILL MODIFY FILES ===");
+}
+
+const project = new Project({ tsConfigFilePath: "../tsconfig.json" });
+
+// Manually add files under src/ to ensure those excluded by tsconfig.json are processed if needed.
+project.addSourceFilesAtPaths("../src/**/*.ts");
+project.addSourceFilesAtPaths("../src/**/*.svelte");
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const projectRoot = path.resolve(__dirname, "..");
+
+function toPosixPath(filePath: string): string {
+    return filePath.replace(/\\/g, "/");
+}
+
+const posixProjectRoot = toPosixPath(projectRoot);
+const posixSrc = `${posixProjectRoot}/src`;
+const posixLibSrc = `${posixProjectRoot}/src/lib`;
+
+const TARGET_GLOBALS = new Set([
+    "setTimeout",
+    "clearTimeout",
+    "setInterval",
+    "clearInterval",
+    "requestAnimationFrame",
+    "cancelAnimationFrame",
+    "localStorage",
+    "navigator",
+    "location",
+    "document",
+    "window"
+]);
+
+let modifiedFilesCount = 0;
+
+for (const sourceFile of project.getSourceFiles()) {
+    const filePath = sourceFile.getFilePath();
+    const posixFilePath = toPosixPath(filePath);
+
+    // Only process files inside the project src directory.
+    if (!posixFilePath.startsWith(posixSrc)) {
+        continue;
+    }
+
+    // Exclude submodule files under src/lib/
+    if (posixFilePath.startsWith(posixLibSrc)) {
+        continue;
+    }
+
+    // Exclude independent application modules under src/apps/
+    if (posixFilePath.startsWith(`${posixSrc}/apps/`)) {
+        continue;
+    }
+
+    // Exclude unit and integration test files
+    if (
+        posixFilePath.endsWith(".spec.ts") ||
+        posixFilePath.endsWith(".test.ts") ||
+        posixFilePath.includes("/_test/")
+    ) {
+        continue;
+    }
+
+    // Collect all identifier nodes
+    const identifiers = sourceFile.getDescendantsOfKind(SyntaxKind.Identifier);
+    const nodesToReplace: { node: Node; replacement: string }[] = [];
+
+    for (const idNode of identifiers) {
+        const name = idNode.getText();
+        if (!TARGET_GLOBALS.has(name)) {
+            continue;
+        }
+
+        const parent = idNode.getParent();
+        if (!parent) {
+            continue;
+        }
+
+        // 1. Skip if it is the property name in a PropertyAccessExpression (e.g. the "setTimeout" in "obj.setTimeout")
+        if (parent.getKind() === SyntaxKind.PropertyAccessExpression) {
+            const propAccess = parent.asKindOrThrow(SyntaxKind.PropertyAccessExpression);
+            if (propAccess.getNameNode() === idNode) {
+                continue;
+            }
+        }
+
+        // 2. Skip if it is the operand of a typeof expression (e.g. "typeof window")
+        if (parent.getKind() === SyntaxKind.TypeOfExpression) {
+            continue;
+        }
+
+        // 3. Skip if it is a declaration name node
+        const kind = parent.getKind();
+        if (
+            kind === SyntaxKind.VariableDeclaration ||
+            kind === SyntaxKind.Parameter ||
+            kind === SyntaxKind.FunctionDeclaration ||
+            kind === SyntaxKind.MethodDeclaration ||
+            kind === SyntaxKind.PropertyDeclaration ||
+            kind === SyntaxKind.ClassDeclaration ||
+            kind === SyntaxKind.InterfaceDeclaration ||
+            kind === SyntaxKind.TypeAliasDeclaration ||
+            kind === SyntaxKind.ImportSpecifier ||
+            kind === SyntaxKind.ExportSpecifier ||
+            kind === SyntaxKind.MethodSignature ||
+            kind === SyntaxKind.PropertySignature ||
+            kind === SyntaxKind.PropertyAssignment
+        ) {
+            if ((parent as any).getNameNode?.() === idNode || (parent as any).getName?.() === name) {
+                continue;
+            }
+        }
+
+        // 4. Verify it is a global variable reference using definitions
+        let isGlobal = false;
+        try {
+            const definitions = idNode.getDefinitions();
+            isGlobal =
+                definitions.length === 0 ||
+                definitions.every((def) => {
+                    const sf = def.getSourceFile();
+                    if (!sf) return true;
+                    const path = sf.getFilePath();
+                    return path.includes("node_modules/typescript/lib/") || path.includes("node_modules/@types/");
+                });
+        } catch (_err) {
+            // If checking definitions fails, assume it is local/imported to be safe
+            isGlobal = false;
+        }
+
+        if (!isGlobal) {
+            continue;
+        }
+
+        // Determine replacement
+        let replacement = "";
+        if (name === "window" || name === "globalThis") {
+            replacement = "compatGlobal";
+        } else {
+            replacement = `compatGlobal.${name}`;
+        }
+
+        nodesToReplace.push({ node: idNode, replacement });
+    }
+
+    if (nodesToReplace.length > 0) {
+        console.log(`File: ${posixFilePath.slice(posixProjectRoot.length + 1)}`);
+        for (const { node, replacement } of nodesToReplace) {
+            const { line } = sourceFile.getLineAndColumnAtPos(node.getStart());
+            console.log(`  Line ${line}: "${node.getText()}" -> "${replacement}"`);
+        }
+
+        if (!isDryRun) {
+            // Apply replacements
+            // Note: replaceWithText changes AST, so we replace them directly
+            for (const { node, replacement } of nodesToReplace) {
+                node.replaceWithText(replacement);
+            }
+
+            // Ensure compatGlobal is imported
+            const hasCompatGlobalImport = sourceFile.getImportDeclarations().some((imp) => {
+                return imp.getNamedImports().some((ni) => ni.getName() === "compatGlobal");
+            });
+
+            if (!hasCompatGlobalImport) {
+                const existingImport = sourceFile.getImportDeclarations().find((imp) => {
+                    const spec = imp.getModuleSpecifierValue();
+                    return spec === "@lib/common/coreEnvFunctions" || spec === "@lib/common/coreEnvFunctions.ts";
+                });
+
+                if (existingImport) {
+                    existingImport.addNamedImport("compatGlobal");
+                } else {
+                    sourceFile.addImportDeclaration({
+                        namedImports: ["compatGlobal"],
+                        moduleSpecifier: "@lib/common/coreEnvFunctions.ts"
+                    });
+                }
+            }
+        }
+
+        modifiedFilesCount++;
+    }
+}
+
+console.log(`\nTotal files to modify: ${modifiedFilesCount}`);
+
+if (!isDryRun) {
+    project.saveSync();
+    console.log("All changes successfully saved.");
+} else {
+    console.log("Dry run complete. No changes were written to files.");
+}