@abide/abide 0.103.0 → 0.105.0

package/src/compiler/checkApp.ts

@@ -1,22 +1,11 @@
 import { relative } from 'node:path' // bun exposes no path helpers of its own
-import { appFiles } from '#server/appTree.ts'
-import { placeOf } from '#shared/routePattern.ts'
-import {
-    type AppChecker,
-    emitApp,
-    resolverIn,
-    sourcesUnder,
-    withChecker,
-    withDependencies,
-} from './compileApp.ts'
+import { type Placement, placement } from '#server/placement.ts'
+import { type AppChecker, compiled } from './compileApp.ts'
 import { abideImportsOf } from './componentGraph.ts'
-import { projectShadow } from './projectShadow.ts'
-import {
-    parseSources,
-    type ReadSource,
-    readSources,
-    refusal,
-} from './readSources.ts'
+import { hooksIn } from './hookCalls.ts'
+import { parseAbide, scriptBodies } from './parseAbide.ts'
+import { Refusals } from './Refusals.ts'
+import { parseSources, readSources } from './readSources.ts'
 import type { Diagnosis } from './TypeSession.ts'
 
 /**
@@ -30,82 +19,21 @@ import type { Diagnosis } from './TypeSession.ts'
  * which is right for a build and wrong for a check: a file the parser or the read classifier
  * refuses is reported at its first line, and the rest of the app is checked around it. A refusal
  * only the whole app can see — two handlers at one address — comes from emitting it over the reads
- * already taken, which is asked only once every file has got that far on its own.
+ * of every file that got that far (`compiled`).
  */
 export async function checkApp(
     appRoot: string,
     kept?: AppChecker,
 ): Promise<Diagnosis[]> {
-    const { root, sources } = await sourcesUnder(appRoot)
-    return withChecker(root, kept, async (session) => {
-        const refused: Diagnosis[] = []
-        const own = parseSources(sources, refused)
-        // 23.16-23.18 — what the build's walk would refuse of the tree, at each file it names.
-        const { handlers } = appFiles(root, (path, message) => {
-            refused.push(refusal(`${root}/${path}`, message))
-        })
-        const resolve = resolverIn()
-        const { sources: everyParsed, handlers: handlerFiles } =
-            await withDependencies(root, own, handlers, resolve, refused)
-        // 38.33 — A FILE WHOSE PROJECTION IS REFUSED (34.3, 34.17) is a finding at its file, found
-        // here because every later step projects it and would throw the refusal for the whole app.
-        // AFTER THE IMPORTS ARE FOLLOWED, so a refused file another one imports is found too.
-        const parsed: typeof everyParsed = []
-        for (const source of everyParsed)
-            try {
-                projectShadow(source.file)
-                parsed.push(source)
-            } catch (thrown) {
-                refused.push(refusal(source.path, thrown))
-            }
-        const { read, warnings } = await readSources(session, parsed, refused)
-        // THE APP'S OWN FILES ARE REPORTED ON: a dependency's is compiled with them (34.23), and
-        // what is wrong inside a package is the package's to report.
-        const reported: ReadSource[] = []
-        for (const source of read)
-            if (placeOf(relative(root, source.path)) !== 'dependency')
-                reported.push(source)
-        const { diagnoses: found, refused: loweringRefused } =
-            await session.diagnose(reported, root)
-        const { ambient, unkeyed } = await session.lints(root, parsed)
-        // A FILE WHOSE LOWERING REFUSED is `found` already, at its line — emitted too, it throws the
-        // same refusal at the root and takes the rest of the app's findings with it.
-        const emittable: ReadSource[] = []
-        for (const source of read)
-            if (!loweringRefused.has(source.path)) emittable.push(source)
-        if (refused.length === 0 && ambient.length === 0)
-            try {
-                warnings.push(
-                    ...(
-                        await emitApp(
-                            root,
-                            session,
-                            emittable,
-                            resolve,
-                            handlerFiles,
-                            // 38.33 — each at its file, and every one rather than the first.
-                            (relative, thrown) =>
-                                refused.push(
-                                    refusal(`${root}/${relative}`, thrown),
-                                ),
-                        )
-                    ).warnings,
-                )
-            } catch (thrown) {
-                refused.push(refusal(root, thrown))
-            }
-        return [...refused, ...ambient, ...unkeyed, ...warnings, ...found]
-    })
+    return (await compiled(appRoot, kept, true)).findings
 }
 
