@abide/abide 0.43.0 → 0.44.0

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

@@ -0,0 +1,55 @@
+import { classStyleMergePlan } from './classStyleMergePlan.ts'
+import type { ElementPlan, ElementPlanAttr } from './types/ElementPlan.ts'
+import type { TemplateAttr } from './types/TemplateAttr.ts'
+import type { TemplateNode } from './types/TemplateNode.ts'
+import { VOID_TAGS } from './VOID_TAGS.ts'
+
+/*
+The single decision site for one element's attribute emission — lifted out of the two
+hand-mirrored code-gen back-ends (`generateBuild`, `generateSSR`) so the load-bearing
+agreement on which attribute is which kind, which class/style parts merge, and which tag
+is void lives ONCE (ADR-0013, the locality milestone). Each back-end RENDERS the plan
+differently — build wires live effects/thunks, SSR pushes escaped strings — but consults
+the same classification, so the markup the client clones and the server emits cannot drift.
+
+`classStyleMergePlan` folds in as the class/style branch. Each attr is tagged `mergedBuild`
+/`mergedSSR` from the two merge triggers (build merges only on an interpolated base, SSR on
+any directive), so a back-end skips exactly the attrs it folded into its merged class/style
+attribute. The positional holes/anchors stay in `skeletonContext`; this plan layers over it.
+*/
+export function elementPlan(
+    node: Extract<TemplateNode, { kind: 'element' }>,
+    lower: (code: string) => string,
+): ElementPlan {
+    const merge = classStyleMergePlan(node.attrs, lower)
+    /* True when this attr is folded into the build back-end's merged class/style effect — the
+       interpolated base or any directive of a merged property (a static base stays surgical). */
+    const isMergedBuild = (attr: TemplateAttr): boolean =>
+        (merge.mergeClassBuild && (attr === merge.classBase || attr.kind === 'class')) ||
+        (merge.mergeStyleBuild && (attr === merge.styleBase || attr.kind === 'style'))
+    /* True when this attr is folded into the SSR back-end's merged class/style attribute,
+       whenever a directive exists. A `class:`/`style:` directive always folds; a static or
+       interpolated base folds by NAME (so a duplicate `class`/`style` base is folded too,
+       never double-emitted next to the merged attribute — the old SSR by-name skip). */
+    const isMergedSSR = (attr: TemplateAttr): boolean => {
+        if (attr.kind === 'class') {
+            return merge.mergeClass
+        }
+        if (attr.kind === 'style') {
+            return merge.mergeStyle
+        }
+        if (attr.kind === 'static' || attr.kind === 'interpolated') {
+            return (
+                (attr.name === 'class' && merge.mergeClass) ||
+                (attr.name === 'style' && merge.mergeStyle)
+            )
+        }
+        return false
+    }
+    const attrs: ElementPlanAttr[] = node.attrs.map((attr) => ({
+        attr,
+        mergedBuild: isMergedBuild(attr),
+        mergedSSR: isMergedSSR(attr),
+    }))
+    return { attrs, merge, isVoid: VOID_TAGS.has(node.tag) }
+}

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

@@ -10,8 +10,31 @@ by start; tokens with an unknown legend type, and any token overlapping the one
 before it, are dropped — the protocol requires a strictly non-overlapping,
 positionally-ordered stream.
 */
+/*
+A token may span newlines (a multiline template-literal string), but the protocol
+forbids a token crossing a line — so split it into one segment per covered line,
+dropping empty lines. A single-line token returns unchanged.
+*/
+function splitByLine(text: string, token: SemanticToken): SemanticToken[] {
+    const raw = text.slice(token.start, token.start + token.length)
+    if (!raw.includes('\n')) {
+        return [token]
+    }
+    const segments: SemanticToken[] = []
+    let offset = token.start
+    for (const line of raw.split('\n')) {
+        if (line.length > 0) {
+            segments.push({ ...token, start: offset, length: line.length })
+        }
+        offset += line.length + 1
+    }
+    return segments
+}
+
 export function encodeSemanticTokens(text: string, tokens: SemanticToken[]): number[] {
-    const sorted = [...tokens].sort((a, b) => a.start - b.start || a.length - b.length)
+    const sorted = tokens
+        .flatMap((token) => splitByLine(text, token))
+        .sort((a, b) => a.start - b.start || a.length - b.length)
     const data: number[] = []
     let previousLine = 0
     let previousCharacter = 0