feat: add `renderStaticHTML` to render a component without hydration markers

hydratable-flag
paoloricciuti 1 month ago
parent 3e083307f5
commit aa155e6963

@ -0,0 +1,5 @@
---
'svelte': patch
---
feat: add `renderStaticHTML` to render a component without hydration markers

@ -1,7 +1,6 @@
/** @import { BlockStatement, Expression, Pattern, Statement } from 'estree' */
/** @import { BlockStatement, Expression, Pattern } from 'estree' */
/** @import { AST } from '#compiler' */
/** @import { ComponentContext } from '../types.js' */
import { is_hydratable } from '../../../../../internal/server/hydration.js';
import * as b from '../../../../utils/builders.js';
import { empty_comment } from './shared/utils.js';
@ -10,8 +9,8 @@ import { empty_comment } from './shared/utils.js';
* @param {ComponentContext} context
*/
export function AwaitBlock(node, context) {
const hydratable = is_hydratable();
const templates = /** @type {Array<Expression | Statement>} */ ([
context.state.template.push(
empty_comment,
b.stmt(
b.call(
'$.await',
@ -28,13 +27,7 @@ export function AwaitBlock(node, context) {
node.catch ? /** @type {BlockStatement} */ (context.visit(node.catch)) : b.block([])
)
)
)
]);
if (hydratable) {
templates.unshift(empty_comment);
templates.push(empty_comment);
}
context.state.template.push(...templates);
),
empty_comment
);
}

@ -1,7 +1,6 @@
/** @import { BlockStatement, Expression, Pattern, Statement } from 'estree' */
/** @import { AST } from '#compiler' */
/** @import { ComponentContext } from '../types.js' */
import { BLOCK_OPEN_ELSE, is_hydratable } from '../../../../../internal/server/hydration.js';
import * as b from '../../../../utils/builders.js';
import { block_close, block_open } from './shared/utils.js';
@ -10,7 +9,6 @@ import { block_close, block_open } from './shared/utils.js';
* @param {ComponentContext} context
*/
export function EachBlock(node, context) {
const hydratable = is_hydratable();
const state = context.state;
const each_node_meta = node.metadata;
@ -41,32 +39,21 @@ export function EachBlock(node, context) {
);
if (node.fallback) {
const fallback = /** @type {BlockStatement} */ (context.visit(node.fallback));
const block = /** @type {Statement[]} */ ([for_loop]);
const open = b.stmt(b.assignment('+=', b.id('$$payload.out'), block_open));
if (hydratable) {
block.unshift(b.stmt(b.assignment('+=', b.id('$$payload.out'), block_open)));
fallback.body.unshift(
b.stmt(b.assignment('+=', b.id('$$payload.out'), b.literal(BLOCK_OPEN_ELSE)))
);
}
const fallback = /** @type {BlockStatement} */ (context.visit(node.fallback));
const templates = /** @type {Array<Expression | Statement>} */ ([
b.if(b.binary('!==', b.member(array_id, 'length'), b.literal(0)), b.block(block), fallback)
]);
if (hydratable) {
templates.push(block_close);
}
fallback.body.unshift(b.stmt(b.assignment('+=', b.id('$$payload.out'), b.call('$.open_else'))));
state.template.push(...templates);
state.template.push(
b.if(
b.binary('!==', b.member(array_id, 'length'), b.literal(0)),
b.block([open, for_loop]),
fallback
),
block_close
);
} else {
const templates = /** @type {Array<Expression | Statement>} */ ([for_loop]);
if (hydratable) {
templates.unshift(block_open);
templates.push(block_close);
}
state.template.push(...templates);
state.template.push(block_open, for_loop, block_close);
}
}

