mirror of https://github.com/sveltejs/svelte
Dominic Gannaway
2 years ago
commit
f97dbca479
@ -0,0 +1,5 @@
|
||||
---
|
||||
"svelte": patch
|
||||
---
|
||||
|
||||
feat: add support for webkitdirectory DOM boolean attribute
|
||||
@ -0,0 +1,5 @@
|
||||
---
|
||||
"svelte": patch
|
||||
---
|
||||
|
||||
fix: don't override instance methods during legacy class creation
|
||||
@ -0,0 +1,5 @@
|
||||
---
|
||||
"svelte": patch
|
||||
---
|
||||
|
||||
fix: adjust scope parent for named slots
|
||||
@ -0,0 +1,5 @@
|
||||
---
|
||||
"svelte": patch
|
||||
---
|
||||
|
||||
fix: improve handling of unowned derived signals
|
||||
@ -0,0 +1,5 @@
|
||||
---
|
||||
"svelte": patch
|
||||
---
|
||||
|
||||
fix: improve element class attribute behaviour
|
||||
@ -0,0 +1,5 @@
|
||||
---
|
||||
"svelte": patch
|
||||
---
|
||||
|
||||
feat: take form resets into account for two way bindings
|
||||
@ -0,0 +1,5 @@
|
||||
---
|
||||
"svelte": patch
|
||||
---
|
||||
|
||||
breaking: apply fallback value every time in runes mode
|
||||
@ -0,0 +1,5 @@
|
||||
---
|
||||
"svelte": patch
|
||||
---
|
||||
|
||||
fix: ensure select value is updated upon select option removal
|
||||
@ -1,194 +1,132 @@
|
||||
import { is_promise } from '../../../common.js';
|
||||
import { hydrate_block_anchor } from '../hydration.js';
|
||||
import { remove } from '../reconciler.js';
|
||||
import { current_block, execute_effect, flushSync } from '../../runtime.js';
|
||||
import { destroy_effect, render_effect } from '../../reactivity/effects.js';
|
||||
import { trigger_transitions } from '../elements/transitions.js';
|
||||
import { AWAIT_BLOCK, UNINITIALIZED } from '../../constants.js';
|
||||
|
||||
/** @returns {import('../../types.js').AwaitBlock} */
|
||||
export function create_await_block() {
|
||||
return {
|
||||
// dom
|
||||
d: null,
|
||||
// effect
|
||||
e: null,
|
||||
// parent
|
||||
p: /** @type {import('../../types.js').Block} */ (current_block),
|
||||
// pending
|
||||
n: true,
|
||||
// transition
|
||||
r: null,
|
||||
// type
|
||||
t: AWAIT_BLOCK
|
||||
};
|
||||
}
|
||||
import {
|
||||
current_component_context,
|
||||
flushSync,
|
||||
set_current_component_context,
|
||||
set_current_effect,
|
||||
set_current_reaction
|
||||
} from '../../runtime.js';
|
||||
import { destroy_effect, pause_effect, render_effect } from '../../reactivity/effects.js';
|
||||
import { DESTROYED, INERT } from '../../constants.js';
|
||||
import { create_block } from './utils.js';
|
||||
|
||||
/**
|
||||
* @template V
|
||||
* @param {Comment} anchor_node
|
||||
* @param {(() => Promise<V>)} input
|
||||
* @param {Comment} anchor
|
||||
* @param {(() => Promise<V>)} get_input
|
||||
* @param {null | ((anchor: Node) => void)} pending_fn
|
||||
* @param {null | ((anchor: Node, value: V) => void)} then_fn
|
||||
* @param {null | ((anchor: Node, error: unknown) => void)} catch_fn
|
||||
* @returns {void}
|
||||
*/
|
||||
export function await_block(anchor_node, input, pending_fn, then_fn, catch_fn) {
|
||||
const block = create_await_block();
|
||||
|
||||
/** @type {null | import('../../types.js').Render} */
|
||||
let current_render = null;
|
||||
hydrate_block_anchor(anchor_node);
|
||||
|
||||
/** @type {{}} */
|
||||
let latest_token;
|
||||
|
||||
/** @type {typeof UNINITIALIZED | V} */
|
||||
let resolved_value = UNINITIALIZED;
|
||||
|
||||
/** @type {unknown} */
|
||||
let error = UNINITIALIZED;
|
||||
let pending = false;
|
||||
block.r =
|
||||
/**
|
||||
* @param {import('../../types.js').Transition} transition
|
||||
* @returns {void}
|
||||
*/
|
||||
(transition) => {
|
||||
const render = /** @type {import('../../types.js').Render} */ (current_render);
|
||||
const transitions = render.s;
|
||||
transitions.add(transition);
|
||||
transition.f(() => {
|
||||
transitions.delete(transition);
|
||||
if (transitions.size === 0) {
|
||||
// If the current render has changed since, then we can remove the old render
|
||||
// effect as it's stale.
|
||||
if (current_render !== render && render.e !== null) {
|
||||
if (render.d !== null) {
|
||||
remove(render.d);
|
||||
render.d = null;
|
||||
}
|
||||
destroy_effect(render.e);
|
||||
render.e = null;
|
||||
}
|
||||
}
|
||||
});
|
||||
};
|
||||
const create_render_effect = () => {
|
||||
/** @type {import('../../types.js').Render} */
|
||||
const render = {
|
||||
d: null,
|
||||
e: null,
|
||||
s: new Set(),
|
||||
p: current_render
|
||||
};
|
||||
const effect = render_effect(
|
||||
() => {
|
||||
if (error === UNINITIALIZED) {
|
||||
if (resolved_value === UNINITIALIZED) {
|
||||
// pending = true
|
||||
block.n = true;
|
||||
if (pending_fn !== null) {
|
||||
pending_fn(anchor_node);
|
||||
}
|
||||
} else if (then_fn !== null) {
|
||||
// pending = false
|
||||
block.n = false;
|
||||
then_fn(anchor_node, resolved_value);
|
||||
}
|
||||
} else if (catch_fn !== null) {
|
||||
// pending = false
|
||||
block.n = false;
|
||||
catch_fn(anchor_node, error);
|
||||
export function await_block(anchor, get_input, pending_fn, then_fn, catch_fn) {
|
||||
const block = create_block();
|
||||
|
||||
const component_context = current_component_context;
|
||||
|
||||
hydrate_block_anchor(anchor);
|
||||
|
||||
/** @type {any} */
|
||||
let input;
|
||||
|
||||
/** @type {import('#client').Effect | null} */
|
||||
let pending_effect;
|
||||
|
||||
/** @type {import('#client').Effect | null} */
|
||||
let then_effect;
|
||||
|
||||
/** @type {import('#client').Effect | null} */
|
||||
let catch_effect;
|
||||
|
||||
/**
|
||||
* @param {(anchor: Comment, value: any) => void} fn
|
||||
* @param {any} value
|
||||
*/
|
||||
function create_effect(fn, value) {
|
||||
set_current_effect(branch);
|
||||
set_current_reaction(branch); // TODO do we need both?
|
||||
set_current_component_context(component_context);
|
||||
var effect = render_effect(() => fn(anchor, value), {}, true);
|
||||
set_current_component_context(null);
|
||||
set_current_reaction(null);
|
||||
set_current_effect(null);
|
||||
|
||||
// without this, the DOM does not update until two ticks after the promise,
|
||||
// resolves which is unexpected behaviour (and somewhat irksome to test)
|
||||
flushSync();
|
||||
|
||||
return effect;
|
||||
}
|
||||
|
||||
/** @param {import('#client').Effect} effect */
|
||||
function pause(effect) {
|
||||
if ((effect.f & DESTROYED) !== 0) return;
|
||||
const block = effect.block;
|
||||
|
||||
pause_effect(effect, () => {
|
||||
// TODO make this unnecessary
|
||||
const dom = block?.d;
|
||||
if (dom) remove(dom);
|
||||
});
|
||||
}
|
||||
|
||||
const branch = render_effect(() => {
|
||||
if (input === (input = get_input())) return;
|
||||
|
||||
if (is_promise(input)) {
|
||||
const promise = /** @type {Promise<any>} */ (input);
|
||||
|
||||
if (pending_fn) {
|
||||
if (pending_effect && (pending_effect.f & INERT) === 0) {
|
||||
if (pending_effect.block?.d) remove(pending_effect.block.d);
|
||||
destroy_effect(pending_effect);
|
||||
}
|
||||
render.d = block.d;
|
||||
block.d = null;
|
||||
},
|
||||
block,
|
||||
true,
|
||||
true
|
||||
);
|
||||
render.e = effect;
|
||||
current_render = render;
|
||||
};
|
||||
const render = () => {
|
||||
const render = current_render;
|
||||
if (render === null) {
|
||||
create_render_effect();
|
||||
return;
|
||||
}
|
||||
const transitions = render.s;
|
||||
if (transitions.size === 0) {
|
||||
if (render.d !== null) {
|
||||
remove(render.d);
|
||||
render.d = null;
|
||||
}
|
||||
if (render.e) {
|
||||
execute_effect(render.e);
|
||||
} else {
|
||||
create_render_effect();
|
||||
|
||||
pending_effect = render_effect(() => pending_fn(anchor), {}, true);
|
||||
}
|
||||
} else {
|
||||
create_render_effect();
|
||||
trigger_transitions(transitions, 'out');
|
||||
}
|
||||
};
|
||||
const await_effect = render_effect(
|
||||
() => {
|
||||
const token = {};
|
||||
latest_token = token;
|
||||
const promise = input();
|
||||
if (is_promise(promise)) {
|
||||
promise.then(
|
||||
/** @param {V} v */
|
||||
(v) => {
|
||||
if (latest_token === token) {
|
||||
// Ensure UI is in sync before resolving value.
|
||||
flushSync();
|
||||
resolved_value = v;
|
||||
pending = false;
|
||||
render();
|
||||
}
|
||||
},
|
||||
/** @param {unknown} _error */
|
||||
(_error) => {
|
||||
error = _error;
|
||||
pending = false;
|
||||
render();
|
||||
|
||||
if (then_effect) pause(then_effect);
|
||||
if (catch_effect) pause(catch_effect);
|
||||
|
||||
promise.then(
|
||||
(value) => {
|
||||
if (promise !== input) return;
|
||||
if (pending_effect) pause(pending_effect);
|
||||
|
||||
if (then_fn) {
|
||||
then_effect = create_effect(then_fn, value);
|
||||
}
|
||||
},
|
||||
(error) => {
|
||||
if (promise !== input) return;
|
||||
if (pending_effect) pause(pending_effect);
|
||||
|
||||
if (catch_fn) {
|
||||
catch_effect = create_effect(catch_fn, error);
|
||||
}
|
||||
);
|
||||
if (resolved_value !== UNINITIALIZED || error !== UNINITIALIZED) {
|
||||
error = UNINITIALIZED;
|
||||
resolved_value = UNINITIALIZED;
|
||||
}
|
||||
if (!pending) {
|
||||
pending = true;
|
||||
render();
|
||||
);
|
||||
} else {
|
||||
if (pending_effect) pause(pending_effect);
|
||||
if (catch_effect) pause(catch_effect);
|
||||
|
||||
if (then_fn) {
|
||||
if (then_effect) {
|
||||
if (then_effect.block?.d) remove(then_effect.block.d);
|
||||
destroy_effect(then_effect);
|
||||
}
|
||||
} else {
|
||||
error = UNINITIALIZED;
|
||||
resolved_value = promise;
|
||||
pending = false;
|
||||
render();
|
||||
}
|
||||
},
|
||||
block,
|
||||
false
|
||||
);
|
||||
await_effect.ondestroy = () => {
|
||||
let render = current_render;
|
||||
latest_token = {};
|
||||
while (render !== null) {
|
||||
const dom = render.d;
|
||||
if (dom !== null) {
|
||||
remove(dom);
|
||||
}
|
||||
const effect = render.e;
|
||||
if (effect !== null) {
|
||||
destroy_effect(effect);
|
||||
|
||||
then_effect = render_effect(() => then_fn(anchor, input), {}, true);
|
||||
}
|
||||
render = render.p;
|
||||
}
|
||||
}, block);
|
||||
|
||||
branch.ondestroy = () => {
|
||||
// TODO this sucks, tidy it up
|
||||
if (pending_effect?.block?.d) remove(pending_effect.block.d);
|
||||
if (then_effect?.block?.d) remove(then_effect.block.d);
|
||||
if (catch_effect?.block?.d) remove(catch_effect.block.d);
|
||||
};
|
||||
block.e = await_effect;
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,140 +1,76 @@
|
||||
import { UNINITIALIZED, KEY_BLOCK } from '../../constants.js';
|
||||
import { UNINITIALIZED } from '../../constants.js';
|
||||
import { hydrate_block_anchor } from '../hydration.js';
|
||||
import { remove } from '../reconciler.js';
|
||||
import { current_block, execute_effect } from '../../runtime.js';
|
||||
import { destroy_effect, render_effect } from '../../reactivity/effects.js';
|
||||
import { trigger_transitions } from '../elements/transitions.js';
|
||||
import { pause_effect, render_effect } from '../../reactivity/effects.js';
|
||||
import { safe_not_equal } from '../../reactivity/equality.js';
|
||||
|
||||
/** @returns {import('../../types.js').KeyBlock} */
|
||||
function create_key_block() {
|
||||
return {
|
||||
// dom
|
||||
d: null,
|
||||
// effect
|
||||
e: null,
|
||||
// parent
|
||||
p: /** @type {import('../../types.js').Block} */ (current_block),
|
||||
// transition
|
||||
r: null,
|
||||
// type
|
||||
t: KEY_BLOCK
|
||||
};
|
||||
}
|
||||
import { create_block } from './utils.js';
|
||||
|
||||
/**
|
||||
* @template V
|
||||
* @param {Comment} anchor_node
|
||||
* @param {() => V} key
|
||||
* @param {Comment} anchor
|
||||
* @param {() => V} get_key
|
||||
* @param {(anchor: Node) => void} render_fn
|
||||
* @returns {void}
|
||||
*/
|
||||
export function key_block(anchor_node, key, render_fn) {
|
||||
const block = create_key_block();
|
||||
export function key_block(anchor, get_key, render_fn) {
|
||||
const block = create_block();
|
||||
|
||||
/** @type {null | import('../../types.js').Render} */
|
||||
let current_render = null;
|
||||
hydrate_block_anchor(anchor_node);
|
||||
hydrate_block_anchor(anchor);
|
||||
|
||||
/** @type {V | typeof UNINITIALIZED} */
|
||||
let key_value = UNINITIALIZED;
|
||||
let mounted = false;
|
||||
block.r =
|
||||
/**
|
||||
* @param {import('../../types.js').Transition} transition
|
||||
* @returns {void}
|
||||
*/
|
||||
(transition) => {
|
||||
const render = /** @type {import('../../types.js').Render} */ (current_render);
|
||||
const transitions = render.s;
|
||||
transitions.add(transition);
|
||||
transition.f(() => {
|
||||
transitions.delete(transition);
|
||||
if (transitions.size === 0) {
|
||||
// If the current render has changed since, then we can remove the old render
|
||||
// effect as it's stale.
|
||||
if (current_render !== render && render.e !== null) {
|
||||
if (render.d !== null) {
|
||||
remove(render.d);
|
||||
render.d = null;
|
||||
}
|
||||
destroy_effect(render.e);
|
||||
render.e = null;
|
||||
}
|
||||
}
|
||||
});
|
||||
};
|
||||
const create_render_effect = () => {
|
||||
/** @type {import('../../types.js').Render} */
|
||||
const render = {
|
||||
d: null,
|
||||
e: null,
|
||||
s: new Set(),
|
||||
p: current_render
|
||||
};
|
||||
const effect = render_effect(
|
||||
() => {
|
||||
render_fn(anchor_node);
|
||||
render.d = block.d;
|
||||
block.d = null;
|
||||
},
|
||||
block,
|
||||
true,
|
||||
true
|
||||
);
|
||||
render.e = effect;
|
||||
current_render = render;
|
||||
};
|
||||
const render = () => {
|
||||
const render = current_render;
|
||||
if (render === null) {
|
||||
create_render_effect();
|
||||
return;
|
||||
}
|
||||
const transitions = render.s;
|
||||
if (transitions.size === 0) {
|
||||
if (render.d !== null) {
|
||||
remove(render.d);
|
||||
render.d = null;
|
||||
}
|
||||
if (render.e) {
|
||||
execute_effect(render.e);
|
||||
} else {
|
||||
create_render_effect();
|
||||
}
|
||||
} else {
|
||||
trigger_transitions(transitions, 'out');
|
||||
create_render_effect();
|
||||
}
|
||||
};
|
||||
let key = UNINITIALIZED;
|
||||
|
||||
/** @type {import('#client').Effect} */
|
||||
let effect;
|
||||
|
||||
/**
|
||||
* Every time `key` changes, we create a new effect. Old effects are
|
||||
* removed from this set when they have fully transitioned out
|
||||
* @type {Set<import('#client').Effect>}
|
||||
*/
|
||||
let effects = new Set();
|
||||
|
||||
const key_effect = render_effect(
|
||||
() => {
|
||||
const prev_key_value = key_value;
|
||||
key_value = key();
|
||||
if (mounted && safe_not_equal(prev_key_value, key_value)) {
|
||||
render();
|
||||
if (safe_not_equal(key, (key = get_key()))) {
|
||||
if (effect) {
|
||||
var e = effect;
|
||||
pause_effect(e, () => {
|
||||
effects.delete(e);
|
||||
});
|
||||
}
|
||||
|
||||
effect = render_effect(
|
||||
() => {
|
||||
render_fn(anchor);
|
||||
|
||||
const dom = block.d;
|
||||
|
||||
return () => {
|
||||
if (dom !== null) {
|
||||
remove(dom);
|
||||
}
|
||||
};
|
||||
},
|
||||
block,
|
||||
true,
|
||||
true
|
||||
);
|
||||
|
||||
// @ts-expect-error TODO tidy up
|
||||
effect.d = block.d;
|
||||
|
||||
effects.add(effect);
|
||||
}
|
||||
},
|
||||
block,
|
||||
false
|
||||
);
|
||||
// To ensure topological ordering of the key effect to the render effect,
|
||||
// we trigger the effect after.
|
||||
render();
|
||||
mounted = true;
|
||||
|
||||
key_effect.ondestroy = () => {
|
||||
let render = current_render;
|
||||
while (render !== null) {
|
||||
const dom = render.d;
|
||||
if (dom !== null) {
|
||||
remove(dom);
|
||||
}
|
||||
const effect = render.e;
|
||||
if (effect !== null) {
|
||||
destroy_effect(effect);
|
||||
}
|
||||
render = render.p;
|
||||
for (const e of effects) {
|
||||
// @ts-expect-error TODO tidy up. ondestroy should be totally unnecessary
|
||||
if (e.d) remove(e.d);
|
||||
}
|
||||
};
|
||||
block.e = key_effect;
|
||||
}
|
||||
|
||||
@ -0,0 +1,7 @@
|
||||
/** @returns {import('#client').Block} */
|
||||
export function create_block() {
|
||||
return {
|
||||
// dom
|
||||
d: null
|
||||
};
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,8 @@
|
||||
import { test } from '../../test';
|
||||
|
||||
export default test({
|
||||
error: {
|
||||
code: 'invalid-rune-args-length',
|
||||
message: '$bindable can only be called with 0 or 1 arguments'
|
||||
}
|
||||
});
|
||||
@ -0,0 +1,3 @@
|
||||
<script>
|
||||
const { foo = $bindable(1, 2) } = $props();
|
||||
</script>
|
||||
@ -0,0 +1,8 @@
|
||||
import { test } from '../../test';
|
||||
|
||||
export default test({
|
||||
error: {
|
||||
code: 'invalid-bindable-location',
|
||||
message: '$bindable() can only be used inside a $props() declaration'
|
||||
}
|
||||
});
|
||||
@ -0,0 +1,3 @@
|
||||
<script>
|
||||
const { a = $bindable() } = $state();
|
||||
</script>
|
||||
@ -0,0 +1 @@
|
||||
const { a = $bindable() } = $state();
|
||||
@ -1 +1 @@
|
||||
<!--ssr:0--><div class="foo"></div><!--ssr:0-->
|
||||
<!--ssr:0--><div id="foo"></div><!--ssr:0-->
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
<script>
|
||||
export let className;
|
||||
export let id;
|
||||
</script>
|
||||
|
||||
<div class={className}></div>
|
||||
<div id={id}></div>
|
||||
|
||||
@ -0,0 +1,12 @@
|
||||
import { test } from '../../test';
|
||||
|
||||
export default test({
|
||||
async test({ assert, target }) {
|
||||
await new Promise((r) => setTimeout(r, 200)); // wait for await block to resolve
|
||||
|
||||
const options = target.querySelectorAll('option');
|
||||
assert.ok(!options[0].selected);
|
||||
assert.ok(options[1].selected);
|
||||
assert.ok(!options[2].selected);
|
||||
}
|
||||
});
|
||||
@ -0,0 +1,19 @@
|
||||
<script>
|
||||
let promise = getNumbers();
|
||||
let selected = 2;
|
||||
|
||||
async function getNumbers() {
|
||||
await new Promise(resolve => setTimeout(resolve, 100));
|
||||
return [1, 2, 3];
|
||||
}
|
||||
</script>
|
||||
|
||||
<select bind:value={selected}>
|
||||
{#await promise}
|
||||
<option>-1</option>
|
||||
{:then numbers}
|
||||
{#each numbers as number}
|
||||
<option>{number}</option>
|
||||
{/each}
|
||||
{/await}
|
||||
</select>
|
||||
@ -0,0 +1,35 @@
|
||||
import { ok, test } from '../../test';
|
||||
|
||||
// test select binding behavior when a selected option is removed
|
||||
export default test({
|
||||
skip_if_ssr: 'permanent',
|
||||
|
||||
html: `<p>selected: a</p><select><option value="a">a</option><option value="b">b</option><option value="c">c</option></select>`,
|
||||
|
||||
async test({ assert, component, target }) {
|
||||
const select = target.querySelector('select');
|
||||
ok(select);
|
||||
const options = target.querySelectorAll('option');
|
||||
|
||||
// first option should be selected by default since no value was bound
|
||||
assert.equal(component.selected, 'a');
|
||||
assert.equal(select.value, 'a');
|
||||
assert.ok(options[0].selected);
|
||||
|
||||
// remove the selected item, so the bound value no longer matches anything
|
||||
component.items = ['b', 'c'];
|
||||
|
||||
// There's a MutationObserver
|
||||
await Promise.resolve();
|
||||
|
||||
// now no option should be selected
|
||||
assert.equal(select.value, '');
|
||||
assert.equal(select.selectedIndex, -1);
|
||||
|
||||
// model of selected value should be kept around, even if it is not in the list
|
||||
assert.htmlEqual(
|
||||
target.innerHTML,
|
||||
`<p>selected: a</p><select><option value="b">b</option><option value="c">c</option></select>`
|
||||
);
|
||||
}
|
||||
});
|
||||
@ -0,0 +1,12 @@
|
||||
<script>
|
||||
export let selected;
|
||||
export let items = ['a', 'b', 'c'];
|
||||
</script>
|
||||
|
||||
<p>selected: {selected}</p>
|
||||
|
||||
<select bind:value={selected}>
|
||||
{#each items as letter}
|
||||
<option>{letter}</option>
|
||||
{/each}
|
||||
</select>
|
||||
@ -0,0 +1 @@
|
||||
<slot name="inner" text="hello world" />
|
||||
@ -0,0 +1,9 @@
|
||||
<script>
|
||||
export let text;
|
||||
</script>
|
||||
|
||||
<div>
|
||||
{text}
|
||||
<hr />
|
||||
<slot name="footer" />
|
||||
</div>
|
||||
@ -0,0 +1,7 @@
|
||||
import { test } from '../../test';
|
||||
|
||||
export default test({
|
||||
html: `
|
||||
<div>hello world <hr> <div slot="footer">hello world</div></div>
|
||||
`
|
||||
});
|
||||
@ -0,0 +1,12 @@
|
||||
<script>
|
||||
import Nested from "./Nested.svelte"
|
||||
import Nested2 from "./Nested2.svelte"
|
||||
</script>
|
||||
|
||||
<Nested>
|
||||
<Nested2 slot="inner" let:text {text}>
|
||||
<div slot="footer">
|
||||
{text}
|
||||
</div>
|
||||
</Nested2>
|
||||
</Nested>
|
||||
@ -0,0 +1,7 @@
|
||||
<script>
|
||||
export let a;
|
||||
export const b = 2;
|
||||
</script>
|
||||
|
||||
<p>a: {a}</p>
|
||||
<p>b: {b}</p>
|
||||
@ -0,0 +1,27 @@
|
||||
import { test } from '../../test';
|
||||
|
||||
export default test({
|
||||
get props() {
|
||||
return { a: 3, b: 4 };
|
||||
},
|
||||
|
||||
html: `
|
||||
<p>a: 3</p>
|
||||
<p>b: 2</p>
|
||||
`,
|
||||
|
||||
async test({ assert, component, target }) {
|
||||
await component.$set({
|
||||
a: 5,
|
||||
b: 6
|
||||
});
|
||||
|
||||
assert.htmlEqual(
|
||||
target.innerHTML,
|
||||
`
|
||||
<p>a: 5</p>
|
||||
<p>b: 2</p>
|
||||
`
|
||||
);
|
||||
}
|
||||
});
|
||||
@ -0,0 +1,8 @@
|
||||
<script>
|
||||
import Nested from './Nested.svelte';
|
||||
|
||||
export let a;
|
||||
export let b;
|
||||
</script>
|
||||
|
||||
<Nested a={a} b={b}/>
|
||||
@ -0,0 +1,37 @@
|
||||
import { test } from '../../test';
|
||||
|
||||
export default test({
|
||||
get props() {
|
||||
return { a: 1, b: 2 };
|
||||
},
|
||||
|
||||
html: `
|
||||
<p>a: 1</p>
|
||||
<p>b: 2</p>
|
||||
<p>c: 3</p>
|
||||
`,
|
||||
|
||||
async test({ assert, component, target }) {
|
||||
await component.$set({ a: 4 });
|
||||
|
||||
assert.htmlEqual(
|
||||
target.innerHTML,
|
||||
`
|
||||
<p>a: 4</p>
|
||||
<p>b: 2</p>
|
||||
<p>c: 6</p>
|
||||
`
|
||||
);
|
||||
|
||||
await component.$set({ b: 5 });
|
||||
|
||||
assert.htmlEqual(
|
||||
target.innerHTML,
|
||||
`
|
||||
<p>a: 4</p>
|
||||
<p>b: 5</p>
|
||||
<p>c: 9</p>
|
||||
`
|
||||
);
|
||||
}
|
||||
});
|
||||
@ -0,0 +1,8 @@
|
||||
<script>
|
||||
export let a;
|
||||
$: c = a + $$props.b;
|
||||
</script>
|
||||
|
||||
<p>a: {a}</p>
|
||||
<p>b: {$$props.b}</p>
|
||||
<p>c: {c}</p>
|
||||
@ -0,0 +1,13 @@
|
||||
import { tick } from 'svelte';
|
||||
import { test } from '../../test';
|
||||
|
||||
export default test({
|
||||
skip: true, // failing test for https://github.com/sveltejs/svelte/issues/10787
|
||||
html: `<button>3</button>`,
|
||||
async test({ assert, target }) {
|
||||
target.querySelector('button')?.click();
|
||||
await tick();
|
||||
|
||||
assert.htmlEqual(target.innerHTML, `<button>1</button>`);
|
||||
}
|
||||
});
|
||||
@ -0,0 +1,16 @@
|
||||
<script>
|
||||
let x = 1;
|
||||
let y = true;
|
||||
$: array = y ? [1, 2] : [1];
|
||||
$: count = array.length === 2 && x ? 1 : 0;
|
||||
$: sum = count + array.length;
|
||||
</script>
|
||||
|
||||
<button
|
||||
on:click={() => {
|
||||
// order is important here: x must be updated before y
|
||||
// in order to test that $: still runs in the correct order
|
||||
x = 2;
|
||||
y = false;
|
||||
}}>{sum}</button
|
||||
>
|
||||
@ -0,0 +1,16 @@
|
||||
import { test } from '../../test';
|
||||
|
||||
export default test({
|
||||
async test({ assert, target }) {
|
||||
await target.querySelector('button')?.click();
|
||||
await Promise.resolve();
|
||||
|
||||
const options = target.querySelectorAll('option');
|
||||
assert.equal(options[0].selected, false);
|
||||
assert.equal(options[1].selected, true);
|
||||
assert.equal(options[2].selected, false);
|
||||
assert.equal(options[3].selected, false);
|
||||
assert.equal(options[4].selected, true);
|
||||
assert.equal(options[5].selected, false);
|
||||
}
|
||||
});
|
||||
@ -0,0 +1,33 @@
|
||||
<script>
|
||||
let value = 'bar';
|
||||
let value_bound = 'bar';
|
||||
let options = {};
|
||||
|
||||
function loadOptions() {
|
||||
options = {
|
||||
foo: 'Foo',
|
||||
bar: 'Bar',
|
||||
baz: 'Baz',
|
||||
};
|
||||
}
|
||||
</script>
|
||||
|
||||
<select {value}>
|
||||
{#each Object.entries(options) as [key, value] (key)}
|
||||
<option value={key}>
|
||||
{value}
|
||||
</option>
|
||||
{/each}
|
||||
</select>
|
||||
|
||||
<select bind:value={value_bound}>
|
||||
{#each Object.entries(options) as [key, value] (key)}
|
||||
<option value={key}>
|
||||
{value}
|
||||
</option>
|
||||
{/each}
|
||||
</select>
|
||||
|
||||
<button on:click={loadOptions}>
|
||||
Load options
|
||||
</button>
|
||||
@ -0,0 +1,21 @@
|
||||
import { test } from '../../test';
|
||||
|
||||
const items = [{ id: 'a' }, { id: 'b' }];
|
||||
|
||||
export default test({
|
||||
get props() {
|
||||
return { foo: [items[0]], items };
|
||||
},
|
||||
|
||||
test({ assert, component, target }) {
|
||||
const options = target.querySelectorAll('option');
|
||||
|
||||
assert.equal(options[0].selected, true);
|
||||
assert.equal(options[1].selected, false);
|
||||
|
||||
component.foo = [component.items[1]];
|
||||
|
||||
assert.equal(options[0].selected, false);
|
||||
assert.equal(options[1].selected, true);
|
||||
}
|
||||
});
|
||||
@ -0,0 +1,9 @@
|
||||
<script>
|
||||
export let foo;
|
||||
export let items;
|
||||
</script>
|
||||
|
||||
<select value="{foo}" multiple>
|
||||
<option value='{items[0]}'>a</option>
|
||||
<option value='{items[1]}'>b</option>
|
||||
</select>
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue