Merge branch 'master' into gh-1520

pull/1691/head
Rich Harris 6 years ago
commit 33ed2f504e

@ -5,7 +5,7 @@ node_js:
env:
global:
- BUILD_TIMEOUT=10000
- BUILD_TIMEOUT=20000
addons:
apt:

@ -1,5 +1,25 @@
# Svelte changelog
## 2.13.1
* Coerce second argument to `toggleClass` ([#1685](https://github.com/sveltejs/svelte/issues/1685))
## 2.13.0
* Add `class` directive ([#890](https://github.com/sveltejs/svelte/issues/890))
* Remove sourcemaps from npm package ([#1690](https://github.com/sveltejs/svelte/pull/1690))
## 2.12.1
* Allow actions to take any expression ([#1676](https://github.com/sveltejs/svelte/issues/1676))
* Run transitions in component context ([#1675](https://github.com/sveltejs/svelte/issues/1675))
* Correctly set select value on mount ([#1666](https://github.com/sveltejs/svelte/issues/1666))
* Support `{@debug}` in SSR ([#1659](https://github.com/sveltejs/svelte/issues/1659))
* Don't treat ` ` as empty whitespace ([#1658](https://github.com/sveltejs/svelte/issues/1658))
* Fix outros for if blocks with no else ([#1688](https://github.com/sveltejs/svelte/pull/1688))
* Set `style.cssText` in spread attributes ([#1684](https://github.com/sveltejs/svelte/pull/1684))
## 2.12.0
* Initialise actions on mount rather than hydrate ([#1653](https://github.com/sveltejs/svelte/pull/1653))

@ -1,6 +1,6 @@
{
"name": "svelte",
"version": "2.12.0",
"version": "2.13.1",
"description": "The magical disappearing UI framework",
"main": "compiler/svelte.js",
"bin": {
@ -8,8 +8,8 @@
},
"files": [
"cli",
"compiler",
"ssr",
"compiler/*.js",
"ssr/*.js",
"shared.js",
"store.js",
"store.umd.js",

@ -210,7 +210,7 @@ export default class Attribute extends Node {
}
`;
block.builders.hydrate.addBlock(deindent`
block.builders.mount.addBlock(deindent`
${last} = ${value};
${updater}
`);

@ -0,0 +1,18 @@
import Node from './shared/Node';
import Expression from './shared/Expression';
export default class Class extends Node {
type: 'Class';
name: string;
expression: Expression;
constructor(compiler, parent, scope, info) {
super(compiler, parent, scope, info);
this.name = info.name;
this.expression = info.expression
? new Expression(compiler, this, scope, info.expression)
: null;
}
}

@ -4,6 +4,7 @@ import Block from '../dom/Block';
import Expression from './shared/Expression';
import deindent from '../../utils/deindent';
import addToSet from '../../utils/addToSet';
import { stringify } from '../../utils/stringify';
export default class DebugTag extends Node {
expressions: Expression[];
@ -25,8 +26,8 @@ export default class DebugTag extends Node {
const { code } = this.compiler;
// Debug all
if (this.expressions.length === 0) {
// Debug all
code.overwrite(this.start + 1, this.start + 7, 'debugger', {
storeName: true
});
@ -67,4 +68,22 @@ export default class DebugTag extends Node {
`);
}
}
ssr() {
if (!this.compiler.options.dev) return;
const filename = this.compiler.file || null;
const { line, column } = this.compiler.locate(this.start + 1);
const obj = this.expressions.length === 0
? `ctx`
: `{ ${this.expressions
.map(e => e.node.name)
.map(name => `${name}: ctx.${name}`)
.join(', ')} }`;
const str = '${@debug(' + `${filename && stringify(filename)}, ${line}, ${column}, ${obj})}`;
this.compiler.target.append(str);
}
}

@ -15,6 +15,7 @@ import EventHandler from './EventHandler';
import Transition from './Transition';
import Animation from './Animation';
import Action from './Action';
import Class from './Class';
import Text from './Text';
import * as namespaces from '../../utils/namespaces';
import mapChildren from './shared/mapChildren';
@ -68,6 +69,8 @@ export default class Element extends Node {
attributes: Attribute[];
actions: Action[];
bindings: Binding[];
classes: Class[];
classDependencies: string[];
handlers: EventHandler[];
intro?: Transition;
outro?: Transition;
@ -90,6 +93,8 @@ export default class Element extends Node {
this.attributes = [];
this.actions = [];
this.bindings = [];
this.classes = [];
this.classDependencies = [];
this.handlers = [];
this.intro = null;
@ -144,6 +149,10 @@ export default class Element extends Node {
this.bindings.push(new Binding(compiler, this, scope, node));
break;
case 'Class':
this.classes.push(new Class(compiler, this, scope, node));
break;
case 'EventHandler':
this.handlers.push(new EventHandler(compiler, this, scope, node));
break;
@ -228,6 +237,13 @@ export default class Element extends Node {
block.addDependencies(binding.value.dependencies);
});
this.classes.forEach(classDir => {
this.parent.cannotUseInnerHTML();
if (classDir.expression) {
block.addDependencies(classDir.expression.dependencies);
}
});
this.handlers.forEach(handler => {
this.parent.cannotUseInnerHTML();
block.addDependencies(handler.dependencies);
@ -403,6 +419,7 @@ export default class Element extends Node {
this.addTransitions(block);
this.addAnimation(block);
this.addActions(block);
this.addClasses(block);
if (this.initialUpdate) {
block.builders.mount.addBlock(this.initialUpdate);
@ -584,6 +601,9 @@ export default class Element extends Node {
}
this.attributes.forEach((attribute: Attribute) => {
if (attribute.name === 'class' && attribute.isDynamic) {
this.classDependencies.push(...attribute.dependencies);
}
attribute.render(block);
});
}
@ -867,6 +887,26 @@ export default class Element extends Node {
});
}
addClasses(block: Block) {
this.classes.forEach(classDir => {
const { expression: { snippet, dependencies}, name } = classDir;
const updater = `@toggleClass(${this.var}, "${name}", ${snippet});`;
block.builders.hydrate.addLine(updater);
if ((dependencies && dependencies.size > 0) || this.classDependencies.length) {
const allDeps = this.classDependencies.concat(...dependencies);
const deps = allDeps.map(dependency => `changed.${dependency}`).join(' || ');
const condition = allDeps.length > 1 ? `(${deps})` : deps;
block.builders.update.addConditional(
condition,
updater
);
}
});
}
getStaticAttributeValue(name: string) {
const attribute = this.attributes.find(
(attr: Attribute) => attr.type === 'Attribute' && attr.name.toLowerCase() === name
@ -937,6 +977,13 @@ export default class Element extends Node {
appendTarget.slots[slotName] = '';
}
const classExpr = this.classes.map((classDir: Class) => {
const { expression: { snippet }, name } = classDir;
return `${snippet} ? "${name}" : ""`;
}).join(', ');
let addClassAttribute = classExpr ? true : false;
if (this.attributes.find(attr => attr.isSpread)) {
// TODO dry this out
const args = [];
@ -977,12 +1024,19 @@ export default class Element extends Node {
) {
// a boolean attribute with one non-Text chunk
openingTag += '${' + attribute.chunks[0].snippet + ' ? " ' + attribute.name + '" : "" }';
} else if (attribute.name === 'class' && classExpr) {
addClassAttribute = false;
openingTag += ` class="\${ [\`${attribute.stringifyForSsr()}\`, ${classExpr} ].join(' ') }"`;
} else {
openingTag += ` ${attribute.name}="${attribute.stringifyForSsr()}"`;
}
});
}
if (addClassAttribute) {
openingTag += ` class="\${ [${classExpr}].join(' ') }"`;
}
openingTag += '>';
compiler.target.append(openingTag);

@ -139,9 +139,10 @@ export default class IfBlock extends Node {
this.buildCompoundWithOutros(block, parentNode, parentNodes, branches, dynamic, vars);
if (this.compiler.options.nestedTransitions) {
block.builders.outro.addLine(
`${name}.o(#outrocallback);`
);
block.builders.outro.addBlock(deindent`
if (${name}) ${name}.o(#outrocallback);
else #outrocallback();
`);
}
} else {
this.buildCompound(block, parentNode, parentNodes, branches, dynamic, vars);

@ -77,10 +77,19 @@ const DIRECTIVES: Record<string, {
attribute(start, end, type, name, expression) {
return { start, end, type, name, expression };
},
allowedExpressionTypes: ['Identifier', 'MemberExpression', 'ObjectExpression', 'Literal', 'CallExpression'],
allowedExpressionTypes: ['*'],
error: 'Data passed to actions must be an identifier (e.g. `foo`), a member expression ' +
'(e.g. `foo.bar` or `foo[baz]`), a method call (e.g. `foo()`), or a literal (e.g. `true` or `\'a string\'`'
},
Class: {
names: ['class'],
attribute(start, end, type, name, expression) {
return { start, end, type, name, expression };
},
allowedExpressionTypes: ['*'],
error: 'Data passed to class directives must be an expression'
},
};
@ -163,7 +172,8 @@ export function readDirective(
try {
expression = readExpression(parser, expressionStart, quoteMark);
if (directive.allowedExpressionTypes.indexOf(expression.type) === -1) {
const allowed = directive.allowedExpressionTypes;
if (allowed[0] !== '*' && allowed.indexOf(expression.type) === -1) {
parser.error({
code: `invalid-directive-value`,
message: directive.error

@ -87,7 +87,9 @@ export function setAttribute(node, attribute, value) {
export function setAttributes(node, attributes) {
for (var key in attributes) {
if (key in node) {
if (key === 'style') {
node.style.cssText = attributes[key];
} else if (key in node) {
node[key] = attributes[key];
} else {
if (attributes[key] === undefined) removeAttribute(node, key);
@ -238,4 +240,8 @@ export function addResizeListener(element, fn) {
element.removeChild(object);
}
};
}
}
export function toggleClass(element, name, toggle) {
element.classList.toggle(name, !!toggle);
}

@ -97,10 +97,6 @@ export function on(eventName, handler) {
};
}
export function run(fn) {
fn();
}
export function set(newState) {
this._set(assign({}, newState));
if (this.root._lock) return;

@ -54,4 +54,10 @@ export function validateSsrComponent(component, name) {
}
return component;
}
export function debug(file, line, column, values) {
console.log(`{@debug} ${file ? file + ' ' : ''}(${line}:${column})`);
console.log(values);
return '';
}

@ -1,5 +1,5 @@
import { createElement } from './dom.js';
import { noop } from './utils.js';
import { noop, run } from './utils.js';
export function linear(t) {
return t;
@ -27,7 +27,7 @@ export function hash(str) {
}
export function wrapTransition(component, node, fn, params, intro) {
let obj = fn(node, params);
let obj = fn.call(component, node, params);
let duration;
let ease;
let cssText;
@ -137,9 +137,7 @@ export function wrapTransition(component, node, fn, params, intro) {
});
if (--program.group.remaining === 0) {
program.group.callbacks.forEach(fn => {
fn();
});
program.group.callbacks.forEach(run);
}
} else {
if (obj.css) transitionManager.deleteRule(node, program.name);

@ -31,4 +31,8 @@ export function exclude(src, prop) {
const tar = {};
for (const k in src) k === prop || (tar[k] = src[k]);
return tar;
}
export function run(fn) {
fn();
}

@ -14,7 +14,7 @@ function isEmptyBlock(node: Node) {
if (!/Block$/.test(node.type) || !node.children) return false;
if (node.children.length > 1) return false;
const child = node.children[0];
return !child || (child.type === 'Text' && !/\S/.test(child.data));
return !child || (child.type === 'Text' && !/[^ \r\n\f\v\t]/.test(child.data));
}
export default function validateHtml(validator: Validator, html: Node) {

@ -25,11 +25,11 @@ export default function validateComponent(
if (attribute.type === 'Ref') {
if (!isValidIdentifier(attribute.name)) {
const suggestion = attribute.name.replace(/[^_$a-z0-9]/ig, '_').replace(/^\d/, '_$&');
validator.error(attribute, {
code: `invalid-reference-name`,
message: `Reference name '${attribute.name}' is invalid — must be a valid identifier such as ${suggestion}`
});
});
} else {
if (!refs.has(attribute.name)) refs.set(attribute.name, []);
refs.get(attribute.name).push(node);
@ -49,6 +49,11 @@ export default function validateComponent(
code: `invalid-action`,
message: `Actions can only be applied to DOM elements, not components`
});
} else if (attribute.type === 'Class') {
validator.error(attribute, {
code: `invalid-class`,
message: `Classes can only be applied to DOM elements, not components`
});
}
});
}

@ -0,0 +1,6 @@
export default {
options: {
generate: 'ssr',
dev: true
}
};

@ -0,0 +1,46 @@
var { debug, each, escape } = require("svelte/shared.js");
var SvelteComponent = {};
SvelteComponent.data = function() {
return {};
};
SvelteComponent.render = function(state, options = {}) {
var components = new Set();
function addComponent(component) {
components.add(component);
}
var result = { head: '', addComponent };
var html = SvelteComponent._render(result, state, options);
var cssCode = Array.from(components).map(c => c.css && c.css.code).filter(Boolean).join('\n');
return {
html,
head: result.head,
css: { code: cssCode, map: null },
toString() {
return html;
}
};
};
SvelteComponent._render = function(__result, ctx, options) {
__result.addComponent(SvelteComponent);
ctx = Object.assign({}, ctx);
return `${ each(ctx.things, item => Object.assign({}, ctx, { thing: item }), ctx => `<span>${escape(ctx.thing.name)}</span>
${debug(null, 2, 2, { foo: ctx.foo })}`)}
<p>foo: ${escape(ctx.foo)}</p>`;
};
SvelteComponent.css = {
code: '',
map: null
};
module.exports = SvelteComponent;

@ -0,0 +1,51 @@
"use strict";
var { debug, each, escape } = require("svelte/shared.js");
var SvelteComponent = {};;
SvelteComponent.data = function() {
return {};
};
SvelteComponent.render = function(state, options = {}) {
var components = new Set();
function addComponent(component) {
components.add(component);
}
var result = { head: '', addComponent };
var html = SvelteComponent._render(result, state, options);
var cssCode = Array.from(components).map(c => c.css && c.css.code).filter(Boolean).join('\n');
return {
html,
head: result.head,
css: { code: cssCode, map: null },
toString() {
return html;
}
};
}
SvelteComponent._render = function(__result, ctx, options) {
__result.addComponent(SvelteComponent);
ctx = Object.assign({}, ctx);
return `${ each(ctx.things, item => Object.assign({}, ctx, { thing: item }), ctx => `<span>${escape(ctx.thing.name)}</span>
${debug(null, 2, 2, { foo: ctx.foo })}`)}
<p>foo: ${escape(ctx.foo)}</p>`;
};
SvelteComponent.css = {
code: '',
map: null
};
var warned = false;
module.exports = SvelteComponent;

@ -0,0 +1,6 @@
{#each things as thing}
<span>{thing.name}</span>
{@debug foo}
{/each}
<p>foo: {foo}</p>

@ -0,0 +1,224 @@
function noop() {}
function assign(tar, src) {
for (var k in src) tar[k] = src[k];
return tar;
}
function append(target, node) {
target.appendChild(node);
}
function insert(target, node, anchor) {
target.insertBefore(node, anchor);
}
function detachNode(node) {
node.parentNode.removeChild(node);
}
function createElement(name) {
return document.createElement(name);
}
function createText(data) {
return document.createTextNode(data);
}
function blankObject() {
return Object.create(null);
}
function destroy(detach) {
this.destroy = noop;
this.fire('destroy');
this.set = noop;
this._fragment.d(detach !== false);
this._fragment = null;
this._state = {};
}
function _differs(a, b) {
return a != a ? b == b : a !== b || ((a && typeof a === 'object') || typeof a === 'function');
}
function fire(eventName, data) {
var handlers =
eventName in this._handlers && this._handlers[eventName].slice();
if (!handlers) return;
for (var i = 0; i < handlers.length; i += 1) {
var handler = handlers[i];
if (!handler.__calling) {
try {
handler.__calling = true;
handler.call(this, data);
} finally {
handler.__calling = false;
}
}
}
}
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() {
return this._state;
}
function init(component, options) {
component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind;
component.options = options;
component.root = options.root || component;
component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
}
function on(eventName, handler) {
var handlers = this._handlers[eventName] || (this._handlers[eventName] = []);
handlers.push(handler);
return {
cancel: function() {
var index = handlers.indexOf(handler);
if (~index) handlers.splice(index, 1);
}
};
}
function set(newState) {
this._set(assign({}, newState));
if (this.root._lock) return;
flush(this.root);
}
function _set(newState) {
var oldState = this._state,
changed = {},
dirty = false;
for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
}
if (!dirty) return;
this._state = assign(assign({}, oldState), newState);
this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state);
if (this._fragment) {
this.fire("state", { changed: changed, current: this._state, previous: oldState });
this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState });
}
}
function callAll(fns) {
while (fns && fns.length) fns.shift()();
}
function _mount(target, anchor) {
this._fragment[this._fragment.i ? 'i' : 'm'](target, anchor || null);
}
var proto = {
destroy,
get,
fire,
on,
set,
_recompute: noop,
_set,
_mount,
_differs
};
/* generated by Svelte vX.Y.Z */
function create_main_fragment(component, ctx) {
var select, option, text, option_1, text_1, select_value_value;
return {
c() {
select = createElement("select");
option = createElement("option");
text = createText("1");
option_1 = createElement("option");
text_1 = createText("2");
option.__value = "1";
option.value = option.__value;
option_1.__value = "2";
option_1.value = option_1.__value;
},
m(target, anchor) {
insert(target, select, anchor);
append(select, option);
append(option, text);
append(select, option_1);
append(option_1, text_1);
select_value_value = ctx.current;
for (var i = 0; i < select.options.length; i += 1) {
var option_2 = select.options[i];
if (option_2.__value === select_value_value) {
option_2.selected = true;
break;
}
}
},
p(changed, ctx) {
if ((changed.current) && select_value_value !== (select_value_value = ctx.current)) {
for (var i = 0; i < select.options.length; i += 1) {
var option_2 = select.options[i];
if (option_2.__value === select_value_value) {
option_2.selected = true;
break;
}
}
}
},
d(detach) {
if (detach) {
detachNode(select);
}
}
};
}
function SvelteComponent(options) {
init(this, options);
this._state = assign({}, options.data);
this._intro = true;
this._fragment = create_main_fragment(this, this._state);
if (options.target) {
this._fragment.c();
this._mount(options.target, options.anchor);
}
}
assign(SvelteComponent.prototype, proto);
export default SvelteComponent;

@ -0,0 +1,73 @@
/* generated by Svelte vX.Y.Z */
import { append, assign, createElement, createText, detachNode, init, insert, proto } from "svelte/shared.js";
function create_main_fragment(component, ctx) {
var select, option, text, option_1, text_1, select_value_value;
return {
c() {
select = createElement("select");
option = createElement("option");
text = createText("1");
option_1 = createElement("option");
text_1 = createText("2");
option.__value = "1";
option.value = option.__value;
option_1.__value = "2";
option_1.value = option_1.__value;
},
m(target, anchor) {
insert(target, select, anchor);
append(select, option);
append(option, text);
append(select, option_1);
append(option_1, text_1);
select_value_value = ctx.current;
for (var i = 0; i < select.options.length; i += 1) {
var option_2 = select.options[i];
if (option_2.__value === select_value_value) {
option_2.selected = true;
break;
}
}
},
p(changed, ctx) {
if ((changed.current) && select_value_value !== (select_value_value = ctx.current)) {
for (var i = 0; i < select.options.length; i += 1) {
var option_2 = select.options[i];
if (option_2.__value === select_value_value) {
option_2.selected = true;
break;
}
}
}
},
d(detach) {
if (detach) {
detachNode(select);
}
}
};
}
function SvelteComponent(options) {
init(this, options);
this._state = assign({}, options.data);
this._intro = true;
this._fragment = create_main_fragment(this, this._state);
if (options.target) {
this._fragment.c();
this._mount(options.target, options.anchor);
}
}
assign(SvelteComponent.prototype, proto);
export default SvelteComponent;

@ -0,0 +1,4 @@
<select value={current}>
<option value="1">1</option>
<option value="2">2</option>
</select>

@ -0,0 +1,20 @@
export default {
data: {
target: 'World!',
display: true,
},
html: `
<h1></h1>
`,
test ( assert, component, target, window ) {
const header = target.querySelector( 'h1' );
const eventClick = new window.MouseEvent( 'click' );
header.dispatchEvent( eventClick );
assert.htmlEqual( target.innerHTML, `
<h1>Hello World!</h1>
` );
}
};

@ -0,0 +1,21 @@
<h1 use:insert="display ? `Hello ${target}` : ''"></h1>
<script>
export default {
actions: {
insert(node, text) {
function onClick() {
node.textContent = text;
}
node.addEventListener('click', onClick);
return {
destroy() {
node.removeEventListener('click', onClick);
}
}
}
}
}
</script>

@ -0,0 +1,3 @@
export default {
html: `<div class="one"></div>`
};

@ -0,0 +1 @@
<div class:one="true"></div>

@ -0,0 +1,14 @@
export default {
data: {
user: { active: true }
},
html: `<div class="active"></div>`,
test ( assert, component, target, window ) {
component.set({ user: { active: false }});
assert.htmlEqual( target.innerHTML, `
<div class></div>
` );
}
};

@ -0,0 +1,11 @@
<div class:active="isActive(user)"></div>
<script>
export default {
helpers: {
isActive(user) {
return user.active;
}
}
}
</script>

@ -0,0 +1,3 @@
export default {
html: `<div class="one two three"></div>`
};

@ -0,0 +1 @@
<div class="one" class:two="true" class:three="true"></div>

@ -0,0 +1,14 @@
export default {
data: {
myClass: 'one two'
},
html: `<div class="one two three"></div>`,
test ( assert, component, target, window ) {
component.set({ myClass: 'one' });
assert.htmlEqual( target.innerHTML, `
<div class="one three"></div>
` );
}
};

@ -0,0 +1 @@
<div class="{ myClass }" class:three="true"></div>

@ -0,0 +1,8 @@
export default {
nestedTransitions: true,
test ( assert, component, target ) {
// Would cause "TypeError: Cannot read property 'o' of undefined"
component.set({ foo: false });
}
};

@ -0,0 +1,16 @@
{#if foo}
{#if false}
<Component/>
{:elseif false}
<Component/>
{/if}
{/if}
<script>
export default {
components: {
Component: './Component.html',
},
data: () => ({ foo: true }),
}
</script>

@ -0,0 +1,9 @@
export default {
test(assert, component, target, window, raf) {
const div = target.querySelector('div');
assert.equal(div.foo, 42);
raf.tick(50);
assert.equal(div.foo, 42);
}
};

@ -0,0 +1,20 @@
<div transition:foo></div>
<script>
export default {
data() {
return { x: 42 };
},
transitions: {
foo(node, params) {
return {
duration: 100,
tick: t => {
node.foo = this.get().x;
}
};
}
}
};
</script>
Loading…
Cancel
Save