@abide/abide 0.58.0 → 0.101.0

package/src/compiler/compiledEntry.ts

@@ -0,0 +1,141 @@
+import type { AppPackage } from '#server/config.ts'
+import type { LauncherOptions } from '#server/launcherOptions.ts'
+import abidePackage from '../../package.json' with { type: 'json' }
+
+// What the executable starts from: `abide compile`'s, and `abide bundle`'s window over it (38.71).
+const RUNNERS = {
+    compiled: {
+        name: 'runCompiled',
+        path: Bun.fileURLToPath(
+            new URL('../server/runCompiled.ts', import.meta.url),
+        ),
+    },
+    desktop: {
+        name: 'runDesktop',
+        path: Bun.fileURLToPath(
+            new URL('../server/runDesktop.ts', import.meta.url),
+        ),
+    },
+}
+const PACKAGE = Bun.fileURLToPath(new URL('../../', import.meta.url))
+
+/**
+ * Abide's own package entries, by the specifier an app imports each with, to the module behind it.
+ *
+ * 38.57 — the compiler is not among them: the executable does not hold it.
+ */
+function abideEntries(): Map<string, string> {
+    const specifiers = new Map<string, string>()
+    for (const [entry, path] of Object.entries(abidePackage.exports)) {
+        if (entry === './compiler' || !path.endsWith('.ts')) continue
+        specifiers.set(
+            entry === '.'
+                ? abidePackage.name
+                : `${abidePackage.name}/${entry.slice(2)}`,
+            `${PACKAGE}${path.slice(2)}`,
+        )
+    }
+    return specifiers
+}
+
+/**
+ * The source of the module a compiled app starts from, written into the build beside `server.ts`.
+ *
+ * 38.11 — every part `runCompiled` boots over, named by a static import the bundler follows into
+ * the executable. 38.45 — NOTHING IN IT IS FOUND AT RUN TIME — a file this module does not name is
+ * a file the executable does not hold, which is what makes the artifact a property of the build
+ * rather than of the machine it lands on.
+ *
+ * A file the app SERVES is imported as a `file`, so its bytes are embedded as they are and it is
+ * answered through a path like any other; a module the app RUNS is imported as code. Every path is
+ * absolute, so the entry means the same thing wherever `--out` put it.
+ */
+export function compiledEntry(app: {
+    /**
+     * 38.71 — what `abide bundle` read out of `src/bundle/`, and `launch` the path of its
+     * `launch.abide`; `undefined` for `abide compile`.
+     */
+    desktop:
+        | {
+              options: LauncherOptions
+              launch: string | undefined
+              shell: string
+          }
+        | undefined
+    out: string
+    /** 37.1 — `src/server/app.ts`, where the app has one. */
+    hooks: string | undefined
+    package: AppPackage
+    shell: string
+    manifest: unknown
+    /** 16.2 — each handler's source path as its row names it, to the file. */
+    handlerModules: Map<string, string>
+    /** Every file under the build's `client/`, by name to the file. */
+    client: Map<string, string>
+    /** Every file under the build's `public/`, by name to the file. */
+    published: Map<string, string>
+}): string {
+    const runner = RUNNERS[app.desktop === undefined ? 'compiled' : 'desktop']
+    let imports = `import { ${runner.name} } from ${JSON.stringify(runner.path)}
+import * as table from ${JSON.stringify(`${app.out}/server.ts`)}
+import { handlers } from ${JSON.stringify(`${app.out}/rpc.ts`)}
+`
+    const files = (kind: string, paths: Map<string, string>): string => {
+        let entries = ''
+        let index = 0
+        for (const [name, path] of paths) {
+            imports += `import ${kind}${index} from ${JSON.stringify(path)} with { type: 'file' }\n`
+            entries += `\n        [${JSON.stringify(name)}, ${kind}${index}],`
+            index += 1
+        }
+        return `new Map([${entries}\n    ])`
+    }
+    const client = files('client', app.client)
+    const published = files('published', app.published)
+    let modules = ''
+    for (const [source, path] of app.handlerModules)
+        modules += `\n    ${JSON.stringify(source)}: () => import(${JSON.stringify(path)}),`
+    // A handler module as a script names it: `#server/rpc/invoices`, with or without its extension.
+    let specifiers = ''
+    for (const [specifier, path] of abideEntries())
+        specifiers += `\n    ${JSON.stringify(specifier)}: () => import(${JSON.stringify(path)}),`
+    for (const source of app.handlerModules.keys())
+        for (const specifier of [
+            `#${source}`,
+            `#${source.replace(/\.ts$/, '')}`,
+        ])
+            specifiers += `\n    ${JSON.stringify(specifier)}: handlerModules[${JSON.stringify(source)}],`
+    const hooks =
+        app.hooks === undefined
+            ? 'undefined'
+            : `() => import(${JSON.stringify(app.hooks)})`
+    const desktop =
+        app.desktop === undefined
+            ? ''
+            : `
+    {
+        options: ${JSON.stringify(app.desktop.options)},
+        launch: ${app.desktop.launch === undefined ? 'undefined' : `() => import(${JSON.stringify(app.desktop.launch)})`},
+        shell: ${JSON.stringify(app.desktop.shell)},
+    },`
+    return `// Written by \`abide compile\`. The whole app, as what one executable holds.
+${imports}
+const handlerModules = {${modules}
+}
+
+await ${runner.name}(
+    { hooks: ${hooks}, package: ${JSON.stringify(app.package)} },
+    {
+        table,
+        handlers,
+        handlerModule: (source) => handlerModules[source](),
+        shell: ${JSON.stringify(app.shell)},
+        manifest: ${JSON.stringify(app.manifest)},
+        client: ${client},
+        published: ${published},
+    },
+    {${specifiers}
+    },${desktop}
+)
+`
+}