@ -3,7 +3,6 @@
import { clean_nodes, infer_namespace } from '../../utils.js';
import * as b from '../../../../utils/builders.js';
import { empty_comment, process_children, build_template } from './shared/utils.js';
import { is_hydratable } from '../../../../../internal/server/hydration.js';
/**
* @param {AST.Fragment} node
@ -36,8 +35,7 @@ export function Fragment(node, context) {
context.visit(node, state);
}
if (is_text_first && is_hydratable()) {
console.log({ hid: is_hydratable() });
if (is_text_first) {
// insert `<!---->` to prevent this from being glued to the previous fragment
state.template.push(empty_comment);
}

@ -1,7 +1,6 @@
/** @import { BlockStatement, Expression } from 'estree' */
/** @import { AST } from '#compiler' */
/** @import { ComponentContext } from '../types.js' */
import { BLOCK_OPEN_ELSE, is_hydratable } from '../../../../../internal/server/hydration.js';
import * as b from '../../../../utils/builders.js';
import { block_close, block_open } from './shared/utils.js';
@ -10,7 +9,6 @@ import { block_close, block_open } from './shared/utils.js';
* @param {ComponentContext} context
*/
export function IfBlock(node, context) {
const hydratable = is_hydratable();
const test = /** @type {Expression} */ (context.visit(node.test));
const consequent = /** @type {BlockStatement} */ (context.visit(node.consequent));
@ -19,13 +17,9 @@ export function IfBlock(node, context) {
? /** @type {BlockStatement} */ (context.visit(node.alternate))
: b.block([]);
if (hydratable) {
consequent.body.unshift(b.stmt(b.assignment('+=', b.id('$$payload.out'), block_open)));
consequent.body.unshift(b.stmt(b.assignment('+=', b.id('$$payload.out'), block_open)));
alternate.body.unshift(
b.stmt(b.assignment('+=', b.id('$$payload.out'), b.literal(BLOCK_OPEN_ELSE)))
);
}
alternate.body.unshift(b.stmt(b.assignment('+=', b.id('$$payload.out'), b.call('$.open_else'))));
context.state.template.push(b.if(test, consequent, alternate), block_close);
}

@ -1,7 +1,6 @@
/** @import { BlockStatement, Expression, Statement } from 'estree' */
/** @import { BlockStatement } from 'estree' */
/** @import { AST } from '#compiler' */
/** @import { ComponentContext } from '../types.js' */
import { is_hydratable } from '../../../../../internal/server/hydration.js';
import { empty_comment } from './shared/utils.js';
/**
@ -9,14 +8,9 @@ import { empty_comment } from './shared/utils.js';
* @param {ComponentContext} context
*/
export function KeyBlock(node, context) {
const templates = /** @type {Array<Expression | Statement>} */ ([
/** @type {BlockStatement} */ (context.visit(node.fragment))
]);
if (is_hydratable()) {
templates.unshift(empty_comment);
templates.push(empty_comment);
}
context.state.template.push(...templates);
context.state.template.push(
empty_comment,
/** @type {BlockStatement} */ (context.visit(node.fragment)),
empty_comment
);
}

@ -1,7 +1,6 @@
/** @import { Expression } from 'estree' */
/** @import { AST } from '#compiler' */
/** @import { ComponentContext } from '../types.js' */
import { is_hydratable } from '../../../../../internal/server/hydration.js';
import { unwrap_optional } from '../../../../utils/ast.js';
import * as b from '../../../../utils/builders.js';
import { empty_comment } from './shared/utils.js';
@ -30,7 +29,7 @@ export function RenderTag(node, context) {
)
);
if (!context.state.skip_hydration_boundaries && is_hydratable()) {
if (!context.state.skip_hydration_boundaries) {
context.state.template.push(empty_comment);
}
}

@ -1,7 +1,6 @@
/** @import { BlockStatement, Expression, Literal, Property, Statement } from 'estree' */
/** @import { BlockStatement, Expression, Literal, Property } from 'estree' */
/** @import { AST } from '#compiler' */
/** @import { ComponentContext } from '../types.js' */
import { is_hydratable } from '../../../../../internal/server/hydration.js';
import * as b from '../../../../utils/builders.js';
import { empty_comment, build_attribute_value } from './shared/utils.js';
@ -51,12 +50,5 @@ export function SlotElement(node, context) {
fallback
);
const templates = /** @type {Array<Expression | Statement>} */ ([b.stmt(slot)]);
if (is_hydratable()) {
templates.unshift(empty_comment);
templates.push(empty_comment);
}
context.state.template.push(...templates);
context.state.template.push(empty_comment, b.stmt(slot), empty_comment);
}

@ -3,23 +3,18 @@
/** @import { ComponentContext, ServerTransformState } from '../../types.js' */
import { escape_html } from '../../../../../../escaping.js';
import {
BLOCK_CLOSE,
BLOCK_OPEN,
EMPTY_COMMENT
} from '../../../../../../internal/server/hydration.js';
import * as b from '../../../../../utils/builders.js';
import { sanitize_template_string } from '../../../../../utils/sanitize_template_string.js';
import { regex_whitespaces_strict } from '../../../../patterns.js';
/** Opens an if/each block, so that we can remove nodes in the case of a mismatch */
export const block_open = b.literal(BLOCK_OPEN);
export const block_open = b.call('$.open');
/** Closes an if/each block, so that we can remove nodes in the case of a mismatch. Also serves as an anchor for these blocks */
export const block_close = b.literal(BLOCK_CLOSE);
export const block_close = b.call('$.close');
/** Empty comment to keep text nodes separate, or provide an anchor node for blocks */
export const empty_comment = b.literal(EMPTY_COMMENT);
export const empty_comment = b.call('$.empty');
/**
* Processes an array of template nodes, joining sibling text/expression nodes and

@ -1,13 +1,12 @@
import { DEV } from 'esm-env';
import { hash } from '../../../utils.js';
import { EMPTY_COMMENT, is_hydratable } from '../hydration.js';
import { empty, open as open_comment } from '../hydration.js';
/**
* @param {string} value
*/
export function html(value) {
const hydratable = is_hydratable();
var html = String(value ?? '');
var open = hydratable ? (DEV ? `<!--${hash(html)}-->` : EMPTY_COMMENT) : '';
return open + html + (hydratable ? EMPTY_COMMENT : '');
var open = DEV ? open_comment(hash(html)) : empty();
return open + html + empty();
}

