@abide/abide 0.28.0

package/src/lib/ui/compile/lowerDocAccess.ts

@@ -0,0 +1,202 @@
+import ts from 'typescript'
+
+/*
+The linchpin compiler pass. Rewrites idiomatic data access on a reactive document
+binding into the document's patch/read API, so an author writes plain property
+syntax and the runtime gets addressed change — the thing that makes a real
+component hit the fast path instead of building path strings by hand:
+
+  model.note = 'x'        →  model.replace("note", 'x')
+  model.count += 1        →  model.replace("count", model.read("count") + 1)
+  model.lines.push(v)     →  model.add("lines/-", v)
+  delete model.byId[key]  →  model.remove(`byId/${key}`)
+  model.lines[0].sku      →  model.read("lines/0/sku")
+  model.lines[i].sku      →  model.read(`lines/${i}/sku`)
+
+A member/element-access chain rooted at `docName` becomes a `/`-joined path:
+literal keys and numeric indices fold into one string literal; a non-literal
+index makes the path a template (a dynamic segment). Reads are lowered to
+`read(path)`; a later pass hoists static-path reads to a `cell` bound once at
+component init (the string-free hot path the bench measured). Index expressions
+are themselves visited, so a read used as an index lowers too.
+*/
+export function lowerDocAccess(code: string, docName: string): string {
+    const source = ts.createSourceFile('component.ts', code, ts.ScriptTarget.Latest, true)
+    const result = ts.transform(source, [docAccessTransformer(docName)])
+    const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed })
+    const output = printer.printFile(result.transformed[0] as ts.SourceFile)
+    result.dispose()
+    return output
+}
+
+/* A path segment is either a literal key or a runtime expression (a dynamic index). */
+type Segment = { kind: 'literal'; value: string } | { kind: 'expression'; node: ts.Expression }
+
+/* Maps a compound-assignment operator to its plain binary counterpart. */
+const COMPOUND_OPERATORS = new Map<ts.SyntaxKind, ts.BinaryOperator>([
+    [ts.SyntaxKind.PlusEqualsToken, ts.SyntaxKind.PlusToken],
+    [ts.SyntaxKind.MinusEqualsToken, ts.SyntaxKind.MinusToken],
+    [ts.SyntaxKind.AsteriskEqualsToken, ts.SyntaxKind.AsteriskToken],
+    [ts.SyntaxKind.SlashEqualsToken, ts.SyntaxKind.SlashToken],
+])
+
+function docAccessTransformer(docName: string): ts.TransformerFactory<ts.SourceFile> {
+    return (context) => (root) => {
+        /* Collects the path of an access chain rooted at `docName`, visiting any
+           dynamic index so reads inside it lower too. undefined if not our doc. */
+        function pathSegments(node: ts.Expression): Segment[] | undefined {
+            const segments: Segment[] = []
+            let current: ts.Expression = node
+            while (true) {
+                if (ts.isPropertyAccessExpression(current)) {
+                    segments.unshift({ kind: 'literal', value: current.name.text })
+                    current = current.expression
+                } else if (ts.isElementAccessExpression(current)) {
+                    const argument = current.argumentExpression
+                    if (ts.isStringLiteral(argument) || ts.isNumericLiteral(argument)) {
+                        segments.unshift({ kind: 'literal', value: argument.text })
+                    } else {
+                        segments.unshift({
+                            kind: 'expression',
+                            node: ts.visitNode(argument, visit) as ts.Expression,
+                        })
+                    }
+                    current = current.expression
+                } else {
+                    break
+                }
+            }
+            if (ts.isIdentifier(current) && current.text === docName && segments.length > 0) {
+                return segments
+            }
+            return undefined
+        }
+
+        function visit(node: ts.Node): ts.Node {
+            /* Assignment (plain or compound) to a doc path → replace patch. */
+            if (ts.isBinaryExpression(node)) {
+                const segments = pathSegments(node.left as ts.Expression)
+                if (segments) {
+                    const operator = node.operatorToken.kind
+                    if (operator === ts.SyntaxKind.EqualsToken) {
+                        return docCall(docName, 'replace', [
+                            buildPath(segments),
+                            ts.visitNode(node.right, visit) as ts.Expression,
+                        ])
+                    }
+                    const binary = COMPOUND_OPERATORS.get(operator)
+                    if (binary) {
+                        const next = ts.factory.createBinaryExpression(
+                            docCall(docName, 'read', [buildPath(segments)]),
+                            binary,
+                            ts.visitNode(node.right, visit) as ts.Expression,
+                        )
+                        return docCall(docName, 'replace', [buildPath(segments), next])
+                    }
+                }
+            }
+            /* doc array `.push(x)` → add patch at the array's `-` slot. */
+            if (
+                ts.isCallExpression(node) &&
+                ts.isPropertyAccessExpression(node.expression) &&
+                node.expression.name.text === 'push'
+            ) {
+                const segments = pathSegments(node.expression.expression)
+                const pushed = node.arguments[0]
+                if (segments && pushed !== undefined) {
+                    return docCall(docName, 'add', [
+                        buildPath([...segments, { kind: 'literal', value: '-' }]),
+                        ts.visitNode(pushed, visit) as ts.Expression,
+                    ])
+                }
+            }
+            /* A called member on a doc chain is a method on the read value, not a
+               deeper path: `model.draft.trim()` → `model.read("draft").trim()`,
+               `model.items.map(f)` → `model.read("items").map(f)`. (Array `.push`
+               above is the exception — it lowers to an `add` patch.) */
+            if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
+                const segments = pathSegments(node.expression.expression)
+                if (segments) {
+                    return ts.factory.createCallExpression(
+                        ts.factory.createPropertyAccessExpression(
+                            docCall(docName, 'read', [buildPath(segments)]),
+                            node.expression.name.text,
+                        ),
+                        node.typeArguments,
+                        node.arguments.map((arg) => ts.visitNode(arg, visit) as ts.Expression),
+                    )
+                }
+            }
+            /* delete doc.path → remove patch. */
+            if (ts.isDeleteExpression(node)) {
+                const segments = pathSegments(node.expression)
+                if (segments) {
+                    return docCall(docName, 'remove', [buildPath(segments)])
+                }
+            }
+            /* Any remaining doc access chain is a read. */
+            if (ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)) {
+                const segments = pathSegments(node)
+                if (segments) {
+                    return docCall(docName, 'read', [buildPath(segments)])
+                }
+            }
+            return ts.visitEachChild(node, visit, context)
+        }
+
+        return ts.visitNode(root, visit) as ts.SourceFile
+    }
+}
+
+/* Builds `docName.method(...args)`. */
+function docCall(docName: string, method: string, args: ts.Expression[]): ts.CallExpression {
+    return ts.factory.createCallExpression(
+        ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(docName), method),
+        undefined,
+        args,
+    )
+}
+
+/*
+Turns segments into a path expression: an all-literal path is one string literal
+(`"lines/0/sku"`); a path with a dynamic segment is a string-concatenation that
+evaluates to the path at runtime (`"lines/" + i + "/sku"`), kept string-typed by
+leading with a literal.
+*/
+function buildPath(segments: Segment[]): ts.Expression {
+    if (segments.every((segment) => segment.kind === 'literal')) {
+        return ts.factory.createStringLiteral(
+            segments.map((segment) => (segment as { value: string }).value).join('/'),
+        )
+    }
+    const fragments: ts.Expression[] = []
+    /* Append text to the trailing string fragment when there is one, so a `/`
+       separator folds into the preceding literal (`"lines/" + i`) rather than
+       printing as its own term (`"lines" + "/" + i`). */
+    const appendText = (text: string): void => {
+        const last = fragments[fragments.length - 1]
+        if (last !== undefined && ts.isStringLiteral(last)) {
+            fragments[fragments.length - 1] = ts.factory.createStringLiteral(last.text + text)
+        } else {
+            fragments.push(ts.factory.createStringLiteral(text))
+        }
+    }
+    segments.forEach((segment, index) => {
+        const separator = index === 0 ? '' : '/'
+        if (segment.kind === 'literal') {
+            appendText(separator + segment.value)
+        } else {
+            if (separator !== '') {
+                appendText(separator)
+            }
+            fragments.push(segment.node)
+        }
+    })
+    const head = fragments[0]
+    if (head === undefined || !ts.isStringLiteral(head)) {
+        fragments.unshift(ts.factory.createStringLiteral(''))
+    }
+    return fragments.reduce((left, right) =>
+        ts.factory.createBinaryExpression(left, ts.SyntaxKind.PlusToken, right),
+    )
+}