package/src/compiler/componentGraph.ts

@@ -0,0 +1,139 @@
+import { dirname, posix, relative as relativePath } from 'node:path' // bun exposes no path helpers of its own
+import { type FileKind, fileKind, routeOf } from '#shared/routePattern.ts'
+import type { AbideFile } from './parseAbide.ts'
+import { abideImports, relativeSpecifiers } from './splitImports.ts'
+
+type Resolve = (specifier: string, from: string) => string | undefined
+
+/**
+ * The build's component graph: which files are invoked as components, and where each file's
+ * `.abide` imports land in the output tree.
+ *
+ * 32.17 — off ONE reading of every file's imports: each `.abide` specifier is resolved once,
+ * against the file that wrote it, and both answers the build needs are read off that resolution.
+ *
+ * `invoked` is every source path another file imports as a component (`emitClient`'s `selfFill`).
+ * By PATH, not by file name: two `Row.abide` in two directories are two components, and only the
+ * one somebody imports carries its own markup.
+ *
+ * `imports` is, per importing file, where each `.abide` specifier it wrote lands in the output
+ * tree, relative and without an extension (`splitImports`). The output mirrors the source, so
+ * the path between two sources IS the path between their modules — which is what turns a seam
+ * specifier (`#ui/components/Row.abide`) into one that resolves inside the build rather than into
+ * a source tree where the compiler wrote nothing.
+ *
+ * `resolve` is the app's: a build asks bun, and a harness that lays an app out by hand answers for
+ * its own seams. A specifier it cannot resolve, or that lands outside `files`, is left as written.
+ */
+export function componentGraph(
+    files: readonly { path: string; file: AbideFile }[],
+    resolve: Resolve,
+): {
+    invoked: Set<string>
+    imports: Map<string, Map<string, string>>
+} {
+    const known = new Set<string>()
+    for (const entry of files) known.add(entry.path)
+    const invoked = new Set<string>()
+    const imports = new Map<string, Map<string, string>>()
+    for (const entry of files) {
+        const from = dirname(entry.path)
+        const landed = new Map<string, string>()
+        for (const [specifier, target] of abideImportsOf(
+            entry.path,
+            entry.file,
+            resolve,
+        )) {
+            if (!known.has(target)) continue
+            invoked.add(target)
+            const path = relativePath(from, target.slice(0, -'.abide'.length))
+            landed.set(specifier, path.startsWith('.') ? path : `./${path}`)
+        }
+        imports.set(entry.path, landed)
+    }
+    return { invoked, imports }
+}
+
+/**
+ * Each `.abide` the file at `path` imports, by the specifier it wrote, resolved from the file —
+ * statically or through an `import('…')` naming it as a literal, which is the same edge (34.15).
+ *
+ * A specifier `resolve` cannot answer is not an edge. `checkSource` reads one file's components
+ * through this and the build reads every file's (`componentGraph`), so the two cannot disagree
+ * about what a page imports.
+ */
+export function abideImportsOf(
+    path: string,
+    file: AbideFile,
+    resolve: Resolve,
+): Map<string, string> {
+    const from = dirname(path)
+    const resolved = new Map<string, string>()
+    for (const script of [...file.modules, ...file.scripts])
+        for (const { specifier } of abideImports(script)) {
+            if (resolved.has(specifier)) continue
+            const target = resolve(specifier, from)
+            if (target !== undefined) resolved.set(specifier, target)
+        }
+    return resolved
+}
+
+/** One source in the app graph: where it is below the root, what it is, and its address. */
+export type AppNode<Source> = Source & {
+    relative: string
+    kind: FileKind
+    /** 23.3 — the address of a page or an error page, and `undefined` for anything else. */
+    route: string | undefined
+}
+
+/**
+ * The app as one graph, built once per build or check: every source with its kind and address,
+ * which files are invoked as components, and where each file's every import lands.
+ *
+ * `imports` is `componentGraph`'s with the relative specifiers landed beside the `.abide` ones —
+ * 34.14, A RELATIVE IMPORT RESOLVES FROM THE FILE THAT WROTE IT. The module that file compiles to
+ * is in the output tree, which holds compiled `.abide` files and nothing else, so a stylesheet or
+ * a `.ts` beside the source is reached by the path from the module back to it.
+ *
+ * `output` is where the modules are written, relative to `root`.
+ */
+export function appGraph<Source extends { path: string; file: AbideFile }>(
+    root: string,
+    sources: readonly Source[],
+    output: string,
+    resolve: Resolve,
+): {
+    nodes: AppNode<Source>[]
+    invoked: Set<string>
+    imports: Map<string, Map<string, string>>
+} {
+    const nodes: AppNode<Source>[] = []
+    for (const source of sources) {
+        const relative = source.path.slice(root.length + 1)
+        const kind = fileKind(relative)
+        nodes.push({
+            ...source,
+            relative,
+            kind,
+            route:
+                kind === 'page' || kind === 'error'
+                    ? routeOf(relative)
+                    : undefined,
+        })
+    }
+    const { invoked, imports } = componentGraph(sources, resolve)
+    for (const node of nodes) {
+        const landed = imports.get(node.path) as Map<string, string>
+        const written = dirname(node.path)
+        const emitted = posix.join(root, output, dirname(node.relative))
+        for (const script of [...node.file.modules, ...node.file.scripts])
+            for (const specifier of relativeSpecifiers(script)) {
+                const path = posix.relative(
+                    emitted,
+                    posix.join(written, specifier),
+                )
+                landed.set(specifier, path.startsWith('.') ? path : `./${path}`)
+            }
+    }
+    return { nodes, invoked, imports }
+}