@loozo/angular-router 0.0.2 → 0.0.4

package/node/src/generation/sources.js

@@ -41,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;
     }
@@ -90,7 +90,7 @@ function moduleText(statement) {
     }
     return statement.moduleSpecifier.text;
 }
-async function genuineImport(statement, expected, options, host = ts.sys) {
+export async function genuineImport(statement, expected, options, host = ts.sys) {
     const actual = resolveModule(moduleText(statement), statement.getSourceFile().fileName, options, host);
     if (!actual) {
         return false;
@@ -167,12 +167,13 @@ const keys = new Set([
     "canActivate",
     "canActivateChild",
     "canMatch",
+    "onInvalidParams",
     "canDeactivate",
     "providers",
     "title",
     "data",
 ]);
-export async function discover(workspace, config, scans, out, auto, authored = new Map(), filesystem = auto !== undefined) {
+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");
     }
@@ -223,7 +224,7 @@ export async function discover(workspace, config, scans, out, auto, authored = n
             continue;
         }
         await auditPath(normalized);
-        if (contains(root, normalized)) {
+        if (launch || contains(root, normalized)) {
             candidates.push(normalized);
         }
     }
@@ -233,14 +234,22 @@ export async function discover(workspace, config, scans, out, auto, authored = n
     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 syntaxHost = overlayHost(parsed.options, authored);
-    const syntaxProgram = ts.createProgram({
-        rootNames: candidates,
-        options: parsed.options,
-        host: syntaxHost,
-    });
+    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 = syntaxHost.readFile(file);
         if (bytes === undefined) {
@@ -281,6 +290,33 @@ export async function discover(workspace, config, scans, out, auto, authored = n
             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))) {
@@ -319,6 +355,9 @@ export async function discover(workspace, config, scans, out, auto, authored = n
         if (!auto && !ignored && needsParams !== config.has("params")) {
             fail(configNode, "Local params must be present exactly when the path declares placeholders");
         }
+        if (!auto && !ignored && !needsParams && config.has("onInvalidParams")) {
+            fail(configNode, "onInvalidParams requires local path placeholders");
+        }
         const data = config.get("data");
         if (data && ts.isObjectLiteralExpression(data)) {
             for (const property of data.properties) {
@@ -363,7 +402,7 @@ export async function discover(workspace, config, scans, out, auto, authored = n
     }
     if (auto) {
         const edits = await synchronize(roots[0], declarations, pages, parsed.options, auto, syntaxProgram.getTypeChecker());
-        return discover(workspace, config, scans, out, undefined, edits, true);
+        return discover(workspace, config, scans, out, undefined, edits, true, launch, compiler);
     }
     if (filesystem) {
         for (let index = declarations.length - 1; index >= 0; index -= 1) {
@@ -435,8 +474,9 @@ export async function discover(workspace, config, scans, out, auto, authored = n
             if (declaration.page ||
                 declaration.children.length ||
                 declaration.config.has("canActivate") ||
-                declaration.config.has("canMatch")) {
-                fail(redirect, "Redirect cannot have a component, children, canActivate or canMatch");
+                declaration.config.has("canMatch") ||
+                declaration.config.has("onInvalidParams")) {
+                fail(redirect, "Redirect cannot have a component, children, canActivate, canMatch or onInvalidParams");
             }
             declaration.retained = false;
         }
@@ -519,6 +559,10 @@ export async function discover(workspace, config, scans, out, auto, authored = n
             fail(declaration.source, "Factory facade is not a final retained generated location");
         }
     }
+    let launchSources;
+    if (launchEntry) {
+        launchSources = { typeEntry: launchEntry, declarations: launchDeclarations };
+    }
     return {
         configFile,
         parsed,
@@ -530,5 +574,6 @@ export async function discover(workspace, config, scans, out, auto, authored = n
         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

@@ -4,6 +4,7 @@ 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) {
@@ -111,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 = overlayHost(sources.parsed.options, sources.authored);
+// 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);
@@ -141,14 +146,24 @@ 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) {
@@ -176,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) {
@@ -215,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) {
@@ -237,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) ||
@@ -292,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)) {
@@ -370,7 +375,7 @@ export async function validateProgram(sources, generated, stale) {
                 fail(redirect, `Incompatible logical redirect params: ${sourceKey} -> ${targetKey.name}`);
             }
         }
-        const sourceSearch = typeWitness(declaration, "__search");
+        // Every search key is optional when writing a URL, so only replacement values need checking.
         const targetSearch = typeWitness(declaration.target, "__search");
         const search = fields.get("search");
         const fragment = fields.get("fragment");
@@ -415,22 +420,6 @@ export async function validateProgram(sources, generated, stale) {
                 fail(value, "Redirect replacement fragment is not declared by its destination");
             }
         }
-        const required = targetSearch
-            .getProperties()
-            .filter((property) => !(property.flags & ts.SymbolFlags.Optional));
-        if (mode.text === "drop" && required.length > 0) {
-            fail(search, `Cannot drop required destination search: ${required.map((property) => property.name).join(", ")}`);
-        }
-        if (mode.text === "preserve") {
-            for (const key of required) {
-                const sourceKey = sourceSearch.getProperty(key.name);
-                if (!sourceKey ||
-                    sourceKey.flags & ts.SymbolFlags.Optional ||
-                    !checker.isTypeAssignableTo(checker.getTypeOfSymbolAtLocation(sourceKey, search), checker.getTypeOfSymbolAtLocation(key, search))) {
-                    fail(search, `Source cannot guarantee required destination search: ${key.name}`);
-                }
-            }
-        }
         if (mode.text === "replace") {
             const values = policy.get("values");
             if (!values) {
@@ -439,15 +428,22 @@ export async function validateProgram(sources, generated, stale) {
             const type = checker.getTypeAtLocation(values);
             for (const key of type.getProperties()) {
                 const targetKey = targetSearch.getProperty(key.name);
-                if (!targetKey ||
-                    !checker.isTypeAssignableTo(checker.getTypeOfSymbolAtLocation(key, values), checker.getTypeOfSymbolAtLocation(targetKey, values))) {
+                if (!targetKey) {
                     fail(values, `Unknown/incompatible redirect replacement key: ${key.name}`);
                 }
-            }
-            for (const key of required) {
-                const supplied = type.getProperty(key.name);
-                if (!supplied || supplied.flags & ts.SymbolFlags.Optional) {
-                    fail(values, `Missing required redirect replacement: ${key.name}`);
+                // Replacements use the write type, `Value | undefined`: undefined omits the key, even
+                // one that reads a fallback, so only the other constituents must be codec values.
+                const supplied = checker.getTypeOfSymbolAtLocation(key, values);
+                const target = checker.getTypeOfSymbolAtLocation(targetKey, values);
+                let constituents = [supplied];
+                if (supplied.isUnion()) {
+                    constituents = supplied.types;
+                }
+                for (const constituent of constituents) {
+                    if (!(constituent.flags & ts.TypeFlags.Undefined) &&
+                        !checker.isTypeAssignableTo(constituent, target)) {
+                        fail(values, `Unknown/incompatible redirect replacement key: ${key.name}`);
+                    }
                 }
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loozo/angular-router",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "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"
   },