package/src/lib/ui/compile/nearestProjectRoot.ts

@@ -0,0 +1,16 @@
+import { dirname } from 'node:path'
+import ts from 'typescript'
+
+/*
+The project root governing a `.abide` file: the directory of the nearest
+`tsconfig.json` at or above it, or `fallback` when none is found. The LSP routes
+each document to a shadow service rooted here, so a file is type-checked against
+its own project's `paths`/`baseUrl`/strictness — the same tsconfig `abide check`
+uses when run from that package. Without this, every file in a monorepo opened at
+its root would be checked against the root tsconfig, and project-local path
+aliases (`$server/*`, `$ui/*`) would fail to resolve.
+*/
+export function nearestProjectRoot(filePath: string, fallback: string): string {
+    const configPath = ts.findConfigFile(dirname(filePath), ts.sys.fileExists, 'tsconfig.json')
+    return configPath === undefined ? fallback : dirname(configPath)
+}

package/src/lib/ui/compile/parseTemplate.ts

@@ -0,0 +1,396 @@
+import { decodeHtmlEntities } from './decodeHtmlEntities.ts'
+import type { TemplateAttr } from './types/TemplateAttr.ts'
+import type { TemplateNode } from './types/TemplateNode.ts'
+import type { TextPart } from './types/TextPart.ts'
+
+/*
+A minimal compile-time parser for the abide template subset: elements, text with
+`{expr}` interpolation, static/`{expr}`/`on<event>={expr}` attributes, and
+`<template each as key>` control flow. Not a full HTML parser — it covers what
+components need and reads brace expressions with quote/nesting awareness so an
+expression containing `<`, `>`, or `}` parses intact. Void elements self-close.
+`<!-- … -->` comments are dropped (no node emitted) so they leave no trace in the
+SSR/client output or hydration cursor.
+
+A `<style>` becomes a `style` node IN PLACE (not hoisted): its CSS body is read
+structurally (not via a raw-source regex) so a `<style>` sitting inside a `{expr}`
+or attribute — e.g. one quoted in a code sample — is read as that expression's
+text, never mistaken for a real style. Keeping it in the tree lets the front-end
+scope it to its sibling subtree (`analyzeComponent`); the node emits no DOM/markup.
+*/
+
+const VOID_TAGS = new Set([
+    'area',
+    'base',
+    'br',
+    'col',
+    'embed',
+    'hr',
+    'img',
+    'input',
+    'link',
+    'meta',
+    'param',
+    'source',
+    'track',
+    'wbr',
+])
+
+/* A braced template expression with the absolute source offset of its first
+   (post-trim) character, so the type-checking shadow can map a diagnostic back. */
+type Braced = { code: string; loc: number }
+
+export function parseTemplate(source: string, baseOffset = 0): { nodes: TemplateNode[] } {
+    let cursor = 0
+
+    /* Reads a `{...}` expression starting at `cursor` (on the `{`), tracking
+       string literals and nested braces so the matching `}` is found. `loc` is the
+       absolute offset (baseOffset-relative) of the trimmed code's first char. */
+    function readBracedExpression(): Braced {
+        cursor += 1 // past '{'
+        const start = cursor
+        let depth = 1
+        while (cursor < source.length && depth > 0) {
+            const char = source.charAt(cursor)
+            if (char === '"' || char === "'" || char === '`') {
+                cursor += 1
+                while (cursor < source.length && source.charAt(cursor) !== char) {
+                    if (source.charAt(cursor) === '\\') {
+                        cursor += 1
+                    }
+                    cursor += 1
+                }
+            } else if (char === '{') {
+                depth += 1
+            } else if (char === '}') {
+                depth -= 1
+            }
+            cursor += 1
+        }
+        const raw = source.slice(start, cursor - 1)
+        const leading = raw.length - raw.trimStart().length
+        return { code: raw.trim(), loc: baseOffset + start + leading }
+    }
+
+    /* Skips an HTML comment starting at `cursor` (on `<!--`), advancing past its
+       `-->`; an unterminated comment runs to the end of source. Emits no node. */
+    function skipComment(): void {
+        const close = source.indexOf('-->', cursor)
+        cursor = close === -1 ? source.length : close + '-->'.length
+    }
+
+    /* True when `cursor` is on a `<style>` open tag — read raw (`readStyle`) so its
+       CSS braces never misparse as `{expr}` interpolations. */
+    function atStyleTag(): boolean {
+        return source.startsWith('<style', cursor) && /[\s>]/.test(source.charAt(cursor + 6))
+    }
+
+    /* Reads a `<style>…</style>` block into a `style` node carrying its CSS body; an
+       unterminated block runs to end. The body is read raw (not parsed as markup) so
+       CSS braces never misparse as `{expr}`. */
+    function readStyle(): TemplateNode {
+        const openEnd = source.indexOf('>', cursor)
+        const close = source.indexOf('</style>', cursor)
+        const css =
+            openEnd !== -1 && (close === -1 || openEnd < close)
+                ? source.slice(openEnd + 1, close === -1 ? source.length : close).trim()
+                : ''
+        cursor = close === -1 ? source.length : close + '</style>'.length
+        return { kind: 'style', css }
+    }
+
+    function readText(): TemplateNode {
+        const parts: TextPart[] = []
+        let literal = ''
+        while (cursor < source.length && source.charAt(cursor) !== '<') {
+            if (source.charAt(cursor) === '{') {
+                if (literal !== '') {
+                    parts.push({ kind: 'static', value: decodeHtmlEntities(literal) })
+                    literal = ''
+                }
+                const { code, loc } = readBracedExpression()
+                parts.push({ kind: 'expression', code, loc })
+            } else {
+                literal += source.charAt(cursor)
+                cursor += 1
+            }
+        }
+        if (literal !== '') {
+            parts.push({ kind: 'static', value: decodeHtmlEntities(literal) })
+        }
+        return { kind: 'text', parts }
+    }
+
+    function readAttributes(): TemplateAttr[] {
+        const attrs: TemplateAttr[] = []
+        while (cursor < source.length) {
+            while (/\s/.test(source.charAt(cursor))) {
+                cursor += 1
+            }
+            const char = source.charAt(cursor)
+            if (char === '>' || char === '/' || char === undefined) {
+                break
+            }
+            let name = ''
+            while (cursor < source.length && !/[\s=>/]/.test(source.charAt(cursor))) {
+                name += source.charAt(cursor)
+                cursor += 1
+            }
+            while (/\s/.test(source.charAt(cursor))) {
+                cursor += 1
+            }
+            if (source.charAt(cursor) !== '=') {
+                attrs.push({ kind: 'static', name, value: '' }) // boolean attribute
+                continue
+            }
+            cursor += 1 // past '='
+            while (/\s/.test(source.charAt(cursor))) {
+                cursor += 1
+            }
+            if (source.charAt(cursor) === '{') {
+                const { code, loc } = readBracedExpression()
+                if (name.startsWith('on')) {
+                    attrs.push({ kind: 'event', event: name.slice(2), code, loc })
+                } else if (name.startsWith('bind:')) {
+                    attrs.push({ kind: 'bind', property: name.slice(5), code, loc })
+                } else if (name === 'attach') {
+                    attrs.push({ kind: 'attach', code, loc })
+                } else {
+                    attrs.push({ kind: 'expression', name, code, loc })
+                }
+            } else {
+                const quote = source.charAt(cursor)
+                cursor += 1
+                let value = ''
+                while (cursor < source.length && source.charAt(cursor) !== quote) {
+                    value += source.charAt(cursor)
+                    cursor += 1
+                }
+                cursor += 1 // past closing quote
+                attrs.push({ kind: 'static', name, value })
+            }
+        }
+        return attrs
+    }
+
+    function readElement(): TemplateNode {
+        cursor += 1 // past '<'
+        let tag = ''
+        while (cursor < source.length && !/[\s>/]/.test(source.charAt(cursor))) {
+            tag += source.charAt(cursor)
+            cursor += 1
+        }
+        const attrs = readAttributes()
+        let selfClosing = false
+        if (source.charAt(cursor) === '/') {
+            selfClosing = true
+            cursor += 1
+        }
+        cursor += 1 // past '>'
+        /* A nested `<script>` is a scoped reactive block: its body is raw JS read
+           verbatim to its `</script>` (not parsed as markup), scoped by the
+           containing branch when compiled. */
+        if (tag === 'script' && !selfClosing) {
+            const close = source.indexOf('</script>', cursor)
+            const end = close === -1 ? source.length : close
+            const code = source.slice(cursor, end)
+            cursor = close === -1 ? source.length : end + '</script>'.length
+            return { kind: 'script', code }
+        }
+        /* A capitalised tag is a child component; its attributes become props and
+           its children become slot content (rendered where the child puts <slot>). */
+        if (/^[A-Z]/.test(tag)) {
+            const slotted = selfClosing ? [] : readChildren(tag)
+            return { kind: 'component', name: tag, props: toProps(attrs), children: slotted }
+        }
+        const children = selfClosing || VOID_TAGS.has(tag) ? [] : readChildren(tag)
+        if (tag === 'template') {
+            return toControlFlow(attrs, children)
+        }
+        return { kind: 'element', tag, attrs, children }
+    }
+
+    function readChildren(closeTag: string): TemplateNode[] {
+        const nodes: TemplateNode[] = []
+        while (cursor < source.length) {
+            if (source.startsWith(`</${closeTag}`, cursor)) {
+                cursor = source.indexOf('>', cursor) + 1
+                break
+            }
+            if (source.startsWith('<!--', cursor)) {
+                skipComment()
+            } else if (atStyleTag()) {
+                nodes.push(readStyle())
+            } else if (source.charAt(cursor) === '<') {
+                nodes.push(readElement())
+            } else {
+                nodes.push(readText())
+            }
+        }
+        return nodes
+    }
+
+    const roots: TemplateNode[] = []
+    while (cursor < source.length) {
+        if (source.startsWith('<!--', cursor)) {
+            skipComment()
+        } else if (atStyleTag()) {
+            roots.push(readStyle())
+        } else if (source.charAt(cursor) === '<') {
+            roots.push(readElement())
+        } else {
+            roots.push(readText())
+        }
+    }
+    return { nodes: roots }
+}
+
+/* Turns a component's attributes into props: a static value becomes a string
+   literal, an expression keeps its code (event/bind on components ignored). */
+function toProps(attrs: TemplateAttr[]): { name: string; code: string; loc?: number }[] {
+    const props: { name: string; code: string; loc?: number }[] = []
+    for (const attr of attrs) {
+        if (attr.kind === 'static') {
+            props.push({ name: attr.name, code: JSON.stringify(attr.value) })
+        } else if (attr.kind === 'expression') {
+            props.push({ name: attr.name, code: attr.code, loc: attr.loc })
+        }
+    }
+    return props
+}
+
+/* The literal text of an attribute (a static value or an expression's code);
+   undefined for event/bind attributes, which a directive never is. */
+function attrText(attr: TemplateAttr): string | undefined {
+    if (attr.kind === 'static') {
+        return attr.value
+    }
+    if (attr.kind === 'expression') {
+        return attr.code
+    }
+    return undefined
+}
+
+/* The source offset of an attribute expression's code (see TextPart.loc); only
+   expression attributes carry one — a static value isn't a checkable expression. */
+function attrLoc(attr: TemplateAttr | undefined): number | undefined {
+    return attr !== undefined && attr.kind === 'expression' ? attr.loc : undefined
+}
+
+/* The attribute's source name (`on<event>`/`bind:<property>` reconstructed). */
+function attrName(attr: TemplateAttr): string {
+    if (attr.kind === 'event') {
+        return `on${attr.event}`
+    }
+    if (attr.kind === 'bind') {
+        return `bind:${attr.property}`
+    }
+    if (attr.kind === 'attach') {
+        return 'attach'
+    }
+    return attr.name
+}
+
+/* Turns a `<template>` directive into a control node (if/each/await + then/catch). */
+function toControlFlow(attrs: TemplateAttr[], children: TemplateNode[]): TemplateNode {
+    const find = (name: string) => attrs.find((attr) => attrName(attr) === name)
+    /* `<template name="row" args={item}>` declares a snippet — a named builder, not
+       a control branch. `args` (its parameter list) rides the `{…}` expression slot. */
+    const snippet = find('name')
+    if (snippet !== undefined) {
+        const name = attrText(snippet)
+        if (name === undefined || name === '') {
+            throw new Error('[abide] <template name> requires a snippet name')
+        }
+        const params = find('args')
+        return {
+            kind: 'snippet',
+            name,
+            params: params === undefined ? undefined : attrText(params),
+            children,
+            loc: attrLoc(params),
+        }
+    }
+    /* `<template try>` is a synchronous error boundary: its children are the guarded
+       subtree; `catch`/`finally` branches handle a throw while building them. */
+    if (find('try') !== undefined) {
+        return { kind: 'try', children }
+    }
+    /* `await` alongside `each` is the async-list switch (handled in the each branch
+       below), not an await block. */
+    const promise = find('await')
+    if (promise !== undefined && find('each') === undefined) {
+        const promiseCode = attrText(promise)
+        if (promiseCode === undefined) {
+            throw new Error('[abide] <template await> requires a promise expression')
+        }
+        /* A `then` attribute ON the await tag is the blocking switch: children become
+           the resolved content bound to its value (a `then` *child* is a streaming
+           branch, handled separately below when its own tag is parsed). */
+        const boundThen = find('then')
+        return {
+            kind: 'await',
+            promise: promiseCode,
+            blocking: boundThen !== undefined,
+            as: boundThen === undefined ? undefined : attrText(boundThen) || undefined,
+            children,
+            loc: attrLoc(promise),
+        }
+    }
+    const thenAttr = find('then')
+    if (thenAttr !== undefined) {
+        return { kind: 'branch', branch: 'then', as: attrText(thenAttr) || undefined, children }
+    }
+    const catchAttr = find('catch')
+    if (catchAttr !== undefined) {
+        return { kind: 'branch', branch: 'catch', as: attrText(catchAttr) || undefined, children }
+    }
+    /* `<template finally>` renders after settle on BOTH outcomes — outcome-agnostic,
+       so it binds no value. */
+    if (find('finally') !== undefined) {
+        return { kind: 'branch', branch: 'finally', as: undefined, children }
+    }
+    const subject = find('switch')
+    if (subject !== undefined) {
+        const subjectCode = attrText(subject)
+        if (subjectCode === undefined) {
+            throw new Error('[abide] <template switch> requires a subject expression')
+        }
+        return { kind: 'switch', subject: subjectCode, children, loc: attrLoc(subject) }
+    }
+    const caseAttr = find('case')
+    if (caseAttr !== undefined) {
+        const matchCode = attrText(caseAttr)
+        if (matchCode === undefined) {
+            throw new Error('[abide] <template case> requires a value expression')
+        }
+        return { kind: 'case', match: matchCode, children, loc: attrLoc(caseAttr) }
+    }
+    if (find('default') !== undefined || find('else') !== undefined) {
+        return { kind: 'case', match: undefined, children } // default (switch) / else (if)
+    }
+    const condition = find('if')
+    if (condition !== undefined) {
+        const conditionCode = attrText(condition)
+        if (conditionCode === undefined) {
+            throw new Error('[abide] <template if> requires a condition expression')
+        }
+        return { kind: 'if', condition: conditionCode, children, loc: attrLoc(condition) }
+    }
+    const items = find('each')
+    const itemsCode = items === undefined ? undefined : attrText(items)
+    if (itemsCode === undefined) {
+        throw new Error('[abide] <template> without a supported directive (if/each)')
+    }
+    const as = find('as')
+    const key = find('key')
+    return {
+        kind: 'each',
+        items: itemsCode,
+        as: (as === undefined ? undefined : attrText(as)) ?? '_item',
+        key: key === undefined ? undefined : attrText(key),
+        async: find('await') !== undefined, // `<template each await>` over an AsyncIterable
+        children,
+        loc: attrLoc(items),
+    }
+}