@ -1,18 +1,42 @@
import { DEV } from 'esm-env';
import { HYDRATION_END, HYDRATION_START, HYDRATION_START_ELSE } from '../../constants.js';
export const BLOCK_OPEN = `<!--${HYDRATION_START}-->`;
export const BLOCK_OPEN_ELSE = `<!--${HYDRATION_START_ELSE}-->`;
export const BLOCK_CLOSE = `<!--${HYDRATION_END}-->`;
export const EMPTY_COMMENT = `<!---->`;
const BLOCK_OPEN = `<!--${HYDRATION_START}-->`;
const BLOCK_OPEN_ELSE = `<!--${HYDRATION_START_ELSE}-->`;
const BLOCK_CLOSE = `<!--${HYDRATION_END}-->`;
const EMPTY_COMMENT = `<!---->`;
let hydratable = true;
/**
* @param {string} [hash]
* @returns
*/
export function open(hash) {
if (!hydratable) return '';
if (DEV && hash) return `<!--${hash}-->`;
return BLOCK_OPEN;
}
export function open_else() {
if (!hydratable) return '';
return BLOCK_OPEN_ELSE;
}
export function close() {
if (!hydratable) return '';
return BLOCK_CLOSE;
}
export function empty() {
if (!hydratable) return '';
return EMPTY_COMMENT;
}
export function is_hydratable() {
return hydratable;
}
/**
*
* @param {boolean} new_hydratable
*/
export function set_hydratable(new_hydratable) {

@ -2,28 +2,22 @@
/** @import { Component, Payload, RenderOutput } from '#server' */
/** @import { Store } from '#shared' */
export { FILENAME, HMR } from '../../constants.js';
import { attr } from '../shared/attributes.js';
import { is_promise, noop } from '../shared/utils.js';
import { subscribe_to_store } from '../../store/utils.js';
import {
UNINITIALIZED,
ELEMENT_IS_NAMESPACED,
ELEMENT_PRESERVE_ATTRIBUTE_CASE,
ELEMENT_IS_NAMESPACED
UNINITIALIZED
} from '../../constants.js';
import { subscribe_to_store } from '../../store/utils.js';
import { attr } from '../shared/attributes.js';
import { is_promise, noop } from '../shared/utils.js';
import { escape_html } from '../../escaping.js';
import { DEV } from 'esm-env';
import { current_component, pop, push } from './context.js';
import {
EMPTY_COMMENT,
BLOCK_CLOSE,
BLOCK_OPEN,
set_hydratable,
is_hydratable
} from './hydration.js';
import { validate_store } from '../shared/validate.js';
import { escape_html } from '../../escaping.js';
import { is_boolean_attribute, is_void } from '../../utils.js';
import { validate_store } from '../shared/validate.js';
import { current_component, pop, push } from './context.js';
import { reset_elements } from './dev.js';
import { close, empty, open, open_else, set_hydratable } from './hydration.js';
// https://html.spec.whatwg.org/multipage/syntax.html#attributes-2
// https://infra.spec.whatwg.org/#noncharacter
@ -67,9 +61,7 @@ export function assign_payload(p1, p2) {
* @returns {void}
*/
export function element(payload, tag, attributes_fn = noop, children_fn = noop) {
let hydratable = is_hydratable();
if (hydratable) payload.out += EMPTY_COMMENT;
payload.out += empty();
if (tag) {
payload.out += `<${tag} `;
@ -78,14 +70,14 @@ export function element(payload, tag, attributes_fn = noop, children_fn = noop)
if (!is_void(tag)) {
children_fn();
if (!RAW_TEXT_ELEMENTS.includes(tag) && hydratable) {
payload.out += EMPTY_COMMENT;
if (!RAW_TEXT_ELEMENTS.includes(tag)) {
payload.out += empty();
}
payload.out += `</${tag}>`;
}
}
if (hydratable) payload.out += EMPTY_COMMENT;
payload.out += empty();
}
/**
@ -99,20 +91,16 @@ export let on_destroy = [];
* Takes a component and returns an object with `body` and `head` properties on it, which you can use to populate the HTML when server-rendering your app.
* @template {Record<string, any>} Props
* @param {import('svelte').Component<Props> | ComponentType<SvelteComponent<Props>>} component
* @param {{ props?: Omit<Props, '$$slots' | '$$events'>; context?: Map<any, any>, hydratable?: boolean }} [options]
* @param {{ props?: Omit<Props, '$$slots' | '$$events'>; context?: Map<any, any> }} [options]
* @returns {RenderOutput}
*/
export function render(component, options = {}) {
let hydratable = options?.hydratable ?? true;
console.log({ hydratable });
set_hydratable(hydratable);
/** @type {Payload} */
const payload = { out: '', css: new Set(), head: { title: '', out: '' } };
const prev_on_destroy = on_destroy;
on_destroy = [];
if (hydratable) payload.out += BLOCK_OPEN;
payload.out += open();
let reset_reset_element;
@ -137,7 +125,7 @@ export function render(component, options = {}) {
reset_reset_element();
}
if (hydratable) payload.out += BLOCK_CLOSE;
payload.out += close();
for (const cleanup of on_destroy) cleanup();
on_destroy = prev_on_destroy;
@ -154,6 +142,27 @@ export function render(component, options = {}) {
};
}
/**
* Only available on the server and when compiling with the `server` option.
* Takes a component and returns an object with `body` and `head` properties on it, which you can use to populate the HTML when server-rendering your app.
* Unlike `render` it doesn't render any hydration marker.
* @template {Record<string, any>} Props
* @param {import('svelte').Component<Props> | ComponentType<SvelteComponent<Props>>} component
* @param {{ props?: Omit<Props, '$$slots' | '$$events'>; context?: Map<any, any> }} [options]
* @returns {RenderOutput}
*/
export function renderStaticHTML(component, options) {
set_hydratable(false);
let payload;
try {
payload = render(component, options);
} finally {
set_hydratable(true);
}
return payload;
}
/**
* @param {Payload} payload
* @param {(head_payload: Payload['head']) => void} fn
@ -161,9 +170,9 @@ export function render(component, options = {}) {
*/
export function head(payload, fn) {
const head_payload = payload.head;
head_payload.out += BLOCK_OPEN;
head_payload.out += open();
fn(head_payload);
head_payload.out += BLOCK_CLOSE;
head_payload.out += close();
}
/**
@ -175,8 +184,6 @@ export function head(payload, fn) {
* @returns {void}
*/
export function css_props(payload, is_html, props, component, dynamic = false) {
let comment = is_hydratable() ? EMPTY_COMMENT : '';
const styles = style_object_to_string(props);
if (is_html) {
@ -186,15 +193,15 @@ export function css_props(payload, is_html, props, component, dynamic = false) {
}
if (dynamic) {
payload.out += comment;
payload.out += empty();
}
component();
if (is_html) {
payload.out += comment + `</svelte-css-wrapper>`;
payload.out += empty() + `</svelte-css-wrapper>`;
} else {
payload.out += comment + `</g>`;
payload.out += empty() + `</g>`;
}
}
@ -537,13 +544,13 @@ export function once(get_value) {
};
}
export { attr };
export { attr, close, empty, open, open_else };
export { html } from './blocks/html.js';
export { push, pop } from './context.js';
export { pop, push } from './context.js';
export { push_element, pop_element } from './dev.js';
export { pop_element, push_element } from './dev.js';
export { snapshot } from '../shared/clone.js';

@ -19,3 +19,23 @@ export function render<
options: { props: Omit<Props, '$$slots' | '$$events'>; context?: Map<any, any> }
]
): RenderOutput;
/**
* Only available on the server and when compiling with the `server` option.
* Takes a component and returns an object with `body` and `head` properties on it, which you can use to populate the HTML when server-rendering your app.
* Unlike `render` it doesn't render any hydration marker.
*/
export function renderStaticHTML<
Comp extends SvelteComponent<any> | Component<any>,
Props extends ComponentProps<Comp> = ComponentProps<Comp>
>(
...args: {} extends Props
? [
component: Comp extends SvelteComponent<any> ? ComponentType<Comp> : Comp,
options?: { props?: Omit<Props, '$$slots' | '$$events'>; context?: Map<any, any> }
]
: [
component: Comp extends SvelteComponent<any> ? ComponentType<Comp> : Comp,
options: { props: Omit<Props, '$$slots' | '$$events'>; context?: Map<any, any> }
]
): RenderOutput;

@ -1 +1 @@
export { render } from '../internal/server/index.js';
export { render, renderStaticHTML } from '../internal/server/index.js';

Loading…
Cancel
Save