-const FILES_CONFIG = /^\s*onConfig\s*\(/m
-
 /**
  * The findings for one file as an editor holds it, saved or not.
  *
  * 38.11 — ONE FILE AS AN EDITOR HOLDS IT, saved or not: the same findings `checkApp` has for it, for
  * `abide lsp` to publish. The rest of the app is read from disk, as it stands — save a file `held`
- * has, which is one the editor holds too.
+ * has, which is one the editor holds too — and so is what the tree refuses of this one (38.34).
  *
  * 33.4 — THE COMPONENTS IT IMPORTS ARE LOWERED BESIDE IT, quietly, so a tag is held to the props its
  * component declares rather than to a stand-in that takes anything. One level: what a component
@@ -118,14 +46,24 @@ export async function checkSource(
     held: (path: string) => string | undefined = () => undefined,
 ): Promise<Diagnosis[]> {
     const { session, root } = checker
-    const refused: Diagnosis[] = []
-    const [page] = parseSources([{ path, text }], refused)
-    if (page === undefined) return refused
+    const layout = await checker.layout()
+    // 38.33 — WHAT THE TREE REFUSES OF IT, off the layout the checker keeps until a move is heard.
+    const tree: Diagnosis[] = []
+    for (const refused of layout.refused)
+        if (refused.path === path) tree.push(refused)
+    const refusals = new Refusals(root, true)
+    const [page] = parseSources([{ path, text }], refusals)
+    if (page === undefined) return [...tree, ...refusals.found]
+    // 23.19 — WHERE THE APP PLACES IT, so a mounted page's `route.params` is typed by the route its
+    // mount gives it, as `checkApp` types it; a file the layout has not seen is placed at its path.
+    const placed: Pick<Placement, 'kind' | 'route'> =
+        layout.sources.find((source) => source.path === path) ??
+        placement(relative(root, path))
     const imports: { path: string; text: string; quiet: boolean }[] = []
     for (const imported of abideImportsOf(
         path,
         page.file,
-        resolverIn(),
+        layout.resolve,
     ).values())
         try {
             imports.push({
@@ -137,26 +75,52 @@ export async function checkSource(
             // A component that cannot be read takes anything here.
         }
     // 27.13 — AND EVERY FILE FILING `onConfig`, quietly, so a page that only reads `config()` is
-    // typed by defaults it never imported — as `checkApp`'s whole-app program types it. The scan
-    // only names candidates (a statement opening on the call); the checker decides which file.
+    // typed by defaults it never imported — as `checkApp`'s whole-app program types it. The calls
+    // only name candidates; the checker decides which file.
     const lowered = new Set(imports.map((one) => one.path))
-    const { sources } = await checker.sources()
-    for (const other of sources) {
+    for (const other of layout.sources) {
         if (other.path === path || lowered.has(other.path)) continue
-        const text = held(other.path) ?? other.text
-        if (text.includes('onConfig') && FILES_CONFIG.test(text))
-            imports.push({ path: other.path, text, quiet: true })
+        const editing = held(other.path)
+        if (
+            editing === undefined || editing === other.text
+                ? other.hooks.includes('onConfig')
+                : filesConfig(editing)
+        )
+            imports.push({
+                path: other.path,
+                text: editing ?? other.text,
+                quiet: true,
+            })
     }
     // A component that does not parse, or that the checker refuses, is its own file's finding and
     // takes anything here: a quiet source's refusal is reported by nobody.
     const { read, warnings } = await readSources(
         session,
-        [page, ...parseSources(imports, refused)],
-        refused,
+        [page, ...parseSources(imports, refusals)],
+        refusals,
     )
-    if (refused.length > 0) return refused
+    if (refusals.found.length > 0) return [...tree, ...refusals.found]
     const own: Diagnosis[] = []
     for (const warning of warnings) if (warning.path === path) own.push(warning)
-    const { diagnoses } = await session.diagnose(read, root, false)
-    return [...own, ...diagnoses]
+    const [checked, ...beside] = read
+    const { diagnoses } = await session.diagnose(
+        checked === undefined
+            ? beside
+            : [
+                  { ...checked, kind: placed.kind, route: placed.route },
+                  ...beside,
+              ],
+        layout,
+        false,
+    )
+    return [...tree, ...own, ...diagnoses]
+}
+
+/** Whether a `.abide` an editor holds calls `onConfig`, where its text parses. */
+function filesConfig(text: string): boolean {
+    try {
+        return hooksIn(scriptBodies(parseAbide(text))).includes('onConfig')
+    } catch {
+        return false
+    }
 }

package/src/compiler/checkedShadow.ts

@@ -1,12 +1,14 @@
 import { SERVER_SPECIFIER } from '#shared/SPECIFIERS.ts'
 import type { CheckerAnswer } from './CheckerAnswer.ts'
 import type { Finding } from './Finding.ts'
+import { hookCalls } from './hookCalls.ts'
 import {
     CHECKED_CONFIG,
     CHECKED_CONFIG_OF,
     CHECKED_VALUES,
     CHECKED_WRITE,
     Lowering,
+    type Routed,
 } from './Lowering.ts'
 import { holdsReactive } from './PositionTable.ts'
 import type { AbideFile } from './parseAbide.ts'
@@ -64,8 +66,10 @@ export const COMPONENT_MODULE = componentModule('any')
 export function checkedShadow(
     file: AbideFile,
     answer: CheckerAnswer,
+    /** 23.9 — a page's or a layout's route, which its `route.params` is typed by. */
+    routed?: Routed,
 ): CheckedShadow {
-    const lowering = new Lowering(file, answer, true)
+    const lowering = new Lowering(file, answer, true, undefined, routed)
     const projection = lowering.projection
     // Every span the emitters lower, with whether it holds the `Reactive` rather than reading it.
     const units: { span: Span; holds: boolean }[] = [
@@ -165,13 +169,10 @@ ${aliases}declare module '${SERVER_SPECIFIER}' {
 `
 }
 
-// A call standing as a statement at a module's top level, as a formatted module writes one.
-const TOP_LEVEL_CONFIG = /^onConfig\s*\(/gm
-
 /**
- * 27.13 FOR A MODULE THAT IS NO `.abide` — a handler file, or one under a `server` directory: its
- * text with each `onConfig(…)` at its top level bound as the lowering binds a server block's, and
- * `Config` extended by each, or `undefined` where it files none.
+ * 27.13 FOR A HANDLER FILE, the one module that is no `.abide` and may call a hook (37.13): its
+ * text with each `onConfig(…)` standing as a statement at its top level bound as the lowering binds
+ * a server block's, and `Config` extended by each, or `undefined` where it files none.
  *
  * A MODULE OF ITS OWN BESIDE THE FILE, which the checker reads and nothing reports on: the file's own
  * text is the one its diagnostics are placed in, and binding a call shifts every column after it.
@@ -180,11 +181,12 @@ export function moduleConfigShadow(text: string): string | undefined {
     const bound: string[] = []
     let out = ''
     let from = 0
-    for (const found of text.matchAll(TOP_LEVEL_CONFIG)) {
+    for (const call of hookCalls(text)) {
+        if (call.hook !== 'onConfig' || !call.topLevel) continue
         const name = `${CHECKED_CONFIG}${bound.length}`
         bound.push(name)
-        out += `${text.slice(from, found.index)}const ${name} = ${CHECKED_CONFIG_OF}(onConfig)(`
-        from = found.index + found[0].length
+        out += `${text.slice(from, call.at)}const ${name} = ${CHECKED_CONFIG_OF}(${text.slice(call.at, call.end)})`
+        from = call.end
     }
     if (bound.length === 0) return undefined
     return `${out}${text.slice(from)}\n${configInterface(bound)}`

package/src/compiler/classifyRead.ts

@@ -101,11 +101,8 @@ export type Read = {
     local: boolean
     /** 33.20 — on the `props` call, the keys its pattern defaults; on a default's opening, its key. */
     keys: string[]
-    /**
-     * 23.9 — on `route.params` in a page or a layout, the route literal and which of the two the
-     * file is.
-     */
-    routeParams: [pattern: string, kind: string] | undefined
+    /** 23.9 — the read is abide's `route.params`, which a page or a layout types by its route. */
+    routeParams: boolean
 }
 
 /**
@@ -136,7 +133,7 @@ export function newRead(
         byValue: false,
         local: false,
         keys: [],
-        routeParams: undefined,
+        routeParams: false,
     }
 }