msb-public
/
svelte
mirror of https://github.com/sveltejs/svelte
1
0
Code Issues Projects Releases Wiki Activity

feat: Expose more AST types from `"svelte/compiler"` (#14601)

Browse Source 
* add missing `SvelteBoundary` in `ElementLike`

* make union of AST types public and exportable with `AST` namespace

* apply AST types change to codebase

* changeset

* manually generate types

* Add `AttributeLike` type

* export namespace `Css` inside `AST`

* manually generate types again

* exported `Css` -> `CSS`

* `Css` -> `AST.CSS`

* fix Prettier issue

* Apply suggestions from code review

---------

Co-authored-by: Rich Harris <hello@rich-harris.dev>
pull/14699/head
Mateusz Kadlubowski 11 months ago committed by GitHub
parent 2e0dcd7872
commit 61a0da8a5f
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
50 changed files with 343 additions and 303 deletions
Show Stats Download Patch File Download Diff File

5
.changeset/short-papayas-relate.md
Unescape View File

@ -0,0 +1,5 @@
---
'svelte': minor
---
feat: expose more AST types from `"svelte/compiler"`

6
packages/svelte/src/compiler/legacy.js
Unescape View File

@ -1,5 +1,5 @@
/** @import { Expression } from 'estree' */ /** @import { Expression } from 'estree' */
/** @import { AST, SvelteNode, TemplateNode } from '#compiler' */ /** @import { AST } from '#compiler' */
/** @import * as Legacy from './types/legacy-nodes.js' */ /** @import * as Legacy from './types/legacy-nodes.js' */
import { walk } from 'zimmerframe'; import { walk } from 'zimmerframe';
import { import {
@ -11,7 +11,7 @@ import { extract_svelte_ignore } from './utils/extract_svelte_ignore.js';
/** /**
* Some of the legacy Svelte AST nodes remove whitespace from the start and end of their children. * Some of the legacy Svelte AST nodes remove whitespace from the start and end of their children.
* @param {TemplateNode[]} nodes * @param {AST.TemplateNode[]} nodes
*/ */
function remove_surrounding_whitespace_nodes(nodes) { function remove_surrounding_whitespace_nodes(nodes) {
const first = nodes.at(0); const first = nodes.at(0);
@ -40,7 +40,7 @@ function remove_surrounding_whitespace_nodes(nodes) {
* @returns {Legacy.LegacyRoot} * @returns {Legacy.LegacyRoot}
*/ */
export function convert(source, ast) { export function convert(source, ast) {
const root = /** @type {SvelteNode | Legacy.LegacySvelteNode} */ (ast); const root = /** @type {AST.SvelteNode | Legacy.LegacySvelteNode} */ (ast);
return /** @type {Legacy.LegacyRoot} */ ( return /** @type {Legacy.LegacyRoot} */ (
walk(root, null, { walk(root, null, {

10
packages/svelte/src/compiler/migrate/index.js
Unescape View File

@ -2,7 +2,7 @@
/** @import { Visitors } from 'zimmerframe' */ /** @import { Visitors } from 'zimmerframe' */
/** @import { ComponentAnalysis } from '../phases/types.js' */ /** @import { ComponentAnalysis } from '../phases/types.js' */
/** @import { Scope, ScopeRoot } from '../phases/scope.js' */ /** @import { Scope, ScopeRoot } from '../phases/scope.js' */
/** @import { AST, Binding, SvelteNode, ValidatedCompileOptions } from '#compiler' */ /** @import { AST, Binding, ValidatedCompileOptions } from '#compiler' */
import MagicString from 'magic-string'; import MagicString from 'magic-string';
import { walk } from 'zimmerframe'; import { walk } from 'zimmerframe';
import { parse } from '../phases/1-parse/index.js'; import { parse } from '../phases/1-parse/index.js';
@ -479,7 +479,7 @@ export function migrate(source, { filename, use_ts } = {}) {
* }} State * }} State
*/ */
/** @type {Visitors<SvelteNode, State>} */ /** @type {Visitors<AST.SvelteNode, State>} */
const instance_script = { const instance_script = {
_(node, { state, next }) { _(node, { state, next }) {
// @ts-expect-error // @ts-expect-error
@ -1050,7 +1050,7 @@ function trim_block(state, start, end) {
} }
} }
/** @type {Visitors<SvelteNode, State>} */ /** @type {Visitors<AST.SvelteNode, State>} */
const template = { const template = {
Identifier(node, { state, path }) { Identifier(node, { state, path }) {
handle_identifier(node, state, path); handle_identifier(node, state, path);
@ -1410,7 +1410,7 @@ const template = {
/** /**
* @param {AST.RegularElement | AST.SvelteElement | AST.SvelteComponent | AST.Component | AST.SlotElement | AST.SvelteFragment} node * @param {AST.RegularElement | AST.SvelteElement | AST.SvelteComponent | AST.Component | AST.SlotElement | AST.SvelteFragment} node
* @param {SvelteNode[]} path * @param {AST.SvelteNode[]} path
* @param {State} state * @param {State} state
*/ */
function migrate_slot_usage(node, path, state) { function migrate_slot_usage(node, path, state) {
@ -1580,7 +1580,7 @@ function migrate_slot_usage(node, path, state) {
/** /**
* @param {VariableDeclarator} declarator * @param {VariableDeclarator} declarator
* @param {State} state * @param {State} state
* @param {SvelteNode[]} path * @param {AST.SvelteNode[]} path
*/ */
function extract_type_and_comment(declarator, state, path) { function extract_type_and_comment(declarator, state, path) {
const str = state.str; const str = state.str;

4
packages/svelte/src/compiler/phases/1-parse/index.js
Unescape View File

@ -1,4 +1,4 @@
/** @import { AST, TemplateNode } from '#compiler' */ /** @import { AST } from '#compiler' */
// @ts-expect-error acorn type definitions are borked in the release we use // @ts-expect-error acorn type definitions are borked in the release we use
import { isIdentifierStart, isIdentifierChar } from 'acorn'; import { isIdentifierStart, isIdentifierChar } from 'acorn';
import fragment from './state/fragment.js'; import fragment from './state/fragment.js';
@ -28,7 +28,7 @@ export class Parser {
/** Whether we're parsing in TypeScript mode */ /** Whether we're parsing in TypeScript mode */
ts = false; ts = false;
/** @type {TemplateNode[]} */ /** @type {AST.TemplateNode[]} */
stack = []; stack = [];
/** @type {AST.Fragment[]} */ /** @type {AST.Fragment[]} */

4
packages/svelte/src/compiler/phases/1-parse/read/script.js
Unescape View File

@ -1,5 +1,5 @@
/** @import { Program } from 'estree' */ /** @import { Program } from 'estree' */
/** @import { AST, Directive } from '#compiler' */ /** @import { AST } from '#compiler' */
/** @import { Parser } from '../index.js' */ /** @import { Parser } from '../index.js' */
import * as acorn from '../acorn.js'; import * as acorn from '../acorn.js';
import { regex_not_newline_characters } from '../../patterns.js'; import { regex_not_newline_characters } from '../../patterns.js';
@ -16,7 +16,7 @@ const ALLOWED_ATTRIBUTES = ['context', 'generics', 'lang', 'module'];
/** /**
* @param {Parser} parser * @param {Parser} parser
* @param {number} start * @param {number} start
* @param {Array<AST.Attribute | AST.SpreadAttribute | Directive>} attributes * @param {Array<AST.Attribute | AST.SpreadAttribute | AST.Directive>} attributes
* @returns {AST.Script} * @returns {AST.Script}
*/ */
export function read_script(parser, start, attributes) { export function read_script(parser, start, attributes) {

40
packages/svelte/src/compiler/phases/1-parse/read/style.js
Unescape View File

@ -1,4 +1,4 @@
/** @import { AST, Css, Directive } from '#compiler' */ /** @import { AST } from '#compiler' */
/** @import { Parser } from '../index.js' */ /** @import { Parser } from '../index.js' */
import * as e from '../../../errors.js'; import * as e from '../../../errors.js';
@ -18,8 +18,8 @@ const REGEX_HTML_COMMENT_CLOSE = /-->/;
/** /**
* @param {Parser} parser * @param {Parser} parser
* @param {number} start * @param {number} start
* @param {Array<AST.Attribute | AST.SpreadAttribute | Directive>} attributes * @param {Array<AST.Attribute | AST.SpreadAttribute | AST.Directive>} attributes
* @returns {Css.StyleSheet} * @returns {AST.CSS.StyleSheet}
*/ */
export default function read_style(parser, start, attributes) { export default function read_style(parser, start, attributes) {
const content_start = parser.index; const content_start = parser.index;
@ -49,7 +49,7 @@ export default function read_style(parser, start, attributes) {
* @returns {any[]} * @returns {any[]}
*/ */
function read_body(parser, close) { function read_body(parser, close) {
/** @type {Array<Css.Rule | Css.Atrule>} */ /** @type {Array<AST.CSS.Rule | AST.CSS.Atrule>} */
const children = []; const children = [];
while (parser.index < parser.template.length) { while (parser.index < parser.template.length) {
@ -71,7 +71,7 @@ function read_body(parser, close) {
/** /**
* @param {Parser} parser * @param {Parser} parser
* @returns {Css.Atrule} * @returns {AST.CSS.Atrule}
*/ */
function read_at_rule(parser) { function read_at_rule(parser) {
const start = parser.index; const start = parser.index;
@ -81,7 +81,7 @@ function read_at_rule(parser) {
const prelude = read_value(parser); const prelude = read_value(parser);
/** @type {Css.Block | null} */ /** @type {AST.CSS.Block | null} */
let block = null; let block = null;
if (parser.match('{')) { if (parser.match('{')) {
@ -104,7 +104,7 @@ function read_at_rule(parser) {
/** /**
* @param {Parser} parser * @param {Parser} parser
* @returns {Css.Rule} * @returns {AST.CSS.Rule}
*/ */
function read_rule(parser) { function read_rule(parser) {
const start = parser.index; const start = parser.index;
@ -126,10 +126,10 @@ function read_rule(parser) {
/** /**
* @param {Parser} parser * @param {Parser} parser
* @param {boolean} [inside_pseudo_class] * @param {boolean} [inside_pseudo_class]
* @returns {Css.SelectorList} * @returns {AST.CSS.SelectorList}
*/ */
function read_selector_list(parser, inside_pseudo_class = false) { function read_selector_list(parser, inside_pseudo_class = false) {
/** @type {Css.ComplexSelector[]} */ /** @type {AST.CSS.ComplexSelector[]} */
const children = []; const children = [];
allow_comment_or_whitespace(parser); allow_comment_or_whitespace(parser);
@ -162,18 +162,18 @@ function read_selector_list(parser, inside_pseudo_class = false) {
/** /**
* @param {Parser} parser * @param {Parser} parser
* @param {boolean} [inside_pseudo_class] * @param {boolean} [inside_pseudo_class]
* @returns {Css.ComplexSelector} * @returns {AST.CSS.ComplexSelector}
*/ */
function read_selector(parser, inside_pseudo_class = false) { function read_selector(parser, inside_pseudo_class = false) {
const list_start = parser.index; const list_start = parser.index;
/** @type {Css.RelativeSelector[]} */ /** @type {AST.CSS.RelativeSelector[]} */
const children = []; const children = [];
/** /**
* @param {Css.Combinator | null} combinator * @param {AST.CSS.Combinator | null} combinator
* @param {number} start * @param {number} start
* @returns {Css.RelativeSelector} * @returns {AST.CSS.RelativeSelector}
*/ */
function create_selector(combinator, start) { function create_selector(combinator, start) {
return { return {
@ -190,7 +190,7 @@ function read_selector(parser, inside_pseudo_class = false) {
}; };
} }
/** @type {Css.RelativeSelector} */ /** @type {AST.CSS.RelativeSelector} */
let relative_selector = create_selector(null, parser.index); let relative_selector = create_selector(null, parser.index);
while (parser.index < parser.template.length) { while (parser.index < parser.template.length) {
@ -247,7 +247,7 @@ function read_selector(parser, inside_pseudo_class = false) {
} else if (parser.eat(':')) { } else if (parser.eat(':')) {
const name = read_identifier(parser); const name = read_identifier(parser);
/** @type {null | Css.SelectorList} */ /** @type {null | AST.CSS.SelectorList} */
let args = null; let args = null;
if (parser.eat('(')) { if (parser.eat('(')) {
@ -372,7 +372,7 @@ function read_selector(parser, inside_pseudo_class = false) {
/** /**
* @param {Parser} parser * @param {Parser} parser
* @returns {Css.Combinator | null} * @returns {AST.CSS.Combinator | null}
*/ */
function read_combinator(parser) { function read_combinator(parser) {
const start = parser.index; const start = parser.index;
@ -407,14 +407,14 @@ function read_combinator(parser) {
/** /**
* @param {Parser} parser * @param {Parser} parser
* @returns {Css.Block} * @returns {AST.CSS.Block}
*/ */
function read_block(parser) { function read_block(parser) {
const start = parser.index; const start = parser.index;
parser.eat('{', true); parser.eat('{', true);
/** @type {Array<Css.Declaration | Css.Rule | Css.Atrule>} */ /** @type {Array<AST.CSS.Declaration | AST.CSS.Rule | AST.CSS.Atrule>} */
const children = []; const children = [];
while (parser.index < parser.template.length) { while (parser.index < parser.template.length) {
@ -441,7 +441,7 @@ function read_block(parser) {
* Reads a declaration, rule or at-rule * Reads a declaration, rule or at-rule
* *
* @param {Parser} parser * @param {Parser} parser
* @returns {Css.Declaration | Css.Rule | Css.Atrule} * @returns {AST.CSS.Declaration | AST.CSS.Rule | AST.CSS.Atrule}
*/ */
function read_block_item(parser) { function read_block_item(parser) {
if (parser.match('@')) { if (parser.match('@')) {
@ -460,7 +460,7 @@ function read_block_item(parser) {
/** /**
* @param {Parser} parser * @param {Parser} parser
* @returns {Css.Declaration} * @returns {AST.CSS.Declaration}
*/ */
function read_declaration(parser) { function read_declaration(parser) {
const start = parser.index; const start = parser.index;

18
packages/svelte/src/compiler/phases/1-parse/state/element.js
Unescape View File

@ -1,5 +1,5 @@
/** @import { Expression } from 'estree' */ /** @import { Expression } from 'estree' */
/** @import { AST, Directive, ElementLike, TemplateNode } from '#compiler' */ /** @import { AST } from '#compiler' */
/** @import { Parser } from '../index.js' */ /** @import { Parser } from '../index.js' */
import { is_void } from '../../../../utils.js'; import { is_void } from '../../../../utils.js';
import read_expression from '../read/expression.js'; import read_expression from '../read/expression.js';
@ -28,7 +28,7 @@ export const regex_valid_component_name =
// (must start with uppercase letter if no dots, can contain dots) // (must start with uppercase letter if no dots, can contain dots)
/^(?:\p{Lu}[$\u200c\u200d\p{ID_Continue}.]*|\p{ID_Start}[$\u200c\u200d\p{ID_Continue}]*(?:\.[$\u200c\u200d\p{ID_Continue}]+)+)$/u; /^(?:\p{Lu}[$\u200c\u200d\p{ID_Continue}.]*|\p{ID_Start}[$\u200c\u200d\p{ID_Continue}]*(?:\.[$\u200c\u200d\p{ID_Continue}]+)+)$/u;
/** @type {Map<string, ElementLike['type']>} */ /** @type {Map<string, AST.ElementLike['type']>} */
const root_only_meta_tags = new Map([ const root_only_meta_tags = new Map([
['svelte:head', 'SvelteHead'], ['svelte:head', 'SvelteHead'],
['svelte:options', 'SvelteOptions'], ['svelte:options', 'SvelteOptions'],
@ -37,7 +37,7 @@ const root_only_meta_tags = new Map([
['svelte:body', 'SvelteBody'] ['svelte:body', 'SvelteBody']
]); ]);
/** @type {Map<string, ElementLike['type']>} */ /** @type {Map<string, AST.ElementLike['type']>} */
const meta_tags = new Map([ const meta_tags = new Map([
...root_only_meta_tags, ...root_only_meta_tags,
['svelte:element', 'SvelteElement'], ['svelte:element', 'SvelteElement'],
@ -137,7 +137,7 @@ export default function element(parser) {
? 'SlotElement' ? 'SlotElement'
: 'RegularElement'; : 'RegularElement';
/** @type {ElementLike} */ /** @type {AST.ElementLike} */
const element = const element =
type === 'RegularElement' type === 'RegularElement'
? { ? {
@ -155,7 +155,7 @@ export default function element(parser) {
path: [] path: []
} }
} }
: /** @type {ElementLike} */ ({ : /** @type {AST.ElementLike} */ ({
type, type,
start, start,
end: -1, end: -1,
@ -358,7 +358,7 @@ export default function element(parser) {
} }
} }
/** @param {TemplateNode[]} stack */ /** @param {AST.TemplateNode[]} stack */
function parent_is_head(stack) { function parent_is_head(stack) {
let i = stack.length; let i = stack.length;
while (i--) { while (i--) {
@ -369,7 +369,7 @@ function parent_is_head(stack) {
return false; return false;
} }
/** @param {TemplateNode[]} stack */ /** @param {AST.TemplateNode[]} stack */
function parent_is_shadowroot_template(stack) { function parent_is_shadowroot_template(stack) {
// https://developer.chrome.com/docs/css-ui/declarative-shadow-dom#building_a_declarative_shadow_root // https://developer.chrome.com/docs/css-ui/declarative-shadow-dom#building_a_declarative_shadow_root
let i = stack.length; let i = stack.length;
@ -433,7 +433,7 @@ function read_static_attribute(parser) {
/** /**
* @param {Parser} parser * @param {Parser} parser
* @returns {AST.Attribute | AST.SpreadAttribute | Directive | null} * @returns {AST.Attribute | AST.SpreadAttribute | AST.Directive | null}
*/ */
function read_attribute(parser) { function read_attribute(parser) {
const start = parser.index; const start = parser.index;
@ -564,7 +564,7 @@ function read_attribute(parser) {
} }
} }
/** @type {Directive} */ /** @type {AST.Directive} */
const directive = { const directive = {
start, start,
end, end,

18
packages/svelte/src/compiler/phases/2-analyze/css/css-analyze.js
Unescape View File

@ -1,5 +1,5 @@
/** @import { ComponentAnalysis } from '../../types.js' */ /** @import { ComponentAnalysis } from '../../types.js' */
/** @import { Css } from '#compiler' */ /** @import { AST } from '#compiler' */
/** @import { Visitors } from 'zimmerframe' */ /** @import { Visitors } from 'zimmerframe' */
import { walk } from 'zimmerframe'; import { walk } from 'zimmerframe';
import * as e from '../../../errors.js'; import * as e from '../../../errors.js';
@ -8,17 +8,17 @@ import { is_global, is_unscoped_pseudo_class } from './utils.js';
/** /**
* @typedef {Visitors< * @typedef {Visitors<
* Css.Node, * AST.CSS.Node,
* { * {
* keyframes: string[]; * keyframes: string[];
* rule: Css.Rule | null; * rule: AST.CSS.Rule | null;
* } * }
* >} CssVisitors * >} CssVisitors
*/ */
/** /**
* True if is `:global` * True if is `:global`
* @param {Css.SimpleSelector} simple_selector * @param {AST.CSS.SimpleSelector} simple_selector
*/ */
function is_global_block_selector(simple_selector) { function is_global_block_selector(simple_selector) {
return ( return (
@ -112,7 +112,7 @@ const css_visitors = {
} }
}, },
RelativeSelector(node, context) { RelativeSelector(node, context) {
const parent = /** @type {Css.ComplexSelector} */ (context.path.at(-1)); const parent = /** @type {AST.CSS.ComplexSelector} */ (context.path.at(-1));
if ( if (
node.combinator != null && node.combinator != null &&
@ -149,7 +149,7 @@ const css_visitors = {
if (node.metadata.is_global_like || node.metadata.is_global) { if (node.metadata.is_global_like || node.metadata.is_global) {
// So that nested selectors like `:root:not(.x)` are not marked as unused // So that nested selectors like `:root:not(.x)` are not marked as unused
for (const child of node.selectors) { for (const child of node.selectors) {
walk(/** @type {Css.Node} */ (child), null, { walk(/** @type {AST.CSS.Node} */ (child), null, {
ComplexSelector(node, context) { ComplexSelector(node, context) {
node.metadata.used = true; node.metadata.used = true;
context.next(); context.next();
@ -177,7 +177,7 @@ const css_visitors = {
if (idx !== -1) { if (idx !== -1) {
is_global_block = true; is_global_block = true;
for (let i = idx + 1; i < child.selectors.length; i++) { for (let i = idx + 1; i < child.selectors.length; i++) {
walk(/** @type {Css.Node} */ (child.selectors[i]), null, { walk(/** @type {AST.CSS.Node} */ (child.selectors[i]), null, {
ComplexSelector(node) { ComplexSelector(node) {
node.metadata.used = true; node.metadata.used = true;
} }
@ -240,7 +240,7 @@ const css_visitors = {
}); });
}, },
NestingSelector(node, context) { NestingSelector(node, context) {
const rule = /** @type {Css.Rule} */ (context.state.rule); const rule = /** @type {AST.CSS.Rule} */ (context.state.rule);
const parent_rule = rule.metadata.parent_rule; const parent_rule = rule.metadata.parent_rule;
if (!parent_rule) { if (!parent_rule) {
@ -271,7 +271,7 @@ const css_visitors = {
}; };
/** /**
* @param {Css.StyleSheet} stylesheet * @param {AST.CSS.StyleSheet} stylesheet
* @param {ComponentAnalysis} analysis * @param {ComponentAnalysis} analysis
*/ */
export function analyze_css(stylesheet, analysis) { export function analyze_css(stylesheet, analysis) {

58
packages/svelte/src/compiler/phases/2-analyze/css/css-prune.js
Unescape View File

@ -14,7 +14,7 @@ const whitelist_attribute_selector = new Map([
['dialog', ['open']] ['dialog', ['open']]
]); ]);
/** @type {Compiler.Css.Combinator} */ /** @type {Compiler.AST.CSS.Combinator} */
const descendant_combinator = { const descendant_combinator = {
type: 'Combinator', type: 'Combinator',
name: ' ', name: ' ',
@ -22,7 +22,7 @@ const descendant_combinator = {
end: -1 end: -1
}; };
/** @type {Compiler.Css.RelativeSelector} */ /** @type {Compiler.AST.CSS.RelativeSelector} */
const nesting_selector = { const nesting_selector = {
type: 'RelativeSelector', type: 'RelativeSelector',
start: -1, start: -1,
@ -51,11 +51,11 @@ const seen = new Set();
/** /**
* *
* @param {Compiler.Css.StyleSheet} stylesheet * @param {Compiler.AST.CSS.StyleSheet} stylesheet
* @param {Compiler.AST.RegularElement | Compiler.AST.SvelteElement} element * @param {Compiler.AST.RegularElement | Compiler.AST.SvelteElement} element
*/ */
export function prune(stylesheet, element) { export function prune(stylesheet, element) {
walk(/** @type {Compiler.Css.Node} */ (stylesheet), null, { walk(/** @type {Compiler.AST.CSS.Node} */ (stylesheet), null, {
Rule(node, context) { Rule(node, context) {
if (node.metadata.is_global_block) { if (node.metadata.is_global_block) {
context.visit(node.prelude); context.visit(node.prelude);
@ -69,7 +69,11 @@ export function prune(stylesheet, element) {
seen.clear(); seen.clear();
if ( if (
apply_selector(selectors, /** @type {Compiler.Css.Rule} */ (node.metadata.rule), element) apply_selector(
selectors,
/** @type {Compiler.AST.CSS.Rule} */ (node.metadata.rule),
element
)
) { ) {
node.metadata.used = true; node.metadata.used = true;
} }
@ -86,7 +90,7 @@ export function prune(stylesheet, element) {
* Also searches them for any existing `&` selectors and adds one if none are found. * Also searches them for any existing `&` selectors and adds one if none are found.
* This ensures we traverse up to the parent rule when the inner selectors match and we're * This ensures we traverse up to the parent rule when the inner selectors match and we're
* trying to see if the parent rule also matches. * trying to see if the parent rule also matches.
* @param {Compiler.Css.ComplexSelector} node * @param {Compiler.AST.CSS.ComplexSelector} node
*/ */
function get_relative_selectors(node) { function get_relative_selectors(node) {
const selectors = truncate(node); const selectors = truncate(node);
@ -124,7 +128,7 @@ function get_relative_selectors(node) {
/** /**
* Discard trailing `:global(...)` selectors, these are unused for scoping purposes * Discard trailing `:global(...)` selectors, these are unused for scoping purposes
* @param {Compiler.Css.ComplexSelector} node * @param {Compiler.AST.CSS.ComplexSelector} node
*/ */
function truncate(node) { function truncate(node) {
const i = node.children.findLastIndex(({ metadata, selectors }) => { const i = node.children.findLastIndex(({ metadata, selectors }) => {
@ -152,8 +156,8 @@ function truncate(node) {
} }
/** /**
* @param {Compiler.Css.RelativeSelector[]} relative_selectors * @param {Compiler.AST.CSS.RelativeSelector[]} relative_selectors
* @param {Compiler.Css.Rule} rule * @param {Compiler.AST.CSS.Rule} rule
* @param {Compiler.AST.RegularElement | Compiler.AST.SvelteElement} element * @param {Compiler.AST.RegularElement | Compiler.AST.SvelteElement} element
* @returns {boolean} * @returns {boolean}
*/ */
@ -178,9 +182,9 @@ function apply_selector(relative_selectors, rule, element) {
} }
/** /**
* @param {Compiler.Css.RelativeSelector} relative_selector * @param {Compiler.AST.CSS.RelativeSelector} relative_selector
* @param {Compiler.Css.RelativeSelector[]} parent_selectors * @param {Compiler.AST.CSS.RelativeSelector[]} parent_selectors
* @param {Compiler.Css.Rule} rule * @param {Compiler.AST.CSS.Rule} rule
* @param {Compiler.AST.RegularElement | Compiler.AST.SvelteElement | Compiler.AST.RenderTag | Compiler.AST.Component | Compiler.AST.SvelteComponent | Compiler.AST.SvelteSelf} node * @param {Compiler.AST.RegularElement | Compiler.AST.SvelteElement | Compiler.AST.RenderTag | Compiler.AST.Component | Compiler.AST.SvelteComponent | Compiler.AST.SvelteSelf} node
* @returns {boolean} * @returns {boolean}
*/ */
@ -263,8 +267,8 @@ function apply_combinator(relative_selector, parent_selectors, rule, node) {
* it's a `:global(...)` or unscopeable selector, or * it's a `:global(...)` or unscopeable selector, or
* is an `:is(...)` or `:where(...)` selector that contains * is an `:is(...)` or `:where(...)` selector that contains
* a global selector * a global selector
* @param {Compiler.Css.RelativeSelector} selector * @param {Compiler.AST.CSS.RelativeSelector} selector
* @param {Compiler.Css.Rule} rule * @param {Compiler.AST.CSS.Rule} rule
*/ */
function is_global(selector, rule) { function is_global(selector, rule) {
if (selector.metadata.is_global || selector.metadata.is_global_like) { if (selector.metadata.is_global || selector.metadata.is_global_like) {
@ -272,7 +276,7 @@ function is_global(selector, rule) {
} }
for (const s of selector.selectors) { for (const s of selector.selectors) {
/** @type {Compiler.Css.SelectorList | null} */ /** @type {Compiler.AST.CSS.SelectorList | null} */
let selector_list = null; let selector_list = null;
let owner = rule; let owner = rule;
@ -283,7 +287,7 @@ function is_global(selector, rule) {
} }
if (s.type === 'NestingSelector') { if (s.type === 'NestingSelector') {
owner = /** @type {Compiler.Css.Rule} */ (rule.metadata.parent_rule); owner = /** @type {Compiler.AST.CSS.Rule} */ (rule.metadata.parent_rule);
selector_list = owner.prelude; selector_list = owner.prelude;
} }
@ -306,8 +310,8 @@ const regex_backslash_and_following_character = /\\(.)/g;
/** /**
* Ensure that `element` satisfies each simple selector in `relative_selector` * Ensure that `element` satisfies each simple selector in `relative_selector`
* *
* @param {Compiler.Css.RelativeSelector} relative_selector * @param {Compiler.AST.CSS.RelativeSelector} relative_selector
* @param {Compiler.Css.Rule} rule * @param {Compiler.AST.CSS.Rule} rule
* @param {Compiler.AST.RegularElement | Compiler.AST.SvelteElement} element * @param {Compiler.AST.RegularElement | Compiler.AST.SvelteElement} element
* @returns {boolean} * @returns {boolean}
*/ */
@ -352,7 +356,7 @@ function relative_selector_might_apply_to_node(relative_selector, rule, element)
const seen = new Set(); const seen = new Set();
/** /**
* @param {Compiler.SvelteNode} node * @param {Compiler.AST.SvelteNode} node
* @param {{ is_child: boolean }} state * @param {{ is_child: boolean }} state
*/ */
function walk_children(node, state) { function walk_children(node, state) {
@ -389,7 +393,7 @@ function relative_selector_might_apply_to_node(relative_selector, rule, element)
// upwards and back-to-front, we need to first check the selectors inside :has(...), then check the rest of the // upwards and back-to-front, we need to first check the selectors inside :has(...), then check the rest of the
// selector in a way that is similar to ancestor matching. In a sense, we're treating `.x:has(.y)` as `.x .y`. // selector in a way that is similar to ancestor matching. In a sense, we're treating `.x:has(.y)` as `.x .y`.
for (const has_selector of has_selectors) { for (const has_selector of has_selectors) {
const complex_selectors = /** @type {Compiler.Css.SelectorList} */ (has_selector.args) const complex_selectors = /** @type {Compiler.AST.CSS.SelectorList} */ (has_selector.args)
.children; .children;
let matched = false; let matched = false;
@ -578,7 +582,7 @@ function relative_selector_might_apply_to_node(relative_selector, rule, element)
case 'NestingSelector': { case 'NestingSelector': {
let matched = false; let matched = false;
const parent = /** @type {Compiler.Css.Rule} */ (rule.metadata.parent_rule); const parent = /** @type {Compiler.AST.CSS.Rule} */ (rule.metadata.parent_rule);
for (const complex_selector of parent.prelude.children) { for (const complex_selector of parent.prelude.children) {
if ( if (
@ -611,9 +615,9 @@ function get_following_sibling_elements(element, include_self) {
const path = element.metadata.path; const path = element.metadata.path;
let i = path.length; let i = path.length;
/** @type {Compiler.SvelteNode} */ /** @type {Compiler.AST.SvelteNode} */
let start = element; let start = element;
let nodes = /** @type {Compiler.SvelteNode[]} */ ( let nodes = /** @type {Compiler.AST.SvelteNode[]} */ (
/** @type {Compiler.AST.Fragment} */ (path[0]).nodes /** @type {Compiler.AST.Fragment} */ (path[0]).nodes
); );
@ -639,7 +643,7 @@ function get_following_sibling_elements(element, include_self) {
const seen = new Set(); const seen = new Set();
/** @param {Compiler.SvelteNode} node */ /** @param {Compiler.AST.SvelteNode} node */
function get_siblings(node) { function get_siblings(node) {
walk(node, null, { walk(node, null, {
RegularElement(node) { RegularElement(node) {
@ -836,7 +840,7 @@ function get_possible_element_siblings(node, adjacent_only, seen = new Set()) {
const result = new Map(); const result = new Map();
const path = node.metadata.path; const path = node.metadata.path;
/** @type {Compiler.SvelteNode} */ /** @type {Compiler.AST.SvelteNode} */
let current = node; let current = node;
let i = path.length; let i = path.length;
@ -1008,7 +1012,7 @@ function higher_existence(exist1, exist2) {
} }
/** /**
* @param {Compiler.SvelteNode[]} children * @param {Compiler.AST.SvelteNode[]} children
* @param {boolean} adjacent_only * @param {boolean} adjacent_only
*/ */
function loop_child(children, adjacent_only) { function loop_child(children, adjacent_only) {
@ -1038,7 +1042,7 @@ function loop_child(children, adjacent_only) {
} }
/** /**
* @param {Compiler.SvelteNode} node * @param {Compiler.AST.SvelteNode} node
* @returns {node is Compiler.AST.IfBlock | Compiler.AST.EachBlock | Compiler.AST.AwaitBlock | Compiler.AST.KeyBlock | Compiler.AST.SlotElement} * @returns {node is Compiler.AST.IfBlock | Compiler.AST.EachBlock | Compiler.AST.AwaitBlock | Compiler.AST.KeyBlock | Compiler.AST.SlotElement}
*/ */
function is_block(node) { function is_block(node) {

8
packages/svelte/src/compiler/phases/2-analyze/css/css-warn.js
Unescape View File

@ -1,17 +1,17 @@
/** @import { Visitors } from 'zimmerframe' */ /** @import { Visitors } from 'zimmerframe' */
/** @import { Css } from '#compiler' */ /** @import { AST } from '#compiler' */
import { walk } from 'zimmerframe'; import { walk } from 'zimmerframe';
import * as w from '../../../warnings.js'; import * as w from '../../../warnings.js';
import { is_keyframes_node } from '../../css.js'; import { is_keyframes_node } from '../../css.js';
/** /**
* @param {Css.StyleSheet} stylesheet * @param {AST.CSS.StyleSheet} stylesheet
*/ */
export function warn_unused(stylesheet) { export function warn_unused(stylesheet) {
walk(stylesheet, { stylesheet }, visitors); walk(stylesheet, { stylesheet }, visitors);
} }
/** @type {Visitors<Css.Node, { stylesheet: Css.StyleSheet }>} */ /** @type {Visitors<AST.CSS.Node, { stylesheet: AST.CSS.StyleSheet }>} */
const visitors = { const visitors = {
Atrule(node, context) { Atrule(node, context) {
if (!is_keyframes_node(node)) { if (!is_keyframes_node(node)) {
@ -28,7 +28,7 @@ const visitors = {
!node.metadata.used && !node.metadata.used &&
// prevent double-marking of `.unused:is(.unused)` // prevent double-marking of `.unused:is(.unused)`
(context.path.at(-2)?.type !== 'PseudoClassSelector' || (context.path.at(-2)?.type !== 'PseudoClassSelector' ||
/** @type {Css.ComplexSelector} */ (context.path.at(-4))?.metadata.used) /** @type {AST.CSS.ComplexSelector} */ (context.path.at(-4))?.metadata.used)
) { ) {
const content = context.state.stylesheet.content; const content = context.state.stylesheet.content;
const text = content.styles.substring(node.start - content.start, node.end - content.start); const text = content.styles.substring(node.start - content.start, node.end - content.start);

14
packages/svelte/src/compiler/phases/2-analyze/css/utils.js
Unescape View File

@ -1,4 +1,4 @@
/** @import { AST, Css } from '#compiler' */ /** @import { AST } from '#compiler' */
/** @import { Node } from 'estree' */ /** @import { Node } from 'estree' */
const UNKNOWN = {}; const UNKNOWN = {};
@ -36,7 +36,7 @@ export function get_possible_values(chunk) {
/** /**
* Returns all parent rules; root is last * Returns all parent rules; root is last
* @param {Css.Rule | null} rule * @param {AST.CSS.Rule | null} rule
*/ */
export function get_parent_rules(rule) { export function get_parent_rules(rule) {
const rules = []; const rules = [];
@ -51,8 +51,8 @@ export function get_parent_rules(rule) {
/** /**
* True if is `:global(...)` or `:global` and no pseudo class that is scoped. * True if is `:global(...)` or `:global` and no pseudo class that is scoped.
* @param {Css.RelativeSelector} relative_selector * @param {AST.CSS.RelativeSelector} relative_selector
* @returns {relative_selector is Css.RelativeSelector & { selectors: [Css.PseudoClassSelector, ...Array<Css.PseudoClassSelector | Css.PseudoElementSelector>] }} * @returns {relative_selector is AST.CSS.RelativeSelector & { selectors: [AST.CSS.PseudoClassSelector, ...Array<AST.CSS.PseudoClassSelector | AST.CSS.PseudoElementSelector>] }}
*/ */
export function is_global(relative_selector) { export function is_global(relative_selector) {
const first = relative_selector.selectors[0]; const first = relative_selector.selectors[0];
@ -72,7 +72,7 @@ export function is_global(relative_selector) {
/** /**
* `true` if is a pseudo class that cannot be or is not scoped * `true` if is a pseudo class that cannot be or is not scoped
* @param {Css.SimpleSelector} selector * @param {AST.CSS.SimpleSelector} selector
*/ */
export function is_unscoped_pseudo_class(selector) { export function is_unscoped_pseudo_class(selector) {
return ( return (
@ -96,8 +96,8 @@ export function is_unscoped_pseudo_class(selector) {
/** /**
* True if is `:global(...)` or `:global`, irrespective of whether or not there are any pseudo classes that are scoped. * True if is `:global(...)` or `:global`, irrespective of whether or not there are any pseudo classes that are scoped.
* Difference to `is_global`: `:global(x):has(y)` is `true` for `is_outer_global` but `false` for `is_global`. * Difference to `is_global`: `:global(x):has(y)` is `true` for `is_outer_global` but `false` for `is_global`.
* @param {Css.RelativeSelector} relative_selector * @param {AST.CSS.RelativeSelector} relative_selector
* @returns {relative_selector is Css.RelativeSelector & { selectors: [Css.PseudoClassSelector, ...Array<Css.PseudoClassSelector | Css.PseudoElementSelector>] }} * @returns {relative_selector is AST.CSS.RelativeSelector & { selectors: [AST.CSS.PseudoClassSelector, ...Array<AST.CSS.PseudoClassSelector | AST.CSS.PseudoElementSelector>] }}
*/ */
export function is_outer_global(relative_selector) { export function is_outer_global(relative_selector) {
const first = relative_selector.selectors[0]; const first = relative_selector.selectors[0];

8
packages/svelte/src/compiler/phases/2-analyze/index.js
Unescape View File

@ -1,5 +1,5 @@
/** @import { Expression, Node, Program } from 'estree' */ /** @import { Expression, Node, Program } from 'estree' */
/** @import { Binding, AST, SvelteNode, ValidatedCompileOptions, ValidatedModuleCompileOptions } from '#compiler' */ /** @import { Binding, AST, ValidatedCompileOptions, ValidatedModuleCompileOptions } from '#compiler' */
/** @import { AnalysisState, Visitors } from './types' */ /** @import { AnalysisState, Visitors } from './types' */
/** @import { Analysis, ComponentAnalysis, Js, ReactiveStatement, Template } from '../types' */ /** @import { Analysis, ComponentAnalysis, Js, ReactiveStatement, Template } from '../types' */
import { walk } from 'zimmerframe'; import { walk } from 'zimmerframe';
@ -525,7 +525,7 @@ export function analyze_component(root, source, options) {
// more legacy nonsense: if an `each` binding is reassigned/mutated, // more legacy nonsense: if an `each` binding is reassigned/mutated,
// treat the expression as being mutated as well // treat the expression as being mutated as well
walk(/** @type {SvelteNode} */ (template.ast), null, { walk(/** @type {AST.SvelteNode} */ (template.ast), null, {
EachBlock(node) { EachBlock(node) {
const scope = /** @type {Scope} */ (template.scopes.get(node)); const scope = /** @type {Scope} */ (template.scopes.get(node));
@ -608,7 +608,7 @@ export function analyze_component(root, source, options) {
reactive_statements: new Map() reactive_statements: new Map()
}; };
walk(/** @type {SvelteNode} */ (ast), state, visitors); walk(/** @type {AST.SvelteNode} */ (ast), state, visitors);
} }
// warn on any nonstate declarations that are a) reassigned and b) referenced in the template // warn on any nonstate declarations that are a) reassigned and b) referenced in the template
@ -677,7 +677,7 @@ export function analyze_component(root, source, options) {
function_depth: scope.function_depth function_depth: scope.function_depth
}; };
walk(/** @type {SvelteNode} */ (ast), state, visitors); walk(/** @type {AST.SvelteNode} */ (ast), state, visitors);
} }
for (const [name, binding] of instance.scope.declarations) { for (const [name, binding] of instance.scope.declarations) {

8
packages/svelte/src/compiler/phases/2-analyze/types.d.ts vendored
Unescape View File

@ -1,11 +1,11 @@
import type { Scope } from '../scope.js'; import type { Scope } from '../scope.js';
import type { ComponentAnalysis, ReactiveStatement } from '../types.js'; import type { ComponentAnalysis, ReactiveStatement } from '../types.js';
import type { ExpressionMetadata, AST, ValidatedCompileOptions, SvelteNode } from '#compiler'; import type { AST, ExpressionMetadata, ValidatedCompileOptions } from '#compiler';
import type { LabeledStatement } from 'estree'; import type { LabeledStatement } from 'estree';
export interface AnalysisState { export interface AnalysisState {
scope: Scope; scope: Scope;
scopes: Map<SvelteNode, Scope>; scopes: Map<AST.SvelteNode, Scope>;
analysis: ComponentAnalysis; analysis: ComponentAnalysis;
options: ValidatedCompileOptions; options: ValidatedCompileOptions;
ast_type: 'instance' | 'template' | 'module'; ast_type: 'instance' | 'template' | 'module';
@ -31,11 +31,11 @@ export interface AnalysisState {
} }
export type Context<State extends AnalysisState = AnalysisState> = import('zimmerframe').Context< export type Context<State extends AnalysisState = AnalysisState> = import('zimmerframe').Context<
SvelteNode, AST.SvelteNode,
State State
>; >;
export type Visitors<State extends AnalysisState = AnalysisState> = import('zimmerframe').Visitors< export type Visitors<State extends AnalysisState = AnalysisState> = import('zimmerframe').Visitors<
SvelteNode, AST.SvelteNode,
State State
>; >;

1
packages/svelte/src/compiler/phases/2-analyze/visitors/AssignmentExpression.js
Unescape View File

@ -1,5 +1,4 @@
/** @import { AssignmentExpression } from 'estree' */ /** @import { AssignmentExpression } from 'estree' */
/** @import { SvelteNode } from '#compiler' */
/** @import { Context } from '../types' */ /** @import { Context } from '../types' */
import { extract_identifiers, object } from '../../../utils/ast.js'; import { extract_identifiers, object } from '../../../utils/ast.js';
import { validate_assignment } from './shared/utils.js'; import { validate_assignment } from './shared/utils.js';

4
packages/svelte/src/compiler/phases/2-analyze/visitors/Attribute.js
Unescape View File

@ -1,5 +1,5 @@
/** @import { ArrowFunctionExpression, Expression, FunctionDeclaration, FunctionExpression } from 'estree' */ /** @import { ArrowFunctionExpression, Expression, FunctionDeclaration, FunctionExpression } from 'estree' */
/** @import { AST, DelegatedEvent, SvelteNode } from '#compiler' */ /** @import { AST, DelegatedEvent } from '#compiler' */
/** @import { Context } from '../types' */ /** @import { Context } from '../types' */
import { cannot_be_set_statically, is_capture_event, is_delegated } from '../../../../utils.js'; import { cannot_be_set_statically, is_capture_event, is_delegated } from '../../../../utils.js';
import { import {
@ -16,7 +16,7 @@ import { mark_subtree_dynamic } from './shared/fragment.js';
export function Attribute(node, context) { export function Attribute(node, context) {
context.next(); context.next();
const parent = /** @type {SvelteNode} */ (context.path.at(-1)); const parent = /** @type {AST.SvelteNode} */ (context.path.at(-1));
if (parent.type === 'RegularElement') { if (parent.type === 'RegularElement') {
// special case <option value="" /> // special case <option value="" />

4
packages/svelte/src/compiler/phases/2-analyze/visitors/CallExpression.js
Unescape View File

@ -1,5 +1,5 @@
/** @import { CallExpression, VariableDeclarator } from 'estree' */ /** @import { CallExpression, VariableDeclarator } from 'estree' */
/** @import { AST, SvelteNode } from '#compiler' */ /** @import { AST } from '#compiler' */
/** @import { Context } from '../types' */ /** @import { Context } from '../types' */
import { get_rune } from '../../scope.js'; import { get_rune } from '../../scope.js';
import * as e from '../../../errors.js'; import * as e from '../../../errors.js';
@ -12,7 +12,7 @@ import { mark_subtree_dynamic } from './shared/fragment.js';
* @param {Context} context * @param {Context} context
*/ */
export function CallExpression(node, context) { export function CallExpression(node, context) {
const parent = /** @type {SvelteNode} */ (get_parent(context.path, -1)); const parent = /** @type {AST.SvelteNode} */ (get_parent(context.path, -1));
const rune = get_rune(node, context.state.scope); const rune = get_rune(node, context.state.scope);

4
packages/svelte/src/compiler/phases/2-analyze/visitors/LabeledStatement.js
Unescape View File

@ -1,5 +1,5 @@
/** @import { Expression, LabeledStatement } from 'estree' */ /** @import { Expression, LabeledStatement } from 'estree' */
/** @import { AST, ReactiveStatement, SvelteNode } from '#compiler' */ /** @import { AST, ReactiveStatement } from '#compiler' */
/** @import { Context } from '../types' */ /** @import { Context } from '../types' */
import * as e from '../../../errors.js'; import * as e from '../../../errors.js';
import { extract_identifiers, object } from '../../../utils/ast.js'; import { extract_identifiers, object } from '../../../utils/ast.js';
@ -11,7 +11,7 @@ import * as w from '../../../warnings.js';
*/ */
export function LabeledStatement(node, context) { export function LabeledStatement(node, context) {
if (node.label.name === '$') { if (node.label.name === '$') {
const parent = /** @type {SvelteNode} */ (context.path.at(-1)); const parent = /** @type {AST.SvelteNode} */ (context.path.at(-1));
const is_reactive_statement = const is_reactive_statement =
context.state.ast_type === 'instance' && parent.type === 'Program'; context.state.ast_type === 'instance' && parent.type === 'Program';

4
packages/svelte/src/compiler/phases/2-analyze/visitors/SnippetBlock.js
Unescape View File

@ -1,4 +1,4 @@
/** @import { AST, Binding, SvelteNode } from '#compiler' */ /** @import { AST, Binding } from '#compiler' */
/** @import { Scope } from '../../scope' */ /** @import { Scope } from '../../scope' */
/** @import { Context } from '../types' */ /** @import { Context } from '../types' */
import { validate_block_not_empty, validate_opening_tag } from './shared/utils.js'; import { validate_block_not_empty, validate_opening_tag } from './shared/utils.js';
@ -80,7 +80,7 @@ export function SnippetBlock(node, context) {
} }
/** /**
* @param {Map<SvelteNode, Scope>} scopes * @param {Map<AST.SvelteNode, Scope>} scopes
* @param {Scope} scope * @param {Scope} scope
*/ */
function can_hoist_snippet(scope, scopes, visited = new Set()) { function can_hoist_snippet(scope, scopes, visited = new Set()) {

6
packages/svelte/src/compiler/phases/2-analyze/visitors/shared/a11y.js
Unescape View File

@ -1,5 +1,5 @@
/** @import { Context } from '../../types.js' */ /** @import { Context } from '../../types.js' */
/** @import { AST, SvelteNode, TemplateNode } from '#compiler' */ /** @import { AST } from '#compiler' */
/** @import { ARIARoleDefinitionKey, ARIARoleRelationConcept, ARIAProperty, ARIAPropertyDefinition, ARIARoleDefinition } from 'aria-query' */ /** @import { ARIARoleDefinitionKey, ARIARoleRelationConcept, ARIAProperty, ARIAPropertyDefinition, ARIARoleDefinition } from 'aria-query' */
import { roles as roles_map, aria, elementRoles } from 'aria-query'; import { roles as roles_map, aria, elementRoles } from 'aria-query';
// @ts-expect-error package doesn't provide typings // @ts-expect-error package doesn't provide typings
@ -582,7 +582,7 @@ function get_implicit_role(name, attribute_map) {
const invisible_elements = ['meta', 'html', 'script', 'style']; const invisible_elements = ['meta', 'html', 'script', 'style'];
/** /**
* @param {SvelteNode[]} path * @param {AST.SvelteNode[]} path
* @param {string[]} elements * @param {string[]} elements
*/ */
function is_parent(path, elements) { function is_parent(path, elements) {
@ -1062,7 +1062,7 @@ export function check_element(node, context) {
} }
if (node.name === 'label') { if (node.name === 'label') {
/** @param {TemplateNode} node */ /** @param {AST.TemplateNode} node */
const has_input_child = (node) => { const has_input_child = (node) => {
let has = false; let has = false;
walk( walk(

4
packages/svelte/src/compiler/phases/2-analyze/visitors/shared/attribute.js
Unescape View File

@ -1,4 +1,4 @@
/** @import { AST, ElementLike } from '#compiler' */ /** @import { AST } from '#compiler' */
/** @import { Context } from '../../types' */ /** @import { Context } from '../../types' */
import * as e from '../../../../errors.js'; import * as e from '../../../../errors.js';
import { is_text_attribute } from '../../../../utils/ast.js'; import { is_text_attribute } from '../../../../utils/ast.js';
@ -22,7 +22,7 @@ export function validate_attribute_name(attribute) {
/** /**
* @param {AST.Attribute} attribute * @param {AST.Attribute} attribute
* @param {ElementLike} parent * @param {AST.ElementLike} parent
*/ */
export function validate_attribute(attribute, parent) { export function validate_attribute(attribute, parent) {
if ( if (

4
packages/svelte/src/compiler/phases/2-analyze/visitors/shared/fragment.js
Unescape View File

@ -1,7 +1,7 @@
/** @import { AST, SvelteNode } from '#compiler' */ /** @import { AST } from '#compiler' */
/** /**
* @param {SvelteNode[]} path * @param {AST.SvelteNode[]} path
*/ */
export function mark_subtree_dynamic(path) { export function mark_subtree_dynamic(path) {
let i = path.length; let i = path.length;

10
packages/svelte/src/compiler/phases/3-transform/client/transform-client.js
Unescape View File

@ -1,5 +1,5 @@
/** @import * as ESTree from 'estree' */ /** @import * as ESTree from 'estree' */
/** @import { ValidatedCompileOptions, AST, ValidatedModuleCompileOptions, SvelteNode } from '#compiler' */ /** @import { AST, ValidatedCompileOptions, ValidatedModuleCompileOptions } from '#compiler' */
/** @import { ComponentAnalysis, Analysis } from '../../types' */ /** @import { ComponentAnalysis, Analysis } from '../../types' */
/** @import { Visitors, ComponentClientTransformState, ClientTransformState } from './types' */ /** @import { Visitors, ComponentClientTransformState, ClientTransformState } from './types' */
import { walk } from 'zimmerframe'; import { walk } from 'zimmerframe';
@ -178,7 +178,7 @@ export function client_component(analysis, options) {
}; };
const module = /** @type {ESTree.Program} */ ( const module = /** @type {ESTree.Program} */ (
walk(/** @type {SvelteNode} */ (analysis.module.ast), state, visitors) walk(/** @type {AST.SvelteNode} */ (analysis.module.ast), state, visitors)
); );
const instance_state = { const instance_state = {
@ -190,12 +190,12 @@ export function client_component(analysis, options) {
}; };
const instance = /** @type {ESTree.Program} */ ( const instance = /** @type {ESTree.Program} */ (
walk(/** @type {SvelteNode} */ (analysis.instance.ast), instance_state, visitors) walk(/** @type {AST.SvelteNode} */ (analysis.instance.ast), instance_state, visitors)
); );
const template = /** @type {ESTree.Program} */ ( const template = /** @type {ESTree.Program} */ (
walk( walk(
/** @type {SvelteNode} */ (analysis.template.ast), /** @type {AST.SvelteNode} */ (analysis.template.ast),
{ {
...state, ...state,
transform: instance_state.transform, transform: instance_state.transform,
@ -664,7 +664,7 @@ export function client_module(analysis, options) {
}; };
const module = /** @type {ESTree.Program} */ ( const module = /** @type {ESTree.Program} */ (
walk(/** @type {SvelteNode} */ (analysis.module.ast), state, visitors) walk(/** @type {AST.SvelteNode} */ (analysis.module.ast), state, visitors)
); );
return { return {

10
packages/svelte/src/compiler/phases/3-transform/client/types.d.ts vendored
Unescape View File

@ -9,7 +9,7 @@ import type {
UpdateExpression, UpdateExpression,
VariableDeclaration VariableDeclaration
} from 'estree'; } from 'estree';
import type { Namespace, SvelteNode, ValidatedCompileOptions } from '#compiler'; import type { AST, Namespace, ValidatedCompileOptions } from '#compiler';
import type { TransformState } from '../types.js'; import type { TransformState } from '../types.js';
import type { ComponentAnalysis } from '../../types.js'; import type { ComponentAnalysis } from '../../types.js';
import type { SourceLocation } from '#shared'; import type { SourceLocation } from '#shared';
@ -98,14 +98,14 @@ export interface StateField {
id: PrivateIdentifier; id: PrivateIdentifier;
} }
export type Context = import('zimmerframe').Context<SvelteNode, ClientTransformState>; export type Context = import('zimmerframe').Context<AST.SvelteNode, ClientTransformState>;
export type Visitors = import('zimmerframe').Visitors<SvelteNode, any>; export type Visitors = import('zimmerframe').Visitors<AST.SvelteNode, any>;
export type ComponentContext = import('zimmerframe').Context< export type ComponentContext = import('zimmerframe').Context<
SvelteNode, AST.SvelteNode,
ComponentClientTransformState ComponentClientTransformState
>; >;
export type ComponentVisitors = import('zimmerframe').Visitors< export type ComponentVisitors = import('zimmerframe').Visitors<
SvelteNode, AST.SvelteNode,
ComponentClientTransformState ComponentClientTransformState
>; >;

4
packages/svelte/src/compiler/phases/3-transform/client/utils.js
Unescape View File

@ -1,5 +1,5 @@
/** @import { ArrowFunctionExpression, Expression, FunctionDeclaration, FunctionExpression, Identifier, Pattern, PrivateIdentifier, Statement } from 'estree' */ /** @import { ArrowFunctionExpression, Expression, FunctionDeclaration, FunctionExpression, Identifier, Pattern, PrivateIdentifier, Statement } from 'estree' */
/** @import { Binding, SvelteNode } from '#compiler' */ /** @import { AST, Binding } from '#compiler' */
/** @import { ClientTransformState, ComponentClientTransformState, ComponentContext } from './types.js' */ /** @import { ClientTransformState, ComponentClientTransformState, ComponentContext } from './types.js' */
/** @import { Analysis } from '../../types.js' */ /** @import { Analysis } from '../../types.js' */
/** @import { Scope } from '../../scope.js' */ /** @import { Scope } from '../../scope.js' */
@ -271,7 +271,7 @@ export function should_proxy(node, scope) {
/** /**
* @param {Pattern} node * @param {Pattern} node
* @param {import('zimmerframe').Context<SvelteNode, ComponentClientTransformState>} context * @param {import('zimmerframe').Context<AST.SvelteNode, ComponentClientTransformState>} context
* @returns {{ id: Pattern, declarations: null | Statement[] }} * @returns {{ id: Pattern, declarations: null | Statement[] }}
*/ */
export function create_derived_block_argument(node, context) { export function create_derived_block_argument(node, context) {

6
packages/svelte/src/compiler/phases/3-transform/client/visitors/BindDirective.js
Unescape View File

@ -1,5 +1,5 @@
/** @import { CallExpression, Expression, MemberExpression, Pattern } from 'estree' */ /** @import { CallExpression, Expression, Pattern } from 'estree' */
/** @import { AST, SvelteNode } from '#compiler' */ /** @import { AST } from '#compiler' */
/** @import { ComponentContext } from '../types' */ /** @import { ComponentContext } from '../types' */
import { dev, is_ignored } from '../../../../state.js'; import { dev, is_ignored } from '../../../../state.js';
import { is_text_attribute } from '../../../../utils/ast.js'; import { is_text_attribute } from '../../../../utils/ast.js';
@ -16,7 +16,7 @@ export function BindDirective(node, context) {
const expression = /** @type {Expression} */ (context.visit(node.expression)); const expression = /** @type {Expression} */ (context.visit(node.expression));
const property = binding_properties[node.name]; const property = binding_properties[node.name];
const parent = /** @type {SvelteNode} */ (context.path.at(-1)); const parent = /** @type {AST.SvelteNode} */ (context.path.at(-1));
let get, set; let get, set;

4
packages/svelte/src/compiler/phases/3-transform/client/visitors/shared/component.js
Unescape View File

@ -1,5 +1,5 @@
/** @import { BlockStatement, Expression, ExpressionStatement, Identifier, MemberExpression, Pattern, Property, SequenceExpression, Statement } from 'estree' */ /** @import { BlockStatement, Expression, ExpressionStatement, Identifier, MemberExpression, Pattern, Property, SequenceExpression, Statement } from 'estree' */
/** @import { AST, TemplateNode } from '#compiler' */ /** @import { AST } from '#compiler' */
/** @import { ComponentContext } from '../../types.js' */ /** @import { ComponentContext } from '../../types.js' */
import { dev, is_ignored } from '../../../../../state.js'; import { dev, is_ignored } from '../../../../../state.js';
import { get_attribute_chunks, object } from '../../../../../utils/ast.js'; import { get_attribute_chunks, object } from '../../../../../utils/ast.js';
@ -35,7 +35,7 @@ export function build_component(node, component_name, context, anchor = context.
} }
}; };
/** @type {Record<string, TemplateNode[]>} */ /** @type {Record<string, AST.TemplateNode[]>} */
const children = {}; const children = {};
/** @type {Record<string, Expression[]>} */ /** @type {Record<string, Expression[]>} */

4
packages/svelte/src/compiler/phases/3-transform/client/visitors/shared/events.js
Unescape View File

@ -1,5 +1,5 @@
/** @import { Expression } from 'estree' */ /** @import { Expression } from 'estree' */
/** @import { AST, ExpressionMetadata, SvelteNode } from '#compiler' */ /** @import { AST, ExpressionMetadata } from '#compiler' */
/** @import { ComponentContext } from '../../types' */ /** @import { ComponentContext } from '../../types' */
import { is_capture_event, is_passive_event } from '../../../../../../utils.js'; import { is_capture_event, is_passive_event } from '../../../../../../utils.js';
import { dev, locator } from '../../../../../state.js'; import { dev, locator } from '../../../../../state.js';
@ -68,7 +68,7 @@ export function visit_event_attribute(node, context) {
) )
); );
const type = /** @type {SvelteNode} */ (context.path.at(-1)).type; const type = /** @type {AST.SvelteNode} */ (context.path.at(-1)).type;
if (type === 'SvelteDocument' || type === 'SvelteWindow' || type === 'SvelteBody') { if (type === 'SvelteDocument' || type === 'SvelteWindow' || type === 'SvelteBody') {
// These nodes are above the component tree, and its events should run parent first // These nodes are above the component tree, and its events should run parent first

6
packages/svelte/src/compiler/phases/3-transform/client/visitors/shared/fragment.js
Unescape View File

@ -1,5 +1,5 @@
/** @import { Expression } from 'estree' */ /** @import { Expression } from 'estree' */
/** @import { AST, SvelteNode } from '#compiler' */ /** @import { AST } from '#compiler' */
/** @import { ComponentContext } from '../../types' */ /** @import { ComponentContext } from '../../types' */
import { cannot_be_set_statically } from '../../../../../../utils.js'; import { cannot_be_set_statically } from '../../../../../../utils.js';
import { is_event_attribute, is_text_attribute } from '../../../../../utils/ast.js'; import { is_event_attribute, is_text_attribute } from '../../../../../utils/ast.js';
@ -10,7 +10,7 @@ import { build_template_chunk, build_update } from './utils.js';
* Processes an array of template nodes, joining sibling text/expression nodes * Processes an array of template nodes, joining sibling text/expression nodes
* (e.g. `{a} b {c}`) into a single update function. Along the way it creates * (e.g. `{a} b {c}`) into a single update function. Along the way it creates
* corresponding template node references these updates are applied to. * corresponding template node references these updates are applied to.
* @param {SvelteNode[]} nodes * @param {AST.SvelteNode[]} nodes
* @param {(is_text: boolean) => Expression} initial * @param {(is_text: boolean) => Expression} initial
* @param {boolean} is_element * @param {boolean} is_element
* @param {ComponentContext} context * @param {ComponentContext} context
@ -124,7 +124,7 @@ export function process_children(nodes, initial, is_element, { visit, state }) {
} }
/** /**
* @param {SvelteNode} node * @param {AST.SvelteNode} node
* @param {ComponentContext["state"]} state * @param {ComponentContext["state"]} state
*/ */
function is_static_element(node, state) { function is_static_element(node, state) {

6
packages/svelte/src/compiler/phases/3-transform/client/visitors/shared/utils.js
Unescape View File

@ -1,5 +1,5 @@
/** @import { Expression, ExpressionStatement, Identifier, MemberExpression, SequenceExpression, Statement, Super } from 'estree' */ /** @import { Expression, ExpressionStatement, Identifier, MemberExpression, SequenceExpression, Statement, Super } from 'estree' */
/** @import { AST, SvelteNode } from '#compiler' */ /** @import { AST } from '#compiler' */
/** @import { ComponentClientTransformState } from '../../types' */ /** @import { ComponentClientTransformState } from '../../types' */
import { walk } from 'zimmerframe'; import { walk } from 'zimmerframe';
import { object } from '../../../../../utils/ast.js'; import { object } from '../../../../../utils/ast.js';
@ -12,7 +12,7 @@ import { locator } from '../../../../../state.js';
/** /**
* @param {Array<AST.Text | AST.ExpressionTag>} values * @param {Array<AST.Text | AST.ExpressionTag>} values
* @param {(node: SvelteNode, state: any) => any} visit * @param {(node: AST.SvelteNode, state: any) => any} visit
* @param {ComponentClientTransformState} state * @param {ComponentClientTransformState} state
* @returns {{ value: Expression, has_state: boolean, has_call: boolean }} * @returns {{ value: Expression, has_state: boolean, has_call: boolean }}
*/ */
@ -145,7 +145,7 @@ export function build_update_assignment(state, id, init, value, update) {
* Serializes `bind:this` for components and elements. * Serializes `bind:this` for components and elements.
* @param {Identifier | MemberExpression | SequenceExpression} expression * @param {Identifier | MemberExpression | SequenceExpression} expression
* @param {Expression} value * @param {Expression} value
* @param {import('zimmerframe').Context<SvelteNode, ComponentClientTransformState>} context * @param {import('zimmerframe').Context<AST.SvelteNode, ComponentClientTransformState>} context
*/ */
export function build_bind_this(expression, value, { state, visit }) { export function build_bind_this(expression, value, { state, visit }) {
if (expression.type === 'SequenceExpression') { if (expression.type === 'SequenceExpression') {

24
packages/svelte/src/compiler/phases/3-transform/css/index.js
Unescape View File

@ -1,5 +1,5 @@
/** @import { Visitors } from 'zimmerframe' */ /** @import { Visitors } from 'zimmerframe' */
/** @import { ValidatedCompileOptions, Css } from '#compiler' */ /** @import { AST, ValidatedCompileOptions } from '#compiler' */
/** @import { ComponentAnalysis } from '../../types.js' */ /** @import { ComponentAnalysis } from '../../types.js' */
import MagicString from 'magic-string'; import MagicString from 'magic-string';
import { walk } from 'zimmerframe'; import { walk } from 'zimmerframe';
@ -41,9 +41,9 @@ export function render_stylesheet(source, analysis, options) {
} }
}; };
const ast = /** @type {Css.StyleSheet} */ (analysis.css.ast); const ast = /** @type {AST.CSS.StyleSheet} */ (analysis.css.ast);
walk(/** @type {Css.Node} */ (ast), state, visitors); walk(/** @type {AST.CSS.Node} */ (ast), state, visitors);
code.remove(0, ast.content.start); code.remove(0, ast.content.start);
code.remove(/** @type {number} */ (ast.content.end), source.length); code.remove(/** @type {number} */ (ast.content.end), source.length);
@ -71,7 +71,7 @@ export function render_stylesheet(source, analysis, options) {
return css; return css;
} }
/** @type {Visitors<Css.Node, State>} */ /** @type {Visitors<AST.CSS.Node, State>} */
const visitors = { const visitors = {
_: (node, context) => { _: (node, context) => {
context.state.code.addSourcemapLocation(node.start); context.state.code.addSourcemapLocation(node.start);
@ -259,7 +259,7 @@ const visitors = {
if (parent?.type === 'Rule') { if (parent?.type === 'Rule') {
specificity = { bumped: false }; specificity = { bumped: false };
/** @type {Css.Rule | null} */ /** @type {AST.CSS.Rule | null} */
let rule = parent.metadata.parent_rule; let rule = parent.metadata.parent_rule;
while (rule) { while (rule) {
@ -278,7 +278,7 @@ const visitors = {
for (const relative_selector of node.children) { for (const relative_selector of node.children) {
if (relative_selector.metadata.is_global) { if (relative_selector.metadata.is_global) {
const global = /** @type {Css.PseudoClassSelector} */ (relative_selector.selectors[0]); const global = /** @type {AST.CSS.PseudoClassSelector} */ (relative_selector.selectors[0]);
remove_global_pseudo_class(global, relative_selector.combinator, context.state); remove_global_pseudo_class(global, relative_selector.combinator, context.state);
if ( if (
@ -361,15 +361,15 @@ const visitors = {
/** /**
* *
* @param {Array<Css.Node>} path * @param {Array<AST.CSS.Node>} path
*/ */
function is_in_global_block(path) { function is_in_global_block(path) {
return path.some((node) => node.type === 'Rule' && node.metadata.is_global_block); return path.some((node) => node.type === 'Rule' && node.metadata.is_global_block);
} }
/** /**
* @param {Css.PseudoClassSelector} selector * @param {AST.CSS.PseudoClassSelector} selector
* @param {Css.Combinator | null} combinator * @param {AST.CSS.Combinator | null} combinator
* @param {State} state * @param {State} state
*/ */
function remove_global_pseudo_class(selector, combinator, state) { function remove_global_pseudo_class(selector, combinator, state) {
@ -399,7 +399,7 @@ function remove_preceding_whitespace(end, state) {
} }
/** /**
* @param {Css.Rule} rule * @param {AST.CSS.Rule} rule
* @param {boolean} is_in_global_block * @param {boolean} is_in_global_block
*/ */
function is_empty(rule, is_in_global_block) { function is_empty(rule, is_in_global_block) {
@ -426,14 +426,14 @@ function is_empty(rule, is_in_global_block) {
return true; return true;
} }
/** @param {Css.Rule} rule */ /** @param {AST.CSS.Rule} rule */
function is_used(rule) { function is_used(rule) {
return rule.prelude.children.some((selector) => selector.metadata.used); return rule.prelude.children.some((selector) => selector.metadata.used);
} }
/** /**
* *
* @param {Css.Rule} node * @param {AST.CSS.Rule} node
* @param {MagicString} code * @param {MagicString} code
*/ */
function escape_comment_close(node, code) { function escape_comment_close(node, code) {

10
packages/svelte/src/compiler/phases/3-transform/server/transform-server.js
Unescape View File

@ -1,5 +1,5 @@
/** @import { Program, Property, Statement, VariableDeclarator } from 'estree' */ /** @import { Program, Property, Statement, VariableDeclarator } from 'estree' */
/** @import { SvelteNode, ValidatedCompileOptions, ValidatedModuleCompileOptions } from '#compiler' */ /** @import { AST, ValidatedCompileOptions, ValidatedModuleCompileOptions } from '#compiler' */
/** @import { ComponentServerTransformState, ComponentVisitors, ServerTransformState, Visitors } from './types.js' */ /** @import { ComponentServerTransformState, ComponentVisitors, ServerTransformState, Visitors } from './types.js' */
/** @import { Analysis, ComponentAnalysis } from '../../types.js' */ /** @import { Analysis, ComponentAnalysis } from '../../types.js' */
import { walk } from 'zimmerframe'; import { walk } from 'zimmerframe';
@ -104,12 +104,12 @@ export function server_component(analysis, options) {
}; };
const module = /** @type {Program} */ ( const module = /** @type {Program} */ (
walk(/** @type {SvelteNode} */ (analysis.module.ast), state, global_visitors) walk(/** @type {AST.SvelteNode} */ (analysis.module.ast), state, global_visitors)
); );
const instance = /** @type {Program} */ ( const instance = /** @type {Program} */ (
walk( walk(
/** @type {SvelteNode} */ (analysis.instance.ast), /** @type {AST.SvelteNode} */ (analysis.instance.ast),
{ ...state, scopes: analysis.instance.scopes }, { ...state, scopes: analysis.instance.scopes },
{ {
...global_visitors, ...global_visitors,
@ -130,7 +130,7 @@ export function server_component(analysis, options) {
const template = /** @type {Program} */ ( const template = /** @type {Program} */ (
walk( walk(
/** @type {SvelteNode} */ (analysis.template.ast), /** @type {AST.SvelteNode} */ (analysis.template.ast),
{ ...state, scopes: analysis.template.scopes }, { ...state, scopes: analysis.template.scopes },
// @ts-expect-error don't know, don't care // @ts-expect-error don't know, don't care
{ ...global_visitors, ...template_visitors } { ...global_visitors, ...template_visitors }
@ -394,7 +394,7 @@ export function server_module(analysis, options) {
}; };
const module = /** @type {Program} */ ( const module = /** @type {Program} */ (
walk(/** @type {SvelteNode} */ (analysis.module.ast), state, global_visitors) walk(/** @type {AST.SvelteNode} */ (analysis.module.ast), state, global_visitors)
); );
return { return {

10
packages/svelte/src/compiler/phases/3-transform/server/types.d.ts vendored
Unescape View File

@ -1,5 +1,5 @@
import type { Expression, Statement, ModuleDeclaration, LabeledStatement } from 'estree'; import type { Expression, Statement, ModuleDeclaration, LabeledStatement } from 'estree';
import type { Namespace, SvelteNode, ValidatedCompileOptions } from '#compiler'; import type { AST, Namespace, ValidatedCompileOptions } from '#compiler';
import type { TransformState } from '../types.js'; import type { TransformState } from '../types.js';
import type { ComponentAnalysis } from '../../types.js'; import type { ComponentAnalysis } from '../../types.js';
import type { StateField } from '../client/types.js'; import type { StateField } from '../client/types.js';
@ -25,14 +25,14 @@ export interface ComponentServerTransformState extends ServerTransformState {
readonly skip_hydration_boundaries: boolean; readonly skip_hydration_boundaries: boolean;
} }
export type Context = import('zimmerframe').Context<SvelteNode, ServerTransformState>; export type Context = import('zimmerframe').Context<AST.SvelteNode, ServerTransformState>;
export type Visitors = import('zimmerframe').Visitors<SvelteNode, ServerTransformState>; export type Visitors = import('zimmerframe').Visitors<AST.SvelteNode, ServerTransformState>;
export type ComponentContext = import('zimmerframe').Context< export type ComponentContext = import('zimmerframe').Context<
SvelteNode, AST.SvelteNode,
ComponentServerTransformState ComponentServerTransformState
>; >;
export type ComponentVisitors = import('zimmerframe').Visitors< export type ComponentVisitors = import('zimmerframe').Visitors<
SvelteNode, AST.SvelteNode,
ComponentServerTransformState ComponentServerTransformState
>; >;

4
packages/svelte/src/compiler/phases/3-transform/server/visitors/AssignmentExpression.js
Unescape View File

@ -1,5 +1,5 @@
/** @import { AssignmentExpression, AssignmentOperator, Expression, Pattern } from 'estree' */ /** @import { AssignmentExpression, AssignmentOperator, Expression, Pattern } from 'estree' */
/** @import { SvelteNode } from '#compiler' */ /** @import { AST } from '#compiler' */
/** @import { Context, ServerTransformState } from '../types.js' */ /** @import { Context, ServerTransformState } from '../types.js' */
import * as b from '../../../../utils/builders.js'; import * as b from '../../../../utils/builders.js';
import { build_assignment_value } from '../../../../utils/ast.js'; import { build_assignment_value } from '../../../../utils/ast.js';
@ -18,7 +18,7 @@ export function AssignmentExpression(node, context) {
* @param {AssignmentOperator} operator * @param {AssignmentOperator} operator
* @param {Pattern} left * @param {Pattern} left
* @param {Expression} right * @param {Expression} right
* @param {import('zimmerframe').Context<SvelteNode, ServerTransformState>} context * @param {import('zimmerframe').Context<AST.SvelteNode, ServerTransformState>} context
* @returns {Expression | null} * @returns {Expression | null}
*/ */
function build_assignment(operator, left, right, context) { function build_assignment(operator, left, right, context) {

4
packages/svelte/src/compiler/phases/3-transform/server/visitors/shared/component.js
Unescape View File

@ -1,5 +1,5 @@
/** @import { BlockStatement, Expression, Pattern, Property, SequenceExpression, Statement } from 'estree' */ /** @import { BlockStatement, Expression, Pattern, Property, SequenceExpression, Statement } from 'estree' */
/** @import { AST, TemplateNode } from '#compiler' */ /** @import { AST } from '#compiler' */
/** @import { ComponentContext } from '../../types.js' */ /** @import { ComponentContext } from '../../types.js' */
import { empty_comment, build_attribute_value } from './utils.js'; import { empty_comment, build_attribute_value } from './utils.js';
import * as b from '../../../../../utils/builders.js'; import * as b from '../../../../../utils/builders.js';
@ -31,7 +31,7 @@ export function build_inline_component(node, expression, context) {
scope: node.metadata.scopes.default scope: node.metadata.scopes.default
}; };
/** @type {Record<string, TemplateNode[]>} */ /** @type {Record<string, AST.TemplateNode[]>} */
const children = {}; const children = {};
/** /**

4
packages/svelte/src/compiler/phases/3-transform/server/visitors/shared/element.js
Unescape View File

@ -1,5 +1,5 @@
/** @import { Expression, Literal } from 'estree' */ /** @import { Expression, Literal } from 'estree' */
/** @import { AST, Namespace, SvelteNode } from '#compiler' */ /** @import { AST, Namespace } from '#compiler' */
/** @import { ComponentContext, ComponentServerTransformState } from '../../types.js' */ /** @import { ComponentContext, ComponentServerTransformState } from '../../types.js' */
import { import {
get_attribute_chunks, get_attribute_chunks,
@ -31,7 +31,7 @@ const WHITESPACE_INSENSITIVE_ATTRIBUTES = ['class', 'style'];
* Writes the output to the template output. Some elements may have attributes on them that require the * Writes the output to the template output. Some elements may have attributes on them that require the
* their output to be the child content instead. In this case, an object is returned. * their output to be the child content instead. In this case, an object is returned.
* @param {AST.RegularElement | AST.SvelteElement} node * @param {AST.RegularElement | AST.SvelteElement} node
* @param {import('zimmerframe').Context<SvelteNode, ComponentServerTransformState>} context * @param {import('zimmerframe').Context<AST.SvelteNode, ComponentServerTransformState>} context
*/ */
export function build_element_attributes(node, context) { export function build_element_attributes(node, context) {
/** @type {Array<AST.Attribute | AST.SpreadAttribute>} */ /** @type {Array<AST.Attribute | AST.SpreadAttribute>} */

4
packages/svelte/src/compiler/phases/3-transform/server/visitors/shared/utils.js
Unescape View File

@ -1,5 +1,5 @@
/** @import { AssignmentOperator, Expression, Identifier, Node, Statement, TemplateElement } from 'estree' */ /** @import { AssignmentOperator, Expression, Identifier, Node, Statement, TemplateElement } from 'estree' */
/** @import { AST, SvelteNode } from '#compiler' */ /** @import { AST } from '#compiler' */
/** @import { ComponentContext, ServerTransformState } from '../../types.js' */ /** @import { ComponentContext, ServerTransformState } from '../../types.js' */
import { escape_html } from '../../../../../../escaping.js'; import { escape_html } from '../../../../../../escaping.js';
@ -24,7 +24,7 @@ export const empty_comment = b.literal(EMPTY_COMMENT);
/** /**
* Processes an array of template nodes, joining sibling text/expression nodes and * Processes an array of template nodes, joining sibling text/expression nodes and
* recursing into child nodes. * recursing into child nodes.
* @param {Array<SvelteNode>} nodes * @param {Array<AST.SvelteNode>} nodes
* @param {ComponentContext} context * @param {ComponentContext} context
*/ */
export function process_children(nodes, { visit, state }) { export function process_children(nodes, { visit, state }) {

4
packages/svelte/src/compiler/phases/3-transform/types.d.ts vendored
Unescape View File

@ -1,10 +1,10 @@
import type { Scope } from '../scope.js'; import type { Scope } from '../scope.js';
import type { SvelteNode, ValidatedModuleCompileOptions } from '#compiler'; import type { AST, ValidatedModuleCompileOptions } from '#compiler';
import type { Analysis } from '../types.js'; import type { Analysis } from '../types.js';
export interface TransformState { export interface TransformState {
readonly analysis: Analysis; readonly analysis: Analysis;
readonly options: ValidatedModuleCompileOptions; readonly options: ValidatedModuleCompileOptions;
readonly scope: Scope; readonly scope: Scope;
readonly scopes: Map<SvelteNode, Scope>; readonly scopes: Map<AST.SvelteNode, Scope>;
} }

20
packages/svelte/src/compiler/phases/3-transform/utils.js
Unescape View File

@ -1,6 +1,6 @@
/** @import { Context } from 'zimmerframe' */ /** @import { Context } from 'zimmerframe' */
/** @import { TransformState } from './types.js' */ /** @import { TransformState } from './types.js' */
/** @import { AST, Binding, Namespace, SvelteNode, ValidatedCompileOptions } from '#compiler' */ /** @import { AST, Binding, Namespace, ValidatedCompileOptions } from '#compiler' */
/** @import { Node, Expression, CallExpression } from 'estree' */ /** @import { Node, Expression, CallExpression } from 'estree' */
import { import {
regex_ends_with_whitespaces, regex_ends_with_whitespaces,
@ -33,7 +33,7 @@ export function is_hoisted_function(node) {
/** /**
* Match Svelte 4 behaviour by sorting ConstTag nodes in topological order * Match Svelte 4 behaviour by sorting ConstTag nodes in topological order
* @param {SvelteNode[]} nodes * @param {AST.SvelteNode[]} nodes
* @param {TransformState} state * @param {TransformState} state
*/ */
function sort_const_tags(nodes, state) { function sort_const_tags(nodes, state) {
@ -133,9 +133,9 @@ function sort_const_tags(nodes, state) {
* unless it's whitespace-only, in which case collapse to a single whitespace for all cases * unless it's whitespace-only, in which case collapse to a single whitespace for all cases
* except when it's children of certain elements where we know ignore whitespace (like td/option/head), * except when it's children of certain elements where we know ignore whitespace (like td/option/head),
* in which case we remove it entirely * in which case we remove it entirely
* @param {SvelteNode} parent * @param {AST.SvelteNode} parent
* @param {SvelteNode[]} nodes * @param {AST.SvelteNode[]} nodes
* @param {SvelteNode[]} path * @param {AST.SvelteNode[]} path
* @param {Namespace} namespace * @param {Namespace} namespace
* @param {TransformState & { options: ValidatedCompileOptions }} state * @param {TransformState & { options: ValidatedCompileOptions }} state
* @param {boolean} preserve_whitespace * @param {boolean} preserve_whitespace
@ -157,10 +157,10 @@ export function clean_nodes(
nodes = sort_const_tags(nodes, state); nodes = sort_const_tags(nodes, state);
} }
/** @type {SvelteNode[]} */ /** @type {AST.SvelteNode[]} */
const hoisted = []; const hoisted = [];
/** @type {SvelteNode[]} */ /** @type {AST.SvelteNode[]} */
const regular = []; const regular = [];
for (const node of nodes) { for (const node of nodes) {
@ -316,8 +316,8 @@ export function clean_nodes(
/** /**
* Infers the namespace for the children of a node that should be used when creating the `$.template(...)`. * Infers the namespace for the children of a node that should be used when creating the `$.template(...)`.
* @param {Namespace} namespace * @param {Namespace} namespace
* @param {SvelteNode} parent * @param {AST.SvelteNode} parent
* @param {SvelteNode[]} nodes * @param {AST.SvelteNode[]} nodes
*/ */
export function infer_namespace(namespace, parent, nodes) { export function infer_namespace(namespace, parent, nodes) {
if (parent.type === 'RegularElement' && parent.name === 'foreignObject') { if (parent.type === 'RegularElement' && parent.name === 'foreignObject') {
@ -371,7 +371,7 @@ export function infer_namespace(namespace, parent, nodes) {
* Heuristic: Keep current namespace, unless we find a regular element, * Heuristic: Keep current namespace, unless we find a regular element,
* in which case we always want html, or we only find svg nodes, * in which case we always want html, or we only find svg nodes,
* in which case we assume svg. * in which case we assume svg.
* @param {SvelteNode[]} nodes * @param {AST.SvelteNode[]} nodes
* @param {Namespace | 'keep' | 'maybe_html'} namespace * @param {Namespace | 'keep' | 'maybe_html'} namespace
*/ */
function check_nodes_for_namespace(nodes, namespace) { function check_nodes_for_namespace(nodes, namespace) {

4
packages/svelte/src/compiler/phases/css.js
Unescape View File

@ -1,4 +1,4 @@
/** @import { Css } from '#compiler' */ /** @import { AST } from '#compiler' */
const regex_css_browser_prefix = /^-((webkit)|(moz)|(o)|(ms))-/; const regex_css_browser_prefix = /^-((webkit)|(moz)|(o)|(ms))-/;
export const regex_css_name_boundary = /^[\s,;}]$/; export const regex_css_name_boundary = /^[\s,;}]$/;
@ -10,5 +10,5 @@ export function remove_css_prefix(name) {
return name.replace(regex_css_browser_prefix, ''); return name.replace(regex_css_browser_prefix, '');
} }
/** @param {Css.Atrule} node */ /** @param {AST.CSS.Atrule} node */
export const is_keyframes_node = (node) => remove_css_prefix(node.name) === 'keyframes'; export const is_keyframes_node = (node) => remove_css_prefix(node.name) === 'keyframes';

4
packages/svelte/src/compiler/phases/nodes.js
Unescape View File

@ -1,4 +1,4 @@
/** @import { AST, ExpressionMetadata, SvelteNode } from '#compiler' */ /** @import { AST, ExpressionMetadata } from '#compiler' */
/** /**
* All nodes that can appear elsewhere than the top level, have attributes and can contain children * All nodes that can appear elsewhere than the top level, have attributes and can contain children
*/ */
@ -14,7 +14,7 @@ const element_nodes = [
/** /**
* Returns true for all nodes that can appear elsewhere than the top level, have attributes and can contain children * Returns true for all nodes that can appear elsewhere than the top level, have attributes and can contain children
* @param {SvelteNode} node * @param {AST.SvelteNode} node
* @returns {node is AST.Component | AST.RegularElement | AST.SlotElement | AST.SvelteComponent | AST.SvelteElement | AST.SvelteFragment | AST.SvelteSelf} * @returns {node is AST.Component | AST.RegularElement | AST.SlotElement | AST.SvelteComponent | AST.SvelteElement | AST.SvelteFragment | AST.SvelteSelf}
*/ */
export function is_element_node(node) { export function is_element_node(node) {

26
packages/svelte/src/compiler/phases/scope.js
Unescape View File

@ -1,6 +1,6 @@
/** @import { ClassDeclaration, Expression, FunctionDeclaration, Identifier, ImportDeclaration, MemberExpression, Node, Pattern, VariableDeclarator } from 'estree' */ /** @import { ClassDeclaration, Expression, FunctionDeclaration, Identifier, ImportDeclaration, MemberExpression, Node, Pattern, VariableDeclarator } from 'estree' */
/** @import { Context, Visitor } from 'zimmerframe' */ /** @import { Context, Visitor } from 'zimmerframe' */
/** @import { AST, Binding, DeclarationKind, ElementLike, SvelteNode } from '#compiler' */ /** @import { AST, Binding, DeclarationKind } from '#compiler' */
import is_reference from 'is-reference'; import is_reference from 'is-reference';
import { walk } from 'zimmerframe'; import { walk } from 'zimmerframe';
import { create_expression_metadata } from './nodes.js'; import { create_expression_metadata } from './nodes.js';
@ -48,7 +48,7 @@ export class Scope {
/** /**
* A set of all the names referenced with this scope * A set of all the names referenced with this scope
* — useful for generating unique names * — useful for generating unique names
* @type {Map<string, { node: Identifier; path: SvelteNode[] }[]>} * @type {Map<string, { node: Identifier; path: AST.SvelteNode[] }[]>}
*/ */
references = new Map(); references = new Map();
@ -179,7 +179,7 @@ export class Scope {
/** /**
* @param {Identifier} node * @param {Identifier} node
* @param {SvelteNode[]} path * @param {AST.SvelteNode[]} path
*/ */
reference(node, path) { reference(node, path) {
path = [...path]; // ensure that mutations to path afterwards don't affect this reference path = [...path]; // ensure that mutations to path afterwards don't affect this reference
@ -225,7 +225,7 @@ export class ScopeRoot {
} }
/** /**
* @param {SvelteNode} ast * @param {AST.SvelteNode} ast
* @param {ScopeRoot} root * @param {ScopeRoot} root
* @param {boolean} allow_reactive_declarations * @param {boolean} allow_reactive_declarations
* @param {Scope | null} parent * @param {Scope | null} parent
@ -235,7 +235,7 @@ export function create_scopes(ast, root, allow_reactive_declarations, parent) {
/** /**
* A map of node->associated scope. A node appearing in this map does not necessarily mean that it created a scope * A map of node->associated scope. A node appearing in this map does not necessarily mean that it created a scope
* @type {Map<SvelteNode, Scope>} * @type {Map<AST.SvelteNode, Scope>}
*/ */
const scopes = new Map(); const scopes = new Map();
const scope = new Scope(root, parent, false); const scope = new Scope(root, parent, false);
@ -244,7 +244,7 @@ export function create_scopes(ast, root, allow_reactive_declarations, parent) {
/** @type {State} */ /** @type {State} */
const state = { scope }; const state = { scope };
/** @type {[Scope, { node: Identifier; path: SvelteNode[] }][]} */ /** @type {[Scope, { node: Identifier; path: AST.SvelteNode[] }][]} */
const references = []; const references = [];
/** @type {[Scope, Pattern | MemberExpression][]} */ /** @type {[Scope, Pattern | MemberExpression][]} */
@ -269,7 +269,7 @@ export function create_scopes(ast, root, allow_reactive_declarations, parent) {
} }
/** /**
* @type {Visitor<Node, State, SvelteNode>} * @type {Visitor<Node, State, AST.SvelteNode>}
*/ */
const create_block_scope = (node, { state, next }) => { const create_block_scope = (node, { state, next }) => {
const scope = state.scope.child(true); const scope = state.scope.child(true);
@ -279,7 +279,7 @@ export function create_scopes(ast, root, allow_reactive_declarations, parent) {
}; };
/** /**
* @type {Visitor<ElementLike, State, SvelteNode>} * @type {Visitor<AST.ElementLike, State, AST.SvelteNode>}
*/ */
const SvelteFragment = (node, { state, next }) => { const SvelteFragment = (node, { state, next }) => {
const scope = state.scope.child(); const scope = state.scope.child();
@ -288,7 +288,7 @@ export function create_scopes(ast, root, allow_reactive_declarations, parent) {
}; };
/** /**
* @type {Visitor<AST.Component | AST.SvelteComponent | AST.SvelteSelf, State, SvelteNode>} * @type {Visitor<AST.Component | AST.SvelteComponent | AST.SvelteSelf, State, AST.SvelteNode>}
*/ */
const Component = (node, context) => { const Component = (node, context) => {
node.metadata.scopes = { node.metadata.scopes = {
@ -329,7 +329,7 @@ export function create_scopes(ast, root, allow_reactive_declarations, parent) {
}; };
/** /**
* @type {Visitor<AST.AnimateDirective | AST.TransitionDirective | AST.UseDirective, State, SvelteNode>} * @type {Visitor<AST.AnimateDirective | AST.TransitionDirective | AST.UseDirective, State, AST.SvelteNode>}
*/ */
const SvelteDirective = (node, { state, path, visit }) => { const SvelteDirective = (node, { state, path, visit }) => {
state.scope.reference(b.id(node.name.split('.')[0]), path); state.scope.reference(b.id(node.name.split('.')[0]), path);
@ -713,9 +713,9 @@ export function create_scopes(ast, root, allow_reactive_declarations, parent) {
} }
/** /**
* @template {{ scope: Scope, scopes: Map<SvelteNode, Scope> }} State * @template {{ scope: Scope, scopes: Map<AST.SvelteNode, Scope> }} State
* @param {SvelteNode} node * @param {AST.SvelteNode} node
* @param {Context<SvelteNode, State>} context * @param {Context<AST.SvelteNode, State>} context
*/ */
export function set_scope(node, { next, state }) { export function set_scope(node, { next, state }) {
const scope = state.scopes.get(node); const scope = state.scopes.get(node);

8
packages/svelte/src/compiler/phases/types.d.ts vendored
Unescape View File

@ -1,17 +1,17 @@
import type { AST, Binding, Css, SvelteNode } from '#compiler'; import type { AST, Binding } from '#compiler';
import type { Identifier, LabeledStatement, Node, Program } from 'estree'; import type { Identifier, LabeledStatement, Node, Program } from 'estree';
import type { Scope, ScopeRoot } from './scope.js'; import type { Scope, ScopeRoot } from './scope.js';
export interface Js { export interface Js {
ast: Program; ast: Program;
scope: Scope; scope: Scope;
scopes: Map<SvelteNode, Scope>; scopes: Map<AST.SvelteNode, Scope>;
} }
export interface Template { export interface Template {
ast: AST.Fragment; ast: AST.Fragment;
scope: Scope; scope: Scope;
scopes: Map<SvelteNode, Scope>; scopes: Map<AST.SvelteNode, Scope>;
} }
export interface ReactiveStatement { export interface ReactiveStatement {
@ -66,7 +66,7 @@ export interface ComponentAnalysis extends Analysis {
binding_groups: Map<[key: string, bindings: Array<Binding | null>], Identifier>; binding_groups: Map<[key: string, bindings: Array<Binding | null>], Identifier>;
slot_names: Map<string, AST.SlotElement>; slot_names: Map<string, AST.SlotElement>;
css: { css: {
ast: Css.StyleSheet | null; ast: AST.CSS.StyleSheet | null;
hash: string; hash: string;
keyframes: string[]; keyframes: string[];
}; };

8
packages/svelte/src/compiler/state.js
Unescape View File

@ -1,5 +1,5 @@
/** @import { CompileOptions, SvelteNode } from './types' */ /** @import { CompileOptions } from './types' */
/** @import { Warning } from '#compiler' */ /** @import { AST, Warning } from '#compiler' */
import { getLocator } from 'locate-character'; import { getLocator } from 'locate-character';
/** @typedef {{ start?: number, end?: number }} NodeLike */ /** @typedef {{ start?: number, end?: number }} NodeLike */
@ -41,7 +41,7 @@ export let ignore_stack = [];
* For each node the list of warnings that should be ignored for that node. * For each node the list of warnings that should be ignored for that node.
* Exists in addition to `ignore_stack` because not all warnings are emitted * Exists in addition to `ignore_stack` because not all warnings are emitted
* while the stack is being built. * while the stack is being built.
* @type {Map<SvelteNode | NodeLike, Set<string>[]>} * @type {Map<AST.SvelteNode | NodeLike, Set<string>[]>}
*/ */
export let ignore_map = new Map(); export let ignore_map = new Map();
@ -66,7 +66,7 @@ export function reset_warning_filter(fn = () => true) {
} }
/** /**
* @param {SvelteNode | NodeLike} node * @param {AST.SvelteNode | NodeLike} node
* @param {import('../constants.js').IGNORABLE_RUNTIME_WARNINGS[number]} code * @param {import('../constants.js').IGNORABLE_RUNTIME_WARNINGS[number]} code
* @returns * @returns
*/ */

2
packages/svelte/src/compiler/types/css.d.ts vendored
Unescape View File

@ -1,6 +1,6 @@
import type { AST } from '#compiler'; import type { AST } from '#compiler';
export namespace Css { export namespace _CSS {
export interface BaseNode { export interface BaseNode {
start: number; start: number;
end: number; end: number;

6
packages/svelte/src/compiler/types/index.d.ts vendored
Unescape View File

@ -7,8 +7,7 @@ import type {
} from 'estree'; } from 'estree';
import type { SourceMap } from 'magic-string'; import type { SourceMap } from 'magic-string';
import type { Scope } from '../phases/scope.js'; import type { Scope } from '../phases/scope.js';
import type { Css } from './css.js'; import type { AST, Namespace } from './template.js';
import type { AST, Namespace, SvelteNode } from './template.js';
import type { ICompileDiagnostic } from '../utils/compile_diagnostic.js'; import type { ICompileDiagnostic } from '../utils/compile_diagnostic.js';
/** The return value of `compile` from `svelte/compiler` */ /** The return value of `compile` from `svelte/compiler` */
@ -295,7 +294,7 @@ export interface Binding {
| AST.EachBlock | AST.EachBlock
| AST.SnippetBlock; | AST.SnippetBlock;
is_called: boolean; is_called: boolean;
references: { node: Identifier; path: SvelteNode[] }[]; references: { node: Identifier; path: AST.SvelteNode[] }[];
mutated: boolean; mutated: boolean;
reassigned: boolean; reassigned: boolean;
/** `true` if mutated _or_ reassigned */ /** `true` if mutated _or_ reassigned */
@ -322,7 +321,6 @@ export interface ExpressionMetadata {
} }
export * from './template.js'; export * from './template.js';
export { Css };
// TODO this chain is a bit weird // TODO this chain is a bit weird
export { ReactiveStatement } from '../phases/types.js'; export { ReactiveStatement } from '../phases/types.js';

4
packages/svelte/src/compiler/types/legacy-nodes.d.ts vendored
Unescape View File

@ -1,4 +1,4 @@
import type { AST, Css } from '#compiler'; import type { AST } from '#compiler';
import type { import type {
ArrayExpression, ArrayExpression,
AssignmentExpression, AssignmentExpression,
@ -260,7 +260,7 @@ export interface LegacyStyle extends BaseNode {
export interface LegacySelector extends BaseNode { export interface LegacySelector extends BaseNode {
type: 'Selector'; type: 'Selector';
children: Array<Css.Combinator | Css.SimpleSelector>; children: Array<AST.CSS.Combinator | AST.CSS.SimpleSelector>;
} }
export type LegacyCssNode = LegacyStyle | LegacySelector; export type LegacyCssNode = LegacyStyle | LegacySelector;

29
packages/svelte/src/compiler/types/template.d.ts vendored
Unescape View File

@ -1,4 +1,4 @@
import type { Binding, Css, ExpressionMetadata } from '#compiler'; import type { Binding, ExpressionMetadata } from '#compiler';
import type { import type {
ArrayExpression, ArrayExpression,
ArrowFunctionExpression, ArrowFunctionExpression,
@ -18,6 +18,7 @@ import type {
SequenceExpression SequenceExpression
} from 'estree'; } from 'estree';
import type { Scope } from '../phases/scope'; import type { Scope } from '../phases/scope';
import type { _CSS } from './css';
/** /**
* - `html` — the default, for e.g. `<div>` or `<span>` * - `html` — the default, for e.g. `<div>` or `<span>`
@ -66,7 +67,7 @@ export namespace AST {
options: SvelteOptions | null; options: SvelteOptions | null;
fragment: Fragment; fragment: Fragment;
/** The parsed `<style>` element, if exists */ /** The parsed `<style>` element, if exists */
css: Css.StyleSheet | null; css: AST.CSS.StyleSheet | null;
/** The parsed `<script>` element, if exists */ /** The parsed `<script>` element, if exists */
instance: Script | null; instance: Script | null;
/** The parsed `<script module>` element, if exists */ /** The parsed `<script module>` element, if exists */
@ -499,11 +500,10 @@ export namespace AST {
content: Program; content: Program;
attributes: Attribute[]; attributes: Attribute[];
} }
}
type Tag = AST.ExpressionTag | AST.HtmlTag | AST.ConstTag | AST.DebugTag | AST.RenderTag; export type AttributeLike = Attribute | SpreadAttribute | Directive;
export type Directive = export type Directive =
| AST.AnimateDirective | AST.AnimateDirective
| AST.BindDirective | AST.BindDirective
| AST.ClassDirective | AST.ClassDirective
@ -513,14 +513,20 @@ export type Directive =
| AST.TransitionDirective | AST.TransitionDirective
| AST.UseDirective; | AST.UseDirective;
export type Block = AST.EachBlock | AST.IfBlock | AST.AwaitBlock | AST.KeyBlock | AST.SnippetBlock; export type Block =
| AST.EachBlock
| AST.IfBlock
| AST.AwaitBlock
| AST.KeyBlock
| AST.SnippetBlock;
export type ElementLike = export type ElementLike =
| AST.Component | AST.Component
| AST.TitleElement | AST.TitleElement
| AST.SlotElement | AST.SlotElement
| AST.RegularElement | AST.RegularElement
| AST.SvelteBody | AST.SvelteBody
| AST.SvelteBoundary
| AST.SvelteComponent | AST.SvelteComponent
| AST.SvelteDocument | AST.SvelteDocument
| AST.SvelteElement | AST.SvelteElement
@ -531,7 +537,9 @@ export type ElementLike =
| AST.SvelteWindow | AST.SvelteWindow
| AST.SvelteBoundary; | AST.SvelteBoundary;
export type TemplateNode = export type Tag = AST.ExpressionTag | AST.HtmlTag | AST.ConstTag | AST.DebugTag | AST.RenderTag;
export type TemplateNode =
| AST.Root | AST.Root
| AST.Text | AST.Text
| Tag | Tag
@ -542,7 +550,10 @@ export type TemplateNode =
| AST.Comment | AST.Comment
| Block; | Block;
export type SvelteNode = Node | TemplateNode | AST.Fragment | Css.Node; export type SvelteNode = Node | TemplateNode | AST.Fragment | _CSS.Node;
export type { _CSS as CSS };
}
declare module 'estree' { declare module 'estree' {
export interface BaseNode { export interface BaseNode {

4
packages/svelte/src/compiler/utils/ast.js
Unescape View File

@ -1,4 +1,4 @@
/** @import { AST, SvelteNode } from '#compiler' */ /** @import { AST } from '#compiler' */
/** @import * as ESTree from 'estree' */ /** @import * as ESTree from 'estree' */
import { walk } from 'zimmerframe'; import { walk } from 'zimmerframe';
import * as b from '../utils/builders.js'; import * as b from '../utils/builders.js';
@ -393,7 +393,7 @@ function _extract_paths(assignments = [], param, expression, update_expression,
* Like `path.at(x)`, but skips over `TSNonNullExpression` and `TSAsExpression` nodes and eases assertions a bit * Like `path.at(x)`, but skips over `TSNonNullExpression` and `TSAsExpression` nodes and eases assertions a bit
* by removing the `| undefined` from the resulting type. * by removing the `| undefined` from the resulting type.
* *
* @template {SvelteNode} T * @template {AST.SvelteNode} T
* @param {T[]} path * @param {T[]} path
* @param {number} at * @param {number} at
*/ */

4
packages/svelte/src/compiler/utils/slot.js
Unescape View File

@ -1,9 +1,9 @@
/** @import { SvelteNode } from '#compiler' */ /** @import { AST } from '#compiler' */
import { is_element_node } from '../phases/nodes.js'; import { is_element_node } from '../phases/nodes.js';
import { is_text_attribute } from './ast.js'; import { is_text_attribute } from './ast.js';
/** /**
* @param {SvelteNode} node * @param {AST.SvelteNode} node
*/ */
export function determine_slot(node) { export function determine_slot(node) {
if (!is_element_node(node)) return null; if (!is_element_node(node)) return null;

59
packages/svelte/types/index.d.ts vendored
Unescape View File

@ -606,7 +606,7 @@ declare module 'svelte/animate' {
} }
declare module 'svelte/compiler' { declare module 'svelte/compiler' {
import type { Expression, Identifier, ArrayExpression, ArrowFunctionExpression, VariableDeclaration, VariableDeclarator, MemberExpression, ObjectExpression, Pattern, Program, ChainExpression, SimpleCallExpression, SequenceExpression } from 'estree'; import type { Expression, Identifier, ArrayExpression, ArrowFunctionExpression, VariableDeclaration, VariableDeclarator, MemberExpression, Node, ObjectExpression, Pattern, Program, ChainExpression, SimpleCallExpression, SequenceExpression } from 'estree';
import type { SourceMap } from 'magic-string'; import type { SourceMap } from 'magic-string';
import type { Location } from 'locate-character'; import type { Location } from 'locate-character';
/** /**
@ -943,7 +943,7 @@ declare module 'svelte/compiler' {
options: SvelteOptions | null; options: SvelteOptions | null;
fragment: Fragment; fragment: Fragment;
/** The parsed `<style>` element, if exists */ /** The parsed `<style>` element, if exists */
css: Css.StyleSheet | null; css: AST.CSS.StyleSheet | null;
/** The parsed `<script>` element, if exists */ /** The parsed `<script>` element, if exists */
instance: Script | null; instance: Script | null;
/** The parsed `<script module>` element, if exists */ /** The parsed `<script module>` element, if exists */
@ -1257,11 +1257,10 @@ declare module 'svelte/compiler' {
content: Program; content: Program;
attributes: Attribute[]; attributes: Attribute[];
} }
}
type Tag = AST.ExpressionTag | AST.HtmlTag | AST.ConstTag | AST.DebugTag | AST.RenderTag; export type AttributeLike = Attribute | SpreadAttribute | Directive;
type Directive = export type Directive =
| AST.AnimateDirective | AST.AnimateDirective
| AST.BindDirective | AST.BindDirective
| AST.ClassDirective | AST.ClassDirective
@ -1271,14 +1270,20 @@ declare module 'svelte/compiler' {
| AST.TransitionDirective | AST.TransitionDirective
| AST.UseDirective; | AST.UseDirective;
type Block = AST.EachBlock | AST.IfBlock | AST.AwaitBlock | AST.KeyBlock | AST.SnippetBlock; export type Block =
| AST.EachBlock
| AST.IfBlock
| AST.AwaitBlock
| AST.KeyBlock
| AST.SnippetBlock;
type ElementLike = export type ElementLike =
| AST.Component | AST.Component
| AST.TitleElement | AST.TitleElement
| AST.SlotElement | AST.SlotElement
| AST.RegularElement | AST.RegularElement
| AST.SvelteBody | AST.SvelteBody
| AST.SvelteBoundary
| AST.SvelteComponent | AST.SvelteComponent
| AST.SvelteDocument | AST.SvelteDocument
| AST.SvelteElement | AST.SvelteElement
@ -1288,6 +1293,24 @@ declare module 'svelte/compiler' {
| AST.SvelteSelf | AST.SvelteSelf
| AST.SvelteWindow | AST.SvelteWindow
| AST.SvelteBoundary; | AST.SvelteBoundary;
export type Tag = AST.ExpressionTag | AST.HtmlTag | AST.ConstTag | AST.DebugTag | AST.RenderTag;
export type TemplateNode =
| AST.Root
| AST.Text
| Tag
| ElementLike
| AST.Attribute
| AST.SpreadAttribute
| Directive
| AST.Comment
| Block;
export type SvelteNode = Node | TemplateNode | AST.Fragment | _CSS.Node;
export type { _CSS as CSS };
}
/** /**
* The preprocess function provides convenient hooks for arbitrarily transforming component source code. * The preprocess function provides convenient hooks for arbitrarily transforming component source code.
* For example, it can be used to convert a `<style lang="sass">` block into vanilla CSS. * For example, it can be used to convert a `<style lang="sass">` block into vanilla CSS.
@ -1313,7 +1336,17 @@ declare module 'svelte/compiler' {
} | undefined): { } | undefined): {
code: string; code: string;
}; };
namespace Css { type ICompileDiagnostic = {
code: string;
message: string;
stack?: string;
filename?: string;
start?: Location;
end?: Location;
position?: [number, number];
frame?: string;
};
namespace _CSS {
export interface BaseNode { export interface BaseNode {
start: number; start: number;
end: number; end: number;
@ -1471,16 +1504,6 @@ declare module 'svelte/compiler' {
| SimpleSelector | SimpleSelector
| Declaration; | Declaration;
} }
type ICompileDiagnostic = {
code: string;
message: string;
stack?: string;
filename?: string;
start?: Location;
end?: Location;
position?: [number, number];
frame?: string;
};
export {}; export {};
} }

Write Preview
Loading…
Cancel
Save