@loozo/angular-router 0.0.1 → 0.0.3

package/node/src/generation/sources.js

@@ -4,6 +4,8 @@ import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { parsePath } from "../../_core/src/path.js";
 import { auditPath, contains, metadata, walk, workspacePaths, markers } from "./files.js";
+import { overlayDirectory, overlayHost } from "./overlay.js";
+import { synchronize, transparent } from "./filesystem.js";
 export function fail(node, message) {
     const source = node.getSourceFile();
     const position = source.getLineAndCharacterOfPosition(node.getStart());
@@ -39,7 +41,7 @@ export function properties(node, label) {
 export function resolveModule(name, source, options, host = ts.sys) {
     return ts.resolveModuleName(name, source, options, host).resolvedModule?.resolvedFileName;
 }
-function namedImport(source, name, imported) {
+export function namedImport(source, name, imported) {
     if (!ts.isIdentifier(name)) {
         return undefined;
     }
@@ -88,8 +90,8 @@ function moduleText(statement) {
     }
     return statement.moduleSpecifier.text;
 }
-async function genuineImport(statement, expected, options) {
-    const actual = resolveModule(moduleText(statement), statement.getSourceFile().fileName, options);
+export async function genuineImport(statement, expected, options, host = ts.sys) {
+    const actual = resolveModule(moduleText(statement), statement.getSourceFile().fileName, options, host);
     if (!actual) {
         return false;
     }
@@ -170,25 +172,25 @@ const keys = new Set([
     "title",
     "data",
 ]);
-export async function discover(workspace, config, scans, out) {
+export async function discover(workspace, config, scans, out, auto, authored = new Map(), filesystem = auto !== undefined, launch, compiler) {
+    if (scans.length !== 1) {
+        throw new Error("scanDirectories must contain exactly one directory");
+    }
     const access = await workspacePaths(workspace);
-    const configFile = await access.resolve(config);
+    const configFile = access.resolve(config);
     const configDirectory = dirname(configFile);
-    const output = await access.resolve(out);
-    const resolvedRoots = await Promise.all(scans.map((scan) => access.resolve(resolve(configDirectory, scan))));
-    const roots = [...new Set(resolvedRoots)].sort();
-    for (const root of roots) {
-        if (contains(root, output) || contains(output, root)) {
-            throw new Error(`Output and scan directory overlap: ${output}; ${root}`);
-        }
+    const output = access.resolve(out);
+    const root = access.resolve(resolve(configDirectory, scans[0]));
+    const roots = [root];
+    if (contains(root, output) || contains(output, root)) {
+        throw new Error(`Output and scan directory overlap: ${output}; ${root}`);
     }
     await Promise.all([auditPath(configFile), auditPath(output)]);
-    const encountered = [
-        ...new Set((await Promise.all(roots.map((root) => walk(root)))).flat()),
-    ].sort();
+    const encountered = (await walk(root)).sort();
     const fatal = [];
     const parsed = ts.getParsedCommandLineOfConfigFile(configFile, {}, {
         ...ts.sys,
+        readDirectory: overlayDirectory(authored, (directory) => access.resolve(directory, true)),
         onUnRecoverableConfigFileDiagnostic: (diagnostic) => fatal.push(diagnostic),
     });
     const errors = [...fatal, ...(parsed?.errors ?? [])].filter((error) => error.code !== 18003);
@@ -201,16 +203,27 @@ export async function discover(workspace, config, scans, out) {
                 getNewLine: () => "\n",
             }));
     }
-    const candidates = [];
+    // Canonicalize only permitted workspace-access prefixes, never source links.
+    // Membership, candidate discovery and the final program share these roots.
+    const admitted = new Set();
     for (const file of parsed.fileNames) {
-        const normalized = await access.resolve(file);
+        admitted.add(access.resolve(file));
+    }
+    parsed.fileNames = [...admitted];
+    for (const file of authored.keys()) {
+        if (!admitted.has(file)) {
+            throw new Error(`TypeScript config does not admit filesystem definition: ${file}`);
+        }
+    }
+    const candidates = [];
+    for (const normalized of parsed.fileNames) {
         if (!normalized.endsWith(".ts") ||
             normalized.endsWith(".d.ts") ||
             normalized.split(sep).includes("node_modules")) {
             continue;
         }
         await auditPath(normalized);
-        if (roots.some((root) => contains(root, normalized))) {
+        if (launch || contains(root, normalized)) {
             candidates.push(normalized);
         }
     }
@@ -220,15 +233,31 @@ export async function discover(workspace, config, scans, out) {
     const manifest = JSON.parse(manifestBytes);
     const factoryEntry = await realpath(resolve(packageRoot, manifest.exports["."].types));
     const declarations = [];
+    const launchDeclarations = [];
+    const launchEntry = launch && (await realpath(launch.typeEntry));
     const pages = new Map();
     const deferredFactories = [];
-    const syntaxProgram = ts.createProgram({
-        rootNames: candidates,
-        options: parsed.options,
-        host: ts.createCompilerHost(parsed.options, true),
-    });
+    const syntaxHost = overlayHost(parsed.options, authored);
+    let syntaxProgram;
+    if (compiler) {
+        syntaxProgram = compiler.createProgram(candidates, parsed.options, syntaxHost);
+    }
+    else {
+        syntaxProgram = ts.createProgram({
+            rootNames: candidates,
+            options: parsed.options,
+            host: syntaxHost,
+        });
+    }
     for (const file of candidates) {
-        const bytes = await readFile(file, "utf8");
+        const bytes = syntaxHost.readFile(file);
+        if (bytes === undefined) {
+            if (auto) {
+                // An explicit tsconfig files entry may name a not-yet-seeded definition.
+                continue;
+            }
+            throw new Error(`Cannot read admitted TypeScript source: ${file}`);
+        }
         if (file.endsWith(`${sep}route.generated.ts`) &&
             bytes.split("\n", 1)[0] === markers["route.generated.ts"]) {
             continue;
@@ -260,6 +289,33 @@ export async function discover(workspace, config, scans, out) {
             fail(defaults[1], "Multiple competing default exports");
         }
         const node = defaults[0];
+        const inRoutes = contains(root, file);
+        if (launchEntry && ts.isExportAssignment(node) && ts.isCallExpression(node.expression)) {
+            const call = node.expression;
+            let kind;
+            let imported = namedImport(source, call.expression, "defineContext");
+            if (imported) {
+                kind = "defineContext";
+            }
+            else if (inRoutes) {
+                imported = namedImport(source, call.expression, "defineRpc");
+                if (imported) {
+                    kind = "defineRpc";
+                }
+            }
+            if (kind && imported) {
+                if (!(await genuineImport(imported, launchEntry, parsed.options, syntaxHost))) {
+                    fail(imported, `${kind} must resolve to Launch's concrete server entry`);
+                }
+                launchDeclarations.push({ file, kind, call });
+                continue;
+            }
+        }
+        // Context is audited over all application roots; unrelated bootstrap defaults
+        // outside route scans are not route declarations.
+        if (!inRoutes) {
+            continue;
+        }
         if (ts.isClassDeclaration(node)) {
             await component(source, node, parsed.options);
             if (pages.has(dirname(file))) {
@@ -294,7 +350,8 @@ export async function discover(workspace, config, scans, out) {
             fail(path, String(error));
         }
         const needsParams = segments.some((segment) => segment.kind !== "static");
-        if (needsParams !== config.has("params")) {
+        const ignored = filesystem && transparent(roots[0], dirname(file));
+        if (!auto && !ignored && needsParams !== config.has("params")) {
             fail(configNode, "Local params must be present exactly when the path declares placeholders");
         }
         const data = config.get("data");
@@ -316,6 +373,7 @@ export async function discover(workspace, config, scans, out) {
             file,
             id,
             source,
+            rawText: authored.get(resolve(file)) ?? (await readFile(file, "utf8")),
             config,
             path: path.text,
             segments,
@@ -325,19 +383,35 @@ export async function discover(workspace, config, scans, out) {
             full: false,
         };
         const ownFacade = resolve(dirname(file), "route.generated.ts");
-        const resolved = resolveModule(moduleText(imported), file, parsed.options);
+        const resolved = resolveModule(moduleText(imported), file, parsed.options, syntaxHost);
         const facadeSpelling = resolve(dirname(file), moduleText(imported)).replace(/\.js$/, ".ts");
         if (resolved === ownFacade || (!resolved && facadeSpelling === ownFacade)) {
             deferredFactories.push(declaration);
         }
         else {
-            const genuine = await genuineImport(imported, factoryEntry, parsed.options);
+            const genuine = await genuineImport(imported, factoryEntry, parsed.options, syntaxHost);
             if (!genuine) {
                 fail(imported, "defineRoute import does not resolve to this package's concrete public entry");
             }
         }
         declarations.push(declaration);
     }
+    if (auto) {
+        const edits = await synchronize(roots[0], declarations, pages, parsed.options, auto, syntaxProgram.getTypeChecker());
+        return discover(workspace, config, scans, out, undefined, edits, true, launch, compiler);
+    }
+    if (filesystem) {
+        for (let index = declarations.length - 1; index >= 0; index -= 1) {
+            const declaration = declarations[index];
+            if (transparent(roots[0], dirname(declaration.file))) {
+                declarations.splice(index, 1);
+                const deferred = deferredFactories.indexOf(declaration);
+                if (deferred >= 0) {
+                    deferredFactories.splice(deferred, 1);
+                }
+            }
+        }
+    }
     const byDirectory = new Map();
     const byFile = new Map();
     for (const declaration of declarations) {
@@ -365,7 +439,7 @@ export async function discover(workspace, config, scans, out) {
                 statement.importClause?.name?.text !== node.text) {
                 continue;
             }
-            const file = resolveModule(moduleText(statement), declaration.file, compilerOptions);
+            const file = resolveModule(moduleText(statement), declaration.file, compilerOptions, syntaxHost);
             const target = file && byFile.get(file);
             if (target) {
                 return target;
@@ -480,6 +554,10 @@ export async function discover(workspace, config, scans, out) {
             fail(declaration.source, "Factory facade is not a final retained generated location");
         }
     }
+    let launchSources;
+    if (launchEntry) {
+        launchSources = { typeEntry: launchEntry, declarations: launchDeclarations };
+    }
     return {
         configFile,
         parsed,
@@ -489,5 +567,8 @@ export async function discover(workspace, config, scans, out) {
         declarations,
         factoryEntry,
         deferredFactories,
+        authored,
+        filesystem,
+        launch: launchSources,
     };
 }

package/node/src/generation/validate.d.ts

@@ -0,0 +1,12 @@
+import ts from "typescript";
+import { type Declaration, type Sources } from "./sources.js";
+import type { CompilerState } from "./compiler.js";
+import { AnchorState } from "./anchor.js";
+export declare function authoredPath(declaration: Declaration): string;
+export declare function selections(sources: Sources): Map<string, Declaration>;
+export declare function createValidationProgram(sources: Sources, generated: ReadonlyMap<string, string>, stale: readonly string[], compiler?: CompilerState): {
+    program: ts.Program;
+    host: ts.CompilerHost;
+    obsolete: Set<string>;
+};
+export declare function validateRoutes(sources: Sources, generated: ReadonlyMap<string, string>, validation: ReturnType<typeof createValidationProgram>, canonical?: AnchorState): Promise<void>;

package/node/src/generation/validate.js

@@ -3,6 +3,8 @@ import { realpath } from "node:fs/promises";
 import { basename, dirname, resolve, sep } from "node:path";
 import { auditPath, contains } from "./files.js";
 import { fail, properties, resolveModule } from "./sources.js";
+import { overlayHost } from "./overlay.js";
+import { AnchorState } from "./anchor.js";
 export function authoredPath(declaration) {
     const parts = [];
     for (const segment of declaration.effective) {
@@ -110,9 +112,13 @@ export function selections(sources) {
     }
     return result;
 }
-// Overlay only the final generated locations. Never evaluate application code.
-export async function validateProgram(sources, generated, stale) {
-    const host = ts.createCompilerHost(sources.parsed.options);
+// Overlay only final generated locations. Never evaluate application code.
+export function createValidationProgram(sources, generated, stale, compiler) {
+    const options = { ...sources.parsed.options };
+    if (sources.launch) {
+        options.skipLibCheck = false;
+    }
+    const host = overlayHost(options, sources.authored);
     const originalRead = host.readFile.bind(host);
     const originalExists = host.fileExists.bind(host);
     const originalDirectoryExists = host.directoryExists.bind(host);
@@ -140,14 +146,38 @@ export async function validateProgram(sources, generated, stale) {
         }
         return ts.createSourceFile(file, text, language, true);
     };
-    const program = ts.createProgram({
-        rootNames: [
-            ...sources.parsed.fileNames.filter((file) => !obsolete.has(resolve(file))),
-            sources.factoryEntry,
-        ],
-        options: sources.parsed.options,
-        host,
-    });
+    const rootNames = [
+        ...sources.parsed.fileNames.filter((file) => !obsolete.has(resolve(file))),
+        sources.factoryEntry,
+    ];
+    if (sources.launch) {
+        rootNames.push(sources.launch.typeEntry, ...generated.keys());
+    }
+    let program;
+    if (compiler) {
+        program = compiler.createProgram(rootNames, options, host);
+    }
+    else {
+        program = ts.createProgram({ rootNames, options, host });
+    }
+    return { program, host, obsolete };
+}
+export async function validateRoutes(sources, generated, validation, canonical) {
+    const { program, host, obsolete } = validation;
+    if (sources.filesystem) {
+        const diagnostics = [];
+        for (const declaration of sources.declarations) {
+            const source = program.getSourceFile(declaration.file);
+            diagnostics.push(...program.getSyntacticDiagnostics(source), ...program.getSemanticDiagnostics(source));
+        }
+        if (diagnostics.length > 0) {
+            throw new Error(ts.formatDiagnostics(diagnostics, {
+                getCanonicalFileName: (name) => name,
+                getCurrentDirectory: () => dirname(sources.configFile),
+                getNewLine: () => "\n",
+            }));
+        }
+    }
     const checker = program.getTypeChecker();
     const entry = program.getSourceFile(sources.factoryEntry);
     const entryModule = checker.getSymbolAtLocation(entry);
@@ -161,20 +191,8 @@ export async function validateProgram(sources, generated, stale) {
     // Anchor the public export's declaration independently of application paths,
     // which can also redirect imports inside the concrete public type entry.
     const canonicalOptions = { ...sources.parsed.options, paths: undefined, baseUrl: undefined };
-    const canonicalProgram = ts.createProgram({
-        rootNames: [sources.factoryEntry],
-        options: canonicalOptions,
-        host: ts.createCompilerHost(canonicalOptions, true),
-    });
-    const canonicalChecker = canonicalProgram.getTypeChecker();
-    const canonicalEntry = canonicalProgram.getSourceFile(sources.factoryEntry);
-    const canonicalModule = canonicalChecker.getSymbolAtLocation(canonicalEntry);
-    let canonicalFactory = canonicalChecker
-        .getExportsOfModule(canonicalModule)
-        .find((symbol) => symbol.name === "defineRoute");
-    if (canonicalFactory.flags & ts.SymbolFlags.Alias) {
-        canonicalFactory = canonicalChecker.getAliasedSymbol(canonicalFactory);
-    }
+    const anchor = await (canonical ?? new AnchorState()).anchor(sources.factoryEntry, ["defineRoute"], canonicalOptions);
+    const canonicalFactory = anchor.get("defineRoute");
     // Tentative own-facade admission is not authority for its re-exported binding.
     // Prove both the concrete module boundary and the final native alias identity.
     for (const declaration of sources.declarations) {
@@ -200,17 +218,14 @@ export async function validateProgram(sources, generated, stale) {
         }
         if (!actualFactory?.declarations?.length ||
             actualFactory !== concreteFactory ||
-            actualFactory.declarations.length !== canonicalFactory.declarations?.length) {
+            actualFactory.declarations.length !== canonicalFactory?.length) {
             fail(call, "Factory binding does not resolve to the concrete defineRoute export");
         }
         for (let index = 0; index < actualFactory.declarations.length; index += 1) {
             const actual = actualFactory.declarations[index];
-            const canonical = canonicalFactory.declarations[index];
-            const [actualFile, canonicalFile] = await Promise.all([
-                realpath(actual.getSourceFile().fileName),
-                realpath(canonical.getSourceFile().fileName),
-            ]);
-            if (actualFile !== canonicalFile ||
+            const canonical = canonicalFactory[index];
+            const actualFile = await realpath(actual.getSourceFile().fileName);
+            if (actualFile !== canonical.file ||
                 actual.kind !== canonical.kind ||
                 actual.pos !== canonical.pos ||
                 actual.end !== canonical.end) {
@@ -222,6 +237,10 @@ export async function validateProgram(sources, generated, stale) {
         resolve(sources.output, "routes.generated.ts"),
         resolve(sources.output, "destinations.generated.ts"),
     ]);
+    if (sources.launch) {
+        globalTargets.add(resolve(sources.output, "context.generated.d.ts"));
+        globalTargets.add(resolve(sources.output, "server.generated.ts"));
+    }
     for (const source of program.getSourceFiles()) {
         if (source.fileName.includes("/node_modules/") ||
             program.isSourceFileFromExternalLibrary(source) ||
@@ -277,7 +296,8 @@ export async function validateProgram(sources, generated, stale) {
                 candidates.add(resolve(file));
             }
             for (const candidate of candidates) {
-                const facadeTarget = basename(candidate) === "route.generated.ts" &&
+                const facadeTarget = (basename(candidate) === "route.generated.ts" ||
+                    (sources.launch && basename(candidate) === "rpc.generated.ts")) &&
                     !candidate.split(sep).includes("node_modules") &&
                     sources.roots.some((root) => contains(root, candidate));
                 if ((facadeTarget || globalTargets.has(candidate)) && !generated.has(candidate)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loozo/angular-router",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Typed route declarations, URLs, navigation and route handles for Angular's native router.",
   "bugs": "https://github.com/theo-matzavinos/loozo/issues",
   "license": "MIT",
@@ -24,6 +24,10 @@
       "types": "./types/loozo-angular-router-_generated.d.ts",
       "default": "./fesm2022/loozo-angular-router-_generated.mjs"
     },
+    "./_generation": {
+      "types": "./node/src/generation/index.d.ts",
+      "node": "./node/src/generation/index.js"
+    },
     "./package.json": {
       "default": "./package.json"
     }
@@ -33,13 +37,14 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@angular-devkit/architect": "0.2201.5",
+    "@angular-devkit/architect": "0.2202.2",
     "chokidar": "5.0.0",
     "rxjs": "7.8.2",
     "tslib": "2.8.1",
     "typescript": "6.0.3"
   },
   "peerDependencies": {
+    "@angular/build": "~22.2.0",
     "@angular/core": "^22.0.0",
     "@angular/router": "^22.0.0"
   },