svelte 3.44.3 → 3.45.0

package/CHANGELOG.md

@@ -1,9 +1,18 @@
 # Svelte changelog
 
+## 3.45.0
+
+* Fix non-boolean attribute rendering in SSR to render truthy values as-is ([#6121](https://github.com/sveltejs/svelte/issues/6121))
+* Fix binding to a member expression also invalidating the member property ([#6921](https://github.com/sveltejs/svelte/issues/6921))
+* Fix default values in `{#each}`/etc. destructurings not being considered references for the purposes of compiler warnings ([#6964](https://github.com/sveltejs/svelte/issues/6964))
+* Fix `{:else if}` value incorrectly being cached ([#7043](https://github.com/sveltejs/svelte/pull/7043))
+* Add `a11y-no-redundant-roles` warning ([#7067](https://github.com/sveltejs/svelte/pull/7067))
+* Fix code generation error with arrow functions whose bodies are object destructuring assignments ([#7087](https://github.com/sveltejs/svelte/issues/7087))
+
 ## 3.44.3
 
 * Fix `bind:this` binding inside `onMount` for manually instantiated component ([#6760](https://github.com/sveltejs/svelte/issues/6760))
-* Prevent cursor jumps for other `type="text"`-like `<input>`s ([#6914](https://github.com/sveltejs/svelte/issues/6914))
+* Prevent cursor jumps with one-way binding for other `type="text"`-like `<input>`s ([#6941](https://github.com/sveltejs/svelte/pull/6941))
 * Exclude `async` loops from `loopGuardTimeout` ([#6945](https://github.com/sveltejs/svelte/issues/6945))
 
 ## 3.44.2

package/LICENSE.md

@@ -1,4 +1,4 @@
-Copyright (c) 2016-21 [these people](https://github.com/sveltejs/svelte/graphs/contributors)
+Copyright (c) 2016-22 [these people](https://github.com/sveltejs/svelte/graphs/contributors)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

package/compiler.js

@@ -6999,7 +6999,10 @@
 
 			chunks.push(c(' => '));
 
-			if (node.body.type === 'ObjectExpression') {
+			if (
+				node.body.type === 'ObjectExpression' ||
+				(node.body.type === 'AssignmentExpression' && node.body.left.type === 'ObjectPattern')
+			) {
 				chunks.push(
 					c('('),
 					...handle(node.body, state),
@@ -19223,7 +19226,7 @@
 
 	// The `foreign` namespace covers all DOM implementations that aren't HTML5.
 	// It opts out of HTML5-specific a11y checks and case-insensitive attribute names.
-	const foreign = 'https://svelte.dev/docs#svelte_options';
+	const foreign = 'https://svelte.dev/docs#template-syntax-svelte-options';
 	const html = 'http://www.w3.org/1999/xhtml';
 	const mathml = 'http://www.w3.org/1998/Math/MathML';
 	const svg = 'http://www.w3.org/2000/svg';
@@ -19855,6 +19858,28 @@
 	        });
 	        return dependencies;
 	    }
+	    get_update_dependencies() {
+	        const object = this.object;
+	        const dependencies = new Set();
+	        if (this.node.expression.template_scope.names.has(object)) {
+	            this.node.expression.template_scope.dependencies_for_name
+	                .get(object)
+	                .forEach((name) => dependencies.add(name));
+	        }
+	        else {
+	            dependencies.add(object);
+	        }
+	        const result = new Set(dependencies);
+	        dependencies.forEach((dependency) => {
+	            const indirect_dependencies = this.parent.renderer.component.indirect_dependencies.get(dependency);
+	            if (indirect_dependencies) {
+	                indirect_dependencies.forEach(indirect_dependency => {
+	                    result.add(indirect_dependency);
+	                });
+	            }
+	        });
+	        return result;
+	    }
 	    is_readonly_media_attribute() {
 	        return this.node.is_readonly_media_attribute();
 	    }
@@ -20146,7 +20171,7 @@
 	    block.renderer.add_to_context(fn.name);
 	    const callee = block.renderer.reference(fn.name);
 	    const { contextual_dependencies, mutation } = binding.handler;
-	    const dependencies = binding.get_dependencies();
+	    const dependencies = binding.get_update_dependencies();
 	    const body = b `
 		${mutation}
 		${Array.from(dependencies)
@@ -21458,7 +21483,7 @@
 	        const contextual_dependencies = new Set();
 	        binding_group.bindings.forEach(binding => {
 	            // TODO this is a mess
-	            add_to_set(dependencies, binding.get_dependencies());
+	            add_to_set(dependencies, binding.get_update_dependencies());
 	            add_to_set(contextual_dependencies, binding.handler.contextual_dependencies);
 	            binding.render(block, lock);
 	        });
@@ -22063,12 +22088,13 @@
 	        if (this.needs_update) {
 	            block.chunks.init.push(b `
 				function ${select_block_type}(#ctx, #dirty) {
-					${this.branches.map(({ dependencies, condition, snippet, block }) => condition
+					${this.branches.map(({ dependencies, condition, snippet }) => {
+                return b `${snippet && dependencies.length > 0 ? b `if (${block.renderer.dirty(dependencies)}) ${condition} = null;` : null}`;
+            })}
+					${this.branches.map(({ condition, snippet, block }) => condition
                 ? b `
-					${snippet && (dependencies.length > 0
-                    ? b `if (${condition} == null || ${block.renderer.dirty(dependencies)}) ${condition} = !!${snippet}`
-                    : b `if (${condition} == null) ${condition} = !!${snippet}`)}
-					if (${condition}) return ${block.name};`
+						${snippet && b `if (${condition} == null) ${condition} = !!${snippet}`}
+						if (${condition}) return ${block.name};`
                 : b `return ${block.name};`)}
 				}
 			`);
@@ -22166,11 +22192,12 @@
 			${this.needs_update
             ? b `
 					function ${select_block_type}(#ctx, #dirty) {
-						${this.branches.map(({ dependencies, condition, snippet }, i) => condition
+						${this.branches.map(({ dependencies, condition, snippet }) => {
+                return b `${snippet && dependencies.length > 0 ? b `if (${block.renderer.dirty(dependencies)}) ${condition} = null;` : null}`;
+            })}
+						${this.branches.map(({ condition, snippet }, i) => condition
                 ? b `
-						${snippet && (dependencies.length > 0
-                    ? b `if (${condition} == null || ${block.renderer.dirty(dependencies)}) ${condition} = !!${snippet}`
-                    : b `if (${condition} == null) ${condition} = !!${snippet}`)}
+						${snippet && b `if (${condition} == null) ${condition} = !!${snippet}`}
 						if (${condition}) return ${i};`
                 : b `return ${i};`)}
 						${!has_else && b `return -1;`}
@@ -22644,6 +22671,10 @@
 	        code: 'a11y-unknown-role',
 	        message: `A11y: Unknown role '${role}'` + (suggestion ? ` (did you mean '${suggestion}'?)` : '')
 	    }),
+	    a11y_no_redundant_roles: (role) => ({
+	        code: 'a11y-no-redundant-roles',
+	        message: `A11y: Redundant role '${role}'`
+	    }),
 	    a11y_accesskey: {
 	        code: 'a11y-accesskey',
 	        message: 'A11y: Avoid using accesskey'
@@ -25977,7 +26008,7 @@
 	    }
 	}
 
-	function unpack_destructuring(contexts, node, modifier = node => node, default_modifier = node => node) {
+	function unpack_destructuring({ contexts, node, modifier = (node) => node, default_modifier = (node) => node, scope, component }) {
 	    if (!node)
 	        return;
 	    if (node.type === 'Identifier') {
@@ -25997,14 +26028,36 @@
 	    else if (node.type === 'ArrayPattern') {
 	        node.elements.forEach((element, i) => {
 	            if (element && element.type === 'RestElement') {
-	                unpack_destructuring(contexts, element, node => x `${modifier(node)}.slice(${i})`, default_modifier);
+	                unpack_destructuring({
+	                    contexts,
+	                    node: element,
+	                    modifier: (node) => x `${modifier(node)}.slice(${i})`,
+	                    default_modifier,
+	                    scope,
+	                    component
+	                });
 	            }
 	            else if (element && element.type === 'AssignmentPattern') {
 	                const n = contexts.length;
-	                unpack_destructuring(contexts, element.left, node => x `${modifier(node)}[${i}]`, (node, to_ctx) => x `${node} !== undefined ? ${node} : ${update_reference(contexts, n, element.right, to_ctx)}`);
+	                mark_referenced(element.right, scope, component);
+	                unpack_destructuring({
+	                    contexts,
+	                    node: element.left,
+	                    modifier: (node) => x `${modifier(node)}[${i}]`,
+	                    default_modifier: (node, to_ctx) => x `${node} !== undefined ? ${node} : ${update_reference(contexts, n, element.right, to_ctx)}`,
+	                    scope,
+	                    component
+	                });
 	            }
 	            else {
-	                unpack_destructuring(contexts, element, node => x `${modifier(node)}[${i}]`, default_modifier);
+	                unpack_destructuring({
+	                    contexts,
+	                    node: element,
+	                    modifier: (node) => x `${modifier(node)}[${i}]`,
+	                    default_modifier,
+	                    scope,
+	                    component
+	                });
 	            }
 	        });
 	    }
@@ -26012,7 +26065,14 @@
 	        const used_properties = [];
 	        node.properties.forEach((property) => {
 	            if (property.type === 'RestElement') {
-	                unpack_destructuring(contexts, property.argument, node => x `@object_without_properties(${modifier(node)}, [${used_properties}])`, default_modifier);
+	                unpack_destructuring({
+	                    contexts,
+	                    node: property.argument,
+	                    modifier: (node) => x `@object_without_properties(${modifier(node)}, [${used_properties}])`,
+	                    default_modifier,
+	                    scope,
+	                    component
+	                });
 	            }
 	            else {
 	                const key = property.key;
@@ -26020,10 +26080,25 @@
 	                used_properties.push(x `"${key.name}"`);
 	                if (value.type === 'AssignmentPattern') {
 	                    const n = contexts.length;
-	                    unpack_destructuring(contexts, value.left, node => x `${modifier(node)}.${key.name}`, (node, to_ctx) => x `${node} !== undefined ? ${node} : ${update_reference(contexts, n, value.right, to_ctx)}`);
+	                    mark_referenced(value.right, scope, component);
+	                    unpack_destructuring({
+	                        contexts,
+	                        node: value.left,
+	                        modifier: (node) => x `${modifier(node)}.${key.name}`,
+	                        default_modifier: (node, to_ctx) => x `${node} !== undefined ? ${node} : ${update_reference(contexts, n, value.right, to_ctx)}`,
+	                        scope,
+	                        component
+	                    });
 	                }
 	                else {
-	                    unpack_destructuring(contexts, value, node => x `${modifier(node)}.${key.name}`, default_modifier);
+	                    unpack_destructuring({
+	                        contexts,
+	                        node: value,
+	                        modifier: (node) => x `${modifier(node)}.${key.name}`,
+	                        default_modifier,
+	                        scope,
+	                        component
+	                    });
 	                }
 	            }
 	        });
@@ -26054,6 +26129,18 @@
 	    });
 	    return expression;
 	}
+	function mark_referenced(node, scope, component) {
+	    walk(node, {
+	        enter(node, parent) {
+	            if (is_reference(node, parent)) {
+	                const { name } = flatten_reference(node);
+	                if (!scope.is_let(name) && !scope.names.has(name)) {
+	                    component.add_reference(name);
+	                }
+	            }
+	        }
+	    });
+	}
 
 	class AwaitBlock$1 extends Node$1 {
 	    constructor(component, parent, scope, info) {
@@ -26063,11 +26150,11 @@
 	        this.catch_node = info.error;
 	        if (this.then_node) {
 	            this.then_contexts = [];
-	            unpack_destructuring(this.then_contexts, info.value);
+	            unpack_destructuring({ contexts: this.then_contexts, node: info.value, scope, component });
 	        }
 	        if (this.catch_node) {
 	            this.catch_contexts = [];
-	            unpack_destructuring(this.catch_contexts, info.error);
+	            unpack_destructuring({ contexts: this.catch_contexts, node: info.error, scope, component });
 	        }
 	        this.pending = new PendingBlock(component, this, scope, info.pending);
 	        this.then = new ThenBlock(component, this, scope, info.then);
@@ -26163,7 +26250,7 @@
 	        this.index = info.index;
 	        this.scope = scope.child();
 	        this.contexts = [];
-	        unpack_destructuring(this.contexts, info.context);
+	        unpack_destructuring({ contexts: this.contexts, node: info.context, scope, component });
 	        this.contexts.forEach(context => {
 	            this.scope.add(context.key.name, this.expression.dependencies, this);
 	        });
@@ -26498,6 +26585,44 @@
 	    'select',
 	    'textarea'
 	]);
+	const a11y_nested_implicit_semantics = new Map([
+	    ['header', 'banner'],
+	    ['footer', 'contentinfo']
+	]);
+	const a11y_implicit_semantics = new Map([
+	    ['a', 'link'],
+	    ['aside', 'complementary'],
+	    ['body', 'document'],
+	    ['datalist', 'listbox'],
+	    ['dd', 'definition'],
+	    ['dfn', 'term'],
+	    ['details', 'group'],
+	    ['dt', 'term'],
+	    ['fieldset', 'group'],
+	    ['form', 'form'],
+	    ['h1', 'heading'],
+	    ['h2', 'heading'],
+	    ['h3', 'heading'],
+	    ['h4', 'heading'],
+	    ['h5', 'heading'],
+	    ['h6', 'heading'],
+	    ['hr', 'separator'],
+	    ['li', 'listitem'],
+	    ['menu', 'list'],
+	    ['nav', 'navigation'],
+	    ['ol', 'list'],
+	    ['optgroup', 'group'],
+	    ['output', 'status'],
+	    ['progress', 'progressbar'],
+	    ['section', 'region'],
+	    ['summary', 'button'],
+	    ['tbody', 'rowgroup'],
+	    ['textarea', 'textbox'],
+	    ['tfoot', 'rowgroup'],
+	    ['thead', 'rowgroup'],
+	    ['tr', 'row'],
+	    ['ul', 'list']
+	]);
 	const invisible_elements = new Set(['meta', 'html', 'script', 'style']);
 	const valid_modifiers = new Set([
 	    'preventDefault',
@@ -26521,6 +26646,21 @@
 	    ['htmlFor', 'for']
 	]);
 	const attributes_to_compact_whitespace = ['class', 'style'];
+	function is_parent(parent, elements) {
+	    let check = false;
+	    while (parent) {
+	        const parent_name = parent.name;
+	        if (elements.includes(parent_name)) {
+	            check = true;
+	            break;
+	        }
+	        if (parent.type === 'Element') {
+	            break;
+	        }
+	        parent = parent.parent;
+	    }
+	    return check;
+	}
 	function get_namespace(parent, element, explicit_namespace) {
 	    const parent_element = parent.find_nearest(/^Element/);
 	    if (!parent_element) {
@@ -26726,6 +26866,19 @@
 	                    const match = fuzzymatch(value, aria_roles);
 	                    component.warn(attribute, compiler_warnings.a11y_unknown_role(value, match));
 	                }
+	                // no-redundant-roles
+	                const has_redundant_role = value === a11y_implicit_semantics.get(this.name);
+	                if (this.name === value || has_redundant_role) {
+	                    component.warn(attribute, compiler_warnings.a11y_no_redundant_roles(value));
+	                }
+	                // Footers and headers are special cases, and should not have redundant roles unless they are the children of sections or articles.
+	                const is_parent_section_or_article = is_parent(this.parent, ['section', 'article']);
+	                if (!is_parent_section_or_article) {
+	                    const has_nested_redundant_role = value === a11y_nested_implicit_semantics.get(this.name);
+	                    if (has_nested_redundant_role) {
+	                        component.warn(attribute, compiler_warnings.a11y_no_redundant_roles(value));
+	                    }
+	                }
 	            }
 	            // no-access-key
 	            if (name === 'accesskey') {
@@ -30155,7 +30308,7 @@
 	        if (result) {
 	            const { compile_options, name } = this;
 	            const { format = 'esm' } = compile_options;
-	            const banner = `${this.file ? `${this.file} ` : ''}generated by Svelte v${'3.44.3'}`;
+	            const banner = `${this.file ? `${this.file} ` : ''}generated by Svelte v${'3.45.0'}`;
 	            const program = { type: 'Program', body: result.js };
 	            walk(program, {
 	                enter: (node, parent, key) => {
@@ -31646,7 +31799,7 @@
 	    return result.to_processed();
 	}
 
-	const VERSION = '3.44.3';
+	const VERSION = '3.45.0';
 
 	exports.VERSION = VERSION;
 	exports.compile = compile;