@abide/abide 0.103.0 → 0.105.0

package/src/server/clientBuildOptions.ts

@@ -1,54 +0,0 @@
-import { CLIENT_ADDRESS } from '#shared/ADDRESSES.ts'
-import { tablePath } from './abideModules.ts'
-import { CLIENT_ENTRY } from './CLIENT_BUILD.ts'
-
-/**
- * The `Bun.build` options for the client bundle both lanes build.
- *
- * `abide build` builds it to disk and `abide dev` in memory. 30.8 says dev resolves an address the
- * way the built app does, so what decides resolution is written once here and each lane adds only
- * where the output goes and how it is named.
- */
-export function clientBuildOptions(
-    root: string,
-    plugins: Bun.BunPlugin[],
-    publicAddresses: string[],
-) {
-    return {
-        // The entry is a table the plugin serves (`abideModules`), below the root.
-        entrypoints: [tablePath(root, `${CLIENT_ENTRY}.ts`)] as string[],
-        // The app's own root, because `Bun.build` opens the entry's directory otherwise, and the
-        // tables' is not on disk to open.
-        root,
-        // 16.28, 16.29 — a `<script server>` is its stand-ins here, and a `server/` module refuses.
-        plugins,
-        target: 'browser',
-        format: 'esm',
-        splitting: true,
-        metafile: true,
-        // 36.15 — a stylesheet's `url('/fonts/…')` is the public file's address, not a path here,
-        // and `Bun.build` reads a leading `/` as a path on this disk and fails on it not being
-        // there. The list is the files that exist rather than every `/…`: a URL naming nothing the
-        // app serves is still worth a build error.
-        external: publicAddresses,
-    } as const
-}
-
-// From the bundle's own directory up to the app's root: `../../` below `/__abide/client`.
-const UP_TO_ROOT = '../'.repeat(CLIENT_ADDRESS.split('/').length - 1)
-
-/**
- * A built stylesheet with every root-absolute `url()` written relative to the bundle's directory.
- *
- * 16.10, 36.15 — THE SAME MECHANISM AS THE HANDLER WRAPPERS: the address is written relative to
- * where the bundle is served and the browser resolves it against the sheet, so one build serves
- * at the root and below a mount. What survives the build as `url(/…)` is a public file's address
- * (the `external` list above), and the browser would resolve it against the origin. `//` is
- * another host's.
- */
-export function stylesheetUnderMount(css: string): string {
-    return css.replace(
-        /url\((["']?)\/(?!\/)/g,
-        (_whole, quote: string) => `url(${quote}${UP_TO_ROOT}`,
-    )
-}

package/src/server/refuseAddressCollision.ts

@@ -1,37 +0,0 @@
-/**
- * Throws, naming both, when a public file claims a route's address or another public file's.
- *
- * 36.13 — the walks that find routes and public files cannot see each other's collisions from
- * inside either one; this is the one place they meet, and naming BOTH is the clause — naming one
- * leaves the reader to find the other. Two `public` directories can claim one address too, since
- * each mounts at the path above it (36.11).
- *
- * THE BUILD AND DEV, and `abide start` trusts the build: `answerRequest` answers a public file
- * AHEAD of any route on the ground that 36.13 makes a collision impossible at run time, and 30.8
- * says dev must resolve an address the way the built app does.
- *
- * `published` is each public file's source path to its address, as `appTree` reads them.
- */
-export function refuseAddressCollision(
-    pages: readonly { pattern: string }[],
-    handlers: readonly { address: string }[],
-    published: Map<string, string>,
-    command: string,
-): void {
-    const patterns = new Set<string>()
-    for (const page of pages) patterns.add(page.pattern)
-    for (const handler of handlers) patterns.add(handler.address)
-    const claimed = new Map<string, string>()
-    for (const [source, address] of published) {
-        if (patterns.has(address))
-            throw new Error(
-                `${command}: ${source} and the route ${address} claim the same address. RULEBOOK 36.13.`,
-            )
-        const other = claimed.get(address)
-        if (other !== undefined)
-            throw new Error(
-                `${command}: ${other} and ${source} are both answered at ${address}. RULEBOOK 36.13.`,
-            )
-        claimed.set(address, source)
-    }
-}

package/src/shared/reactive/chunksOfStream.ts

@@ -1,57 +0,0 @@
-import { isFailed } from '../Failed.ts'
-import { chunksFrom } from './Reactive.ts'
-
-/**
- * The chunks of a streaming value, as they land, ending when its run closes.
- *
- * The live cursor is the wake and not the source: a cursor outlives the run (it waits on the next
- * one), and a chunk landing in the same turn as the close could be lost to whichever settled first
- * — so each wake sends what the accumulation holds past what has already gone, and the close sends
- * the rest.
- */
-export async function* chunksOfStream(value: unknown): AsyncGenerator<unknown> {
-    const stream = value as PromiseLike<unknown> & AsyncIterable<unknown>
-    let closed = false
-    let failure: unknown
-    // ONE REACTION ON THE CLOSE FOR THE WHOLE STREAM, which wakes whichever wait is current. A
-    // `Promise.race` against the close per chunk left one reaction per chunk on it, held until the
-    // stream ended.
-    let wake: () => void = () => {}
-    void Promise.resolve(stream).then(
-        () => {
-            closed = true
-            wake()
-        },
-        (error: unknown) => {
-            closed = true
-            failure = error
-            wake()
-        },
-    )
-    const cursor = stream[Symbol.asyncIterator]()
-    let sent = 0
-    let woken = cursor.next()
-    try {
-        for (;;) {
-            if (!closed)
-                await new Promise<void>((resolve, reject) => {
-                    wake = resolve
-                    woken.then(() => resolve(), reject)
-                })
-            for (const chunk of chunksFrom(value, sent)) {
-                sent += 1
-                yield chunk
-            }
-            if (closed) break
-            woken = cursor.next()
-        }
-    } finally {
-        void cursor.return?.(undefined)
-    }
-    if (failure !== undefined) throw failure
-    // 16.59, 16.60 — A RUN ENDED BY ITS TIMEOUT SETTLES with the chunks it had and holds its refusal
-    // rather than rejecting, so the refusal is read off the value and thrown after them: a stream
-    // answered over http then ends on it (16.68) rather than as though it had finished.
-    const held = (value as { error?: () => unknown }).error?.()
-    if (isFailed(held)) throw held
-}

package/src/ui/MOUNTING_LEVEL.ts

@@ -1,18 +0,0 @@
-// 39.1, 39.6 — THE ROUTER'S LEVEL BEING MOUNTED, set by the router around a page's or a layout's
-// setup and markup: a component mounted inside one adds its `<head>` to that level's
-// (`contributeHead`), and one mounted later — a row a list grew by — finds none and leaves the
-// document's head alone. `unapplied` is the head the components built on the client contributed
-// while it was set, which the router applies once it is unset rather than once a component.
-export const MOUNTING_LEVEL: {
-    current:
-        | {
-              head: (() => string) | undefined
-              /** Every component head joined to the level's own, in the order they mounted. */
-              contributed: (() => string)[] | undefined
-          }
-        | undefined
-    unapplied: string
-} = {
-    current: undefined,
-    unapplied: '',
-}