package/src/lib/ui/compile/partitionSlots.ts

@@ -0,0 +1,36 @@
+import { staticAttrValue } from './staticAttrValue.ts'
+import type { TemplateNode } from './types/TemplateNode.ts'
+
+/* A component's slotted children split by destination slot. */
+export type SlotGroups = {
+    default: TemplateNode[]
+    named: { name: string; nodes: TemplateNode[] }[]
+}
+
+/*
+Partitions a component's children by their `slot="name"` attribute: an element
+carrying one goes to that named group (with the directive attr stripped so it
+never renders as a real attribute), everything else forms the default slot. Both
+back-ends partition identically, so SSR and client agree on which markup lands in
+which `<slot>`.
+*/
+export function partitionSlots(children: TemplateNode[]): SlotGroups {
+    const defaults: TemplateNode[] = []
+    const named = new Map<string, TemplateNode[]>()
+    for (const child of children) {
+        const name = child.kind === 'element' ? staticAttrValue(child, 'slot') : undefined
+        if (child.kind !== 'element' || name === undefined) {
+            defaults.push(child)
+            continue
+        }
+        const stripped = {
+            ...child,
+            attrs: child.attrs.filter((attr) => !(attr.kind === 'static' && attr.name === 'slot')),
+        }
+        named.set(name, [...(named.get(name) ?? []), stripped])
+    }
+    return {
+        default: defaults,
+        named: [...named].map(([name, nodes]) => ({ name, nodes })),
+    }
+}