@abide/abide 0.100.0 → 0.102.0

package/src/compiler/sourceMapOf.ts

@@ -0,0 +1,193 @@
+// 38.97 — WHERE A COMPILED MODULE'S LINES CAME FROM IN ITS `.abide`. The emitters build a module
+// as text around what `Lowering` hands them, so a chunk is placed by FINDING it in what they wrote
+// rather than by threading offsets through every template string that assembles one:
+//
+// - a script block is many lines and lands whole, its imports each left as a `;` on as many lines
+//   (`splitImports`), so it is anchored by its longest line found once in the module and then read
+//   line for line;
+// - a template expression is one line and may land more than once — a client module writes a slot
+//   in its markup and again in the effect that updates it — and every landing is the same source.
+//
+// What no chunk covers is the framework's own scaffolding, and maps to nothing.
+
+import { encodeMappings, type Segment } from '#server/sourceMappings.ts'
+import type { LoweredChunk } from './Lowering.ts'
+import type { Origin } from './projectShadow.ts'
+import { mapBack } from './ShadowMap.ts'
+
+/** The module's `mappings`, into the `.abide` whose text is `source`. */
+export function sourceMapOf(
+    output: string,
+    chunks: readonly LoweredChunk[],
+    projected: readonly Origin[],
+    source: string,
+): string {
+    const sourceStarts = lineStarts(source)
+    const outputLines = output.split('\n')
+    const outputStarts = lineStarts(output)
+    const lines: Segment[][] = []
+    for (let index = 0; index < outputLines.length; index += 1) lines.push([])
+    // Where a projection offset is in the `.abide`, as a line and a column.
+    const place = (line: number, column: number, offset: number): void => {
+        const at = mapBack(projected, offset)
+        const sourceLine = lineAt(sourceStarts, at)
+        ;(lines[line] as Segment[]).push([
+            column,
+            0,
+            sourceLine,
+            at - (sourceStarts[sourceLine] as number),
+        ])
+    }
+    const claimed = new Set<number>()
+
+    const multiline: LoweredChunk[] = []
+    const single: LoweredChunk[] = []
+    for (const chunk of chunks)
+        (chunk.text.includes('\n') ? multiline : single).push(chunk)
+    multiline.sort((one, two) => two.text.length - one.text.length)
+
+    for (const chunk of multiline) {
+        const chunkLines = chunk.text.split('\n')
+        const first = anchor(chunkLines, outputLines, outputStarts, output)
+        if (first === undefined) continue
+        const chunkStarts = lineStarts(chunk.text)
+        for (let index = 0; index < chunkLines.length; index += 1) {
+            const line = first + index
+            const written = outputLines[line]
+            const lowered = chunkLines[index] as string
+            if (written === undefined || claimed.has(line)) continue
+            if (written.trim() !== lowered.trim() || lowered.trim() === '')
+                continue
+            claimed.add(line)
+            const start = chunkStarts[index] as number
+            const end = start + lowered.length
+            // Lines the emitter re-indented keep their text, and move by the margin it added.
+            const shift = written.length - lowered.length
+            for (const origin of chunk.origins) {
+                const runEnd = origin.at + Math.max(origin.length, 1)
+                if (origin.at >= end || runEnd <= start) continue
+                const from = Math.max(origin.at, start)
+                place(
+                    line,
+                    from - start + shift,
+                    origin.source + (from - origin.at),
+                )
+            }
+        }
+    }
+
+    // LONGEST FIRST, each landing claimed: `count() + 1` is found again inside the handler
+    // `() => { count.set(count() + 1) }` was lowered from, and is that handler's there.
+    single.sort((one, two) => two.text.trim().length - one.text.trim().length)
+    const taken: [number, number][] = []
+    const seen = new Set<string>()
+    for (const chunk of single) {
+        const text = chunk.text.trim()
+        if (text.length < 2) continue
+        // An expression an emitter asked for twice is one chunk.
+        const key = `${chunk.origins[0]?.source}:${text}`
+        if (seen.has(key)) continue
+        seen.add(key)
+        const lead = chunk.text.indexOf(text)
+        for (
+            let found = output.indexOf(text);
+            found !== -1;
+            found = output.indexOf(text, found + text.length)
+        ) {
+            const end = found + text.length
+            if (!standsAlone(output, found, end)) continue
+            const line = lineAt(outputStarts, found)
+            if (claimed.has(line)) continue
+            if (taken.some(([from, to]) => found < to && end > from)) continue
+            taken.push([found, end])
+            const column = found - (outputStarts[line] as number)
+            for (const origin of chunk.origins) {
+                const at = origin.at - lead
+                if (at < 0 || at > text.length) continue
+                place(line, column + at, origin.source)
+            }
+        }
+    }
+
+    // Two runs placed at one column — a pin and the copy after it — keep the later, which is the
+    // author's own text.
+    for (const segments of lines) {
+        segments.sort((one, two) => one[0] - two[0])
+        for (let at = segments.length - 1; at > 0; at -= 1)
+            if (
+                (segments[at - 1] as Segment)[0] ===
+                (segments[at] as Segment)[0]
+            )
+                segments.splice(at - 1, 1)
+    }
+    return encodeMappings(lines)
+}
+
+/**
+ * The module line `chunkLines` starts on: its longest line found exactly once, standing where the
+ * rest of the chunk agrees — or `undefined` where no line places it.
+ */
+function anchor(
+    chunkLines: readonly string[],
+    outputLines: readonly string[],
+    outputStarts: readonly number[],
+    output: string,
+): number | undefined {
+    const order: number[] = []
+    for (let index = 0; index < chunkLines.length; index += 1) order.push(index)
+    order.sort(
+        (one, two) =>
+            (chunkLines[two] as string).trim().length -
+            (chunkLines[one] as string).trim().length,
+    )
+    for (const index of order) {
+        const text = (chunkLines[index] as string).trim()
+        if (text.length < 8) return undefined
+        const found = output.indexOf(text)
+        if (found === -1 || output.indexOf(text, found + 1) !== -1) continue
+        const first = lineAt(outputStarts, found) - index
+        if (first < 0) continue
+        let agreeing = 0
+        let written = 0
+        for (let at = 0; at < chunkLines.length; at += 1) {
+            const lowered = (chunkLines[at] as string).trim()
+            if (lowered === '') continue
+            written += 1
+            if (outputLines[first + at]?.trim() === lowered) agreeing += 1
+        }
+        if (agreeing * 2 >= written) return first
+    }
+    return undefined
+}
+
+const NAME = /[\w$.]/
+
+// Not the middle of a longer name, or a member of one: `count()` inside `__count()` is not it.
+function standsAlone(output: string, start: number, end: number): boolean {
+    return (
+        !NAME.test(output[start - 1] ?? ' ') &&
+        !/[\w$]/.test(output[end] ?? ' ')
+    )
+}
+
+function lineStarts(text: string): number[] {
+    const starts = [0]
+    for (
+        let at = text.indexOf('\n');
+        at !== -1;
+        at = text.indexOf('\n', at + 1)
+    )
+        starts.push(at + 1)
+    return starts
+}
+
+function lineAt(starts: readonly number[], offset: number): number {
+    let low = 0
+    let high = starts.length - 1
+    while (low < high) {
+        const middle = (low + high + 1) >>> 1
+        if ((starts[middle] as number) <= offset) low = middle
+        else high = middle - 1
+    }
+    return low
+}

package/src/compiler/splitImports.ts

@@ -1,4 +1,5 @@
 import { SyntaxKind } from 'typescript/unstable/ast'
+import { COMPONENT_QUERY, TEXT_QUERY } from '#server/MODULE_QUERIES.ts'
 import { isContextualKeyword, type Token, tokenize } from './tokenize.ts'
 
 /**
@@ -11,13 +12,12 @@ import { isContextualKeyword, type Token, tokenize } from './tokenize.ts'
  * WHERE AN IMPORT BEGINS AND ENDS IS READ OFF the one tokenizer, which carries the template
  * re-scan a bare `` ` `` needs, so an import after a template literal is still found.
  *
- * With `landed`, every specifier the build moved is rewritten where it stands, a static import's
- * and an `import('…')`'s alike (`landedSpecifier`) — so the two cannot land in different places.
+ * Every specifier naming a face of a `.abide` is rewritten where it stands, a static import's and an
+ * `import('…')`'s alike (`facedSpecifier`) — so the two cannot ask for different faces.
  */
 export function splitImports(
     script: string,
-    lane: '' | '.client' = '',
-    landed?: ReadonlyMap<string, string>,
+    lane: Lane = 'component',
 ): {
     imports: string
     body: string
@@ -29,18 +29,13 @@ export function splitImports(
     let body = ''
     let at = 0
     for (const span of spans) {
+        const moved = facedSpecifier(span.specifier, lane)
         if (span.dynamic) {
-            if (landed === undefined) continue
-            const moved = landedSpecifier(span.specifier, lane, landed)
             if (moved === undefined) continue
             body += `${script.slice(at, span.literalStart + 1)}${moved}`
             at = span.end - 1
             continue
         }
-        const moved =
-            landed === undefined
-                ? undefined
-                : landedSpecifier(span.specifier, lane, landed)
         imports +=
             moved === undefined
                 ? `${script.slice(span.start, span.end)}\n`
@@ -50,7 +45,9 @@ export function splitImports(
         // a `[` that automatic semicolon insertion does NOT break — it reads as `f()[2]`, a
         // different program with nothing about it saying so. The empty statement left in its
         // place is the separator the import was.
-        body += `${script.slice(at, span.start)};`
+        // 38.97 — and as many lines as it spanned, so the body stays line for line with the
+        // script it came from and a source map can read the one off the other.
+        body += `${script.slice(at, span.start)};${'\n'.repeat(newlinesIn(script, span.start, span.end))}`
         at = span.end
         // The `;` an import may end with would otherwise be left behind beside the one above.
         if (script[at] === ';') at += 1
@@ -58,6 +55,18 @@ export function splitImports(
     return { imports, body: body + script.slice(at) }
 }
 
+/** How many line breaks `text` holds between `start` and `end`. */
+export function newlinesIn(text: string, start: number, end: number): number {
+    let count = 0
+    for (
+        let at = text.indexOf('\n', start);
+        at !== -1 && at < end;
+        at = text.indexOf('\n', at + 1)
+    )
+        count += 1
+    return count
+}
+
 // What can stand between `import` and its specifier. A token that cannot is a malformed import,
 // and stopping there is what keeps one broken line from swallowing the statements after it.
 //
@@ -252,7 +261,14 @@ export function abideImports(
     const found: { specifier: string; closingQuote: number }[] = []
     if (!script.includes('.abide')) return found
     for (const span of importSpans(script))
-        if (span.specifier.endsWith('.abide'))
+        if (
+            span.specifier.endsWith('.abide') &&
+            // 34.25 — a `.abide` imported as text is its text, and no component edge.
+            (span.dynamic ||
+                !IMPORT_ATTRIBUTES.text.test(
+                    script.slice(span.literalEnd, span.end),
+                ))
+        )
             found.push({
                 specifier: span.specifier,
                 closingQuote: span.literalEnd - 1,
@@ -260,40 +276,167 @@ export function abideImports(
     return found
 }
 
+/** One name an import statement binds. */
+export type ImportBinding = {
+    /** `default`, `*`, or the name imported — a string literal's text where one is written. */
+    imported: string
+    local: string
+    /** Under a `type` modifier, on the binding or on the whole statement: no value of its own. */
+    typeOnly: boolean
+    /** The binding as a statement's clause spells it, its own modifier kept: `type a as b`. */
+    written: string
+}
+
 /**
- * Every relative specifier a script imports, re-exports or `import('…')`s, as written, other than
- * a `.abide` one.
+ * Every static import statement a script makes: where it stands, what it names, and each binding,
+ * read off the one tokenizer — so a comment or a line break inside the clause is trivia, as it is
+ * to bun, and never part of a name.
  *
- * 34.14 — what the build rewrites to the path from the compiled module back to the source.
+ * `attributes` is the statement's text after its specifier, a `with { … }` or nothing. A statement of
+ * no shape this reads answers no bindings.
  */
-export function relativeSpecifiers(script: string): string[] {
-    const specifiers: string[] = []
-    if (!script.includes('./')) return specifiers
-    for (const span of importSpans(script))
+export function importStatements(script: string): {
+    start: number
+    end: number
+    specifier: string
+    typeOnly: boolean
+    attributes: string
+    bindings: ImportBinding[]
+}[] {
+    const found: ReturnType<typeof importStatements> = []
+    if (!script.includes('import')) return found
+    for (const span of importSpans(script)) {
+        if (span.dynamic || !script.startsWith('import', span.start)) continue
+        const tokens = tokenize(script.slice(span.start, span.literalStart))
+        const bindings: ImportBinding[] = []
+        let at = 1
+        // `type` modifies the statement unless it is the default's own name: `import type from`.
+        const typeOnly =
+            tokens[at]?.text === 'type' &&
+            tokens[at + 1] !== undefined &&
+            tokens[at + 1]?.kind !== SyntaxKind.FromKeyword &&
+            tokens[at + 1]?.kind !== SyntaxKind.CommaToken
+        if (typeOnly) at += 1
+        const head = tokens[at]
         if (
-            (span.specifier.startsWith('./') ||
-                span.specifier.startsWith('../')) &&
-            !span.specifier.endsWith('.abide')
-        )
-            specifiers.push(span.specifier)
-    return specifiers
+            head !== undefined &&
+            head.kind !== SyntaxKind.OpenBraceToken &&
+            head.kind !== SyntaxKind.AsteriskToken &&
+            (tokens[at + 1]?.kind === SyntaxKind.FromKeyword ||
+                tokens[at + 1]?.kind === SyntaxKind.CommaToken)
+        ) {
+            bindings.push({
+                imported: 'default',
+                local: head.text,
+                typeOnly,
+                written: head.text,
+            })
+            at += tokens[at + 1]?.kind === SyntaxKind.CommaToken ? 2 : 1
+        }
+        if (tokens[at]?.kind === SyntaxKind.AsteriskToken) {
+            const local = tokens[at + 2]?.text ?? ''
+            bindings.push({
+                imported: '*',
+                local,
+                typeOnly,
+                written: `* as ${local}`,
+            })
+        } else if (tokens[at]?.kind === SyntaxKind.OpenBraceToken) {
+            // Each element between the braces: `[type] imported [as local]`.
+            let element: Token[] = []
+            for (at += 1; at < tokens.length; at += 1) {
+                const token = tokens[at] as Token
+                const closed = token.kind === SyntaxKind.CloseBraceToken
+                if (closed || token.kind === SyntaxKind.CommaToken) {
+                    // `type as t` imports `type`; `type x` and `type x as y` modify.
+                    const modified =
+                        element[0]?.text === 'type' &&
+                        (element.length === 2 || element.length === 4)
+                    const name = element[modified ? 1 : 0]
+                    if (name !== undefined) {
+                        const imported =
+                            name.kind === SyntaxKind.StringLiteral
+                                ? name.text.slice(1, -1)
+                                : name.text
+                        let written = ''
+                        for (const part of element)
+                            written +=
+                                written === '' ? part.text : ` ${part.text}`
+                        bindings.push({
+                            imported,
+                            local: (element.at(-1) as Token).text,
+                            typeOnly: typeOnly || modified,
+                            written,
+                        })
+                    }
+                    element = []
+                    if (closed) break
+                } else element.push(token)
+            }
+        }
+        found.push({
+            start: span.start,
+            end: span.end,
+            specifier: span.specifier,
+            typeOnly,
+            attributes: script.slice(span.literalEnd, span.end).trim(),
+            bindings,
+        })
+    }
+    return found
 }
 
+// The attribute a static import is read by: as text (34.25), or as a mount of routes (23.19).
+export const IMPORT_ATTRIBUTES = {
+    text: /\btype\s*:\s*['"]text['"]/,
+    routes: /\btype\s*:\s*['"]routes['"]/,
+} as const
+
 /**
- * Every import declaration in a script: its text and where it starts.
+ * Every static import a script makes `with { type }`: the specifier, where the statement and its
+ * literal begin, and where the attributes end.
  *
- * `import …` alone — an `export … from` binds nothing in the script it stands in.
+ * 34.25 — a text import's literal-to-end span is what the projection writes over with the specifier
+ * the checker types a `string` (`SOURCE_SUFFIX`), and the emitters ask for as text
+ * (`facedSpecifier`). 23.19 — a routes import's whole statement is what the projection blanks: a
+ * mount is read by the build off the file, and neither bun nor the checker has a module to give it.
  */
-function importDeclarations(script: string): { text: string; start: number }[] {
-    const declarations: { text: string; start: number }[] = []
-    if (!script.includes('import')) return declarations
+export function attributedImports(
+    script: string,
+    type: keyof typeof IMPORT_ATTRIBUTES,
+): ImportSpan[] {
+    const found: ImportSpan[] = []
+    if (!script.includes(type)) return found
+    const attribute = IMPORT_ATTRIBUTES[type]
     for (const span of importSpans(script))
-        if (!span.dynamic && script.startsWith('import', span.start))
-            declarations.push({
-                text: script.slice(span.start, span.end),
-                start: span.start,
-            })
-    return declarations
+        if (
+            !span.dynamic &&
+            attribute.test(script.slice(span.literalEnd, span.end))
+        )
+            found.push(span)
+    return found
+}
+
+/** What a file imported as text is written as once projected: `./X.abide` → `./X.abide.source`. */
+export const SOURCE_SUFFIX = '.source'
+
+/**
+ * `source` with each module specifier — of a declaration, an `export … from` or an `import('…')` —
+ * written as `rewrite` answers for it, and left as it is where `rewrite` answers `undefined`.
+ */
+export function respecified(
+    source: string,
+    rewrite: (specifier: string) => string | undefined,
+): string {
+    let out = ''
+    let at = 0
+    for (const span of importSpans(source)) {
+        const written = rewrite(span.specifier)
+        if (written === undefined) continue
+        out += `${source.slice(at, span.literalStart + 1)}${written}`
+        at = span.literalEnd - 1
+    }
+    return at === 0 ? source : out + source.slice(at)
 }
 
 /**
@@ -305,62 +448,41 @@ export function importedNames(
     script: string,
 ): { name: string; specifier: string }[] {
     const names: { name: string; specifier: string }[] = []
-    for (const declaration of importDeclarations(script)) {
-        const tokens = tokenize(declaration.text)
-        const last = tokens.findLastIndex(
-            (token) => token.kind === SyntaxKind.StringLiteral,
-        )
-        if (last === -1) continue
-        const specifier = (tokens[last] as Token).text.slice(1, -1)
-        for (let at = 1; at < last; at += 1) {
-            const token = tokens[at] as Token
-            if (token.kind === SyntaxKind.FromKeyword) break
-            if (token.kind === SyntaxKind.AsKeyword) continue
-            if (
-                token.kind !== SyntaxKind.Identifier &&
-                !isContextualKeyword(token.kind)
-            )
-                continue
-            const next = tokens[at + 1] as Token
-            // A name followed by `as` is renamed, and a modifier is followed by what it modifies.
-            if (next.kind === SyntaxKind.AsKeyword) continue
-            if (
-                token.text === 'type' &&
-                (next.kind === SyntaxKind.Identifier ||
-                    next.kind === SyntaxKind.OpenBraceToken ||
-                    next.kind === SyntaxKind.AsteriskToken ||
-                    isContextualKeyword(next.kind))
-            )
-                continue
-            names.push({ name: token.text, specifier })
-        }
-    }
+    // `import …` alone — an `export … from` binds nothing in the script it stands in.
+    for (const declaration of importStatements(script))
+        for (const binding of declaration.bindings)
+            names.push({
+                name: binding.local,
+                specifier: declaration.specifier,
+            })
     return names
 }
 
 /**
- * Where the build moved `specifier`: a `.abide` one to the lane's compiled module for it, and a
- * relative one to its source — or `undefined` where it stays as written.
+ * The face of a `.abide` a specifier asks for, spelled on it (`MODULE_QUERIES`), or `undefined`
+ * where the specifier stays as written.
  *
- * 32.17 — A `.abide` IMPORT IS AN IMPORT OF THE MODULE THAT FILE COMPILES TO, and which of the two
- * it is is the LANE's business: the server module renders the child, the client module mounts it.
- * WHERE that module is, is the build's: `landed` maps a specifier to the path, relative and
- * without an extension, the build resolved it to (`componentGraph`) — and a `.abide` specifier it
- * does not map keeps the path as written.
+ * 34.14 — EVERY OTHER SPECIFIER STAYS AS WRITTEN: the compiled module is served at its `.abide`'s
+ * own path, so bun resolves a relative, a `#` or a bare specifier from the file that wrote it.
  *
- * 34.14 — `landed` maps any other relative specifier to the path from the module, in the output
- * tree, back to the file the author meant, which the output tree does not hold.
+ * 32.17 — a component block's `.abide` import is of the module that file compiles to; a server
+ * block's stays bare, for the face a module abide did not compile gets (34.16). 34.25 — a file the
+ * projection marked as text is asked for as its text.
  */
-function landedSpecifier(
-    specifier: string,
-    lane: '' | '.client',
-    landed: ReadonlyMap<string, string>,
-): string | undefined {
-    if (specifier.endsWith('.abide'))
-        return `${landed.get(specifier) ?? specifier.slice(0, -'.abide'.length)}${lane}.ts`
-    return landed.get(specifier)
+function facedSpecifier(specifier: string, lane: Lane): string | undefined {
+    if (specifier.endsWith(SOURCE_SUFFIX))
+        return `${specifier.slice(0, -SOURCE_SUFFIX.length)}${TEXT_QUERY}`
+    if (lane === 'component' && specifier.endsWith('.abide'))
+        return `${specifier}${COMPONENT_QUERY}`
+    return undefined
 }
 
+/**
+ * Which face a block's imports are written for: a component's — its `<script>` and
+ * `<script module>`, in either lane — or a server block's, whose `.abide` imports stay bare (34.16).
+ */
+export type Lane = 'component' | 'source'
+
 /**
  * `imports` with `props` dropped from the abide import that names it.
  *

package/src/compiler/syncTypes.ts

@@ -0,0 +1,32 @@
+// 34.24 — THE TYPES A PLAIN `.ts` READS A `.abide` BY, written with no checker and no build: the
+// files parsed and projected, and nothing else. What `abide sync` runs — and the scaffold's `prepare`
+// with it, so a project is typed as soon as it is installed — and what the language server runs as
+// a file is edited.
+
+import { sourcesUnder } from './compileApp.ts'
+import { parseSources } from './readSources.ts'
+import type { Diagnosis } from './TypeSession.ts'
+import { writeTypes } from './writeTypes.ts'
+
+/**
+ * Writes the types of every `.abide` under `appRoot`, `held` standing in for the text on disk of
+ * the files an editor has open; answers how many files it typed and what it refused. A file that
+ * does not parse, or whose projection is refused, is left as it last was and the rest are typed.
+ */
+export async function syncTypes(
+    appRoot: string,
+    held: ReadonlyMap<string, string> = new Map(),
+): Promise<{ typed: number; refused: Diagnosis[] }> {
+    const { root, sources } = await sourcesUnder(appRoot)
+    const read: { path: string; text: string }[] = []
+    for (const source of sources)
+        read.push({
+            path: source.path,
+            text: held.get(source.path) ?? source.text,
+        })
+    const refused: Diagnosis[] = []
+    const parsed = parseSources(read, refused)
+    const unparsed = refused.length
+    await writeTypes(root, parsed, true, refused)
+    return { typed: parsed.length - (refused.length - unparsed), refused }
+}

package/src/compiler/tokenize.ts

@@ -31,6 +31,20 @@ export function tokenize(source: string): Token[] {
     return tokens
 }
 
+/**
+ * Whether a token of the code scanned from `from` begins at `at` — false where `at` is inside a
+ * string, a template, a regex or a comment.
+ */
+export function startsToken(source: string, from: number, at: number): boolean {
+    let found = false
+    scan(source, from, (_kind, scanner) => {
+        const start = scanner.getTokenStart()
+        found = start === at
+        return start < at
+    })
+    return found
+}
+
 /**
  * How far `kind` moves the bracket depth a top-level separator is found at: a template's
  * substitutions nest as a call's arguments do, so `${a, b}` holds its comma.

package/src/compiler/writeDefaultProject.ts

@@ -1,4 +1,4 @@
-// 38.31 — AN APP WITH NO tsconfig.json IS TYPED AGAINST ONE OF ABIDE'S, not read untyped. The checker
+// 38.30 — AN APP WITH NO tsconfig.json IS TYPED AGAINST ONE OF ABIDE'S, not read untyped. The checker
 // is what tells the compiler which names are `Reactive`s (31.3), and with no project to ask every
 // template position read as static: the server painted an unlanded read by throwing out of the
 // render (41.4), the client never bound a slot at all, and `props` went unseen — an app that built