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

update tests

Browse Source
pull/1670/head
Rich Harris 7 years ago
parent f47d65bd26
commit d323f51e6c
65 changed files with 901 additions and 465 deletions
Show Stats Download Patch File Download Diff File

21
test/cli/samples/basic/expected/Main.js
Unescape View File

@ -65,11 +65,18 @@ function detachNode(node) {
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function assign(tar, src) { function assign(tar, src) {
@ -125,11 +132,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {
@ -165,6 +168,14 @@ function blankObject() {
return Object.create(null); return Object.create(null);
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function callAll(fns) { function callAll(fns) {
while (fns && fns.length) fns.shift()(); while (fns && fns.length) fns.shift()();
} }

21
test/cli/samples/custom-element/expected/Main.js
Unescape View File

@ -86,11 +86,18 @@ function detachNode(node) {
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function assign(tar, src) { function assign(tar, src) {
@ -146,11 +153,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {
@ -186,6 +189,14 @@ function blankObject() {
return Object.create(null); return Object.create(null);
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function callAll(fns) { function callAll(fns) {
while (fns && fns.length) fns.shift()(); while (fns && fns.length) fns.shift()();
} }

21
test/cli/samples/dev/expected/Main.js
Unescape View File

@ -89,11 +89,18 @@ function detachNode(node) {
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function assign(tar, src) { function assign(tar, src) {
@ -200,11 +207,15 @@ function destroy(detach) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate); }
callAll(this.root._oncreate);
callAll(this.root._aftercreate); function flush(component) {
this.root._lock = false; component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
} }
function callAll(fns) { function callAll(fns) {

37
test/cli/samples/dir-sourcemap/expected/Main.js
Unescape View File

@ -32,23 +32,13 @@ function Main(options) {
this._state = assign({}, options.data); this._state = assign({}, options.data);
this._intro = true; this._intro = true;
if (!options.root) {
this._oncreate = [];
this._beforecreate = [];
this._aftercreate = [];
}
this._fragment = create_main_fragment(this, this._state); this._fragment = create_main_fragment(this, this._state);
if (options.target) { if (options.target) {
this._fragment.c(); this._fragment.c();
this._mount(options.target, options.anchor); this._mount(options.target, options.anchor);
this._lock = true; flush(this);
callAll(this._beforecreate);
callAll(this._oncreate);
callAll(this._aftercreate);
this._lock = false;
} }
} }
@ -69,11 +59,18 @@ function noop() {}
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function assign(tar, src) { function assign(tar, src) {
@ -81,8 +78,12 @@ function assign(tar, src) {
return tar; return tar;
} }
function callAll(fns) { function flush(component) {
while (fns && fns.length) fns.shift()(); component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
} }
function destroy(detach) { function destroy(detach) {
@ -133,11 +134,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {
@ -172,5 +169,9 @@ function _differs(a, b) {
function blankObject() { function blankObject() {
return Object.create(null); return Object.create(null);
} }
function callAll(fns) {
while (fns && fns.length) fns.shift()();
}
export default Main; export default Main;
//# sourceMappingURL=Main.js.map //# sourceMappingURL=Main.js.map

2
test/cli/samples/dir-sourcemap/expected/Main.js.map
Unescape View File

@ -1 +1 @@
{"version":3,"file":"Main.js","sources":["../src/Main.html"],"sourcesContent":["<Widget/>\n\n<script>\n\timport Widget from './Widget.html';\n\n\texport default {\n\t\tcomponents: {\n\t\t\tWidget\n\t\t}\n\t};\n</script>"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"} {"version":3,"file":"Main.js","sources":["../src/Main.html"],"sourcesContent":["<Widget/>\n\n<script>\n\timport Widget from './Widget.html';\n\n\texport default {\n\t\tcomponents: {\n\t\t\tWidget\n\t\t}\n\t};\n</script>"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

21
test/cli/samples/dir-sourcemap/expected/Widget.js
Unescape View File

@ -65,11 +65,18 @@ function detachNode(node) {
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function assign(tar, src) { function assign(tar, src) {
@ -125,11 +132,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {
@ -165,6 +168,14 @@ function blankObject() {
return Object.create(null); return Object.create(null);
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function callAll(fns) { function callAll(fns) {
while (fns && fns.length) fns.shift()(); while (fns && fns.length) fns.shift()();
} }

2
test/cli/samples/dir-sourcemap/expected/Widget.js.map
Unescape View File

@ -1 +1 @@
{"version":3,"file":"Widget.js","sources":["../src/Widget.html"],"sourcesContent":["<p>widget</p>"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"} {"version":3,"file":"Widget.js","sources":["../src/Widget.html"],"sourcesContent":["<p>widget</p>"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

37
test/cli/samples/dir-subdir/expected/Main.js
Unescape View File

@ -32,23 +32,13 @@ function Main(options) {
this._state = assign({}, options.data); this._state = assign({}, options.data);
this._intro = true; this._intro = true;
if (!options.root) {
this._oncreate = [];
this._beforecreate = [];
this._aftercreate = [];
}
this._fragment = create_main_fragment(this, this._state); this._fragment = create_main_fragment(this, this._state);
if (options.target) { if (options.target) {
this._fragment.c(); this._fragment.c();
this._mount(options.target, options.anchor); this._mount(options.target, options.anchor);
this._lock = true; flush(this);
callAll(this._beforecreate);
callAll(this._oncreate);
callAll(this._aftercreate);
this._lock = false;
} }
} }
@ -69,11 +59,18 @@ function noop() {}
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function assign(tar, src) { function assign(tar, src) {
@ -81,8 +78,12 @@ function assign(tar, src) {
return tar; return tar;
} }
function callAll(fns) { function flush(component) {
while (fns && fns.length) fns.shift()(); component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
} }
function destroy(detach) { function destroy(detach) {
@ -133,11 +134,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {
@ -172,4 +169,8 @@ function _differs(a, b) {
function blankObject() { function blankObject() {
return Object.create(null); return Object.create(null);
} }
function callAll(fns) {
while (fns && fns.length) fns.shift()();
}
export default Main; export default Main;

21
test/cli/samples/dir-subdir/expected/widget/Widget.js
Unescape View File

@ -65,11 +65,18 @@ function detachNode(node) {
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function assign(tar, src) { function assign(tar, src) {
@ -125,11 +132,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {
@ -165,6 +168,14 @@ function blankObject() {
return Object.create(null); return Object.create(null);
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function callAll(fns) { function callAll(fns) {
while (fns && fns.length) fns.shift()(); while (fns && fns.length) fns.shift()();
} }

37
test/cli/samples/dir/expected/Main.js
Unescape View File

@ -32,23 +32,13 @@ function Main(options) {
this._state = assign({}, options.data); this._state = assign({}, options.data);
this._intro = true; this._intro = true;
if (!options.root) {
this._oncreate = [];
this._beforecreate = [];
this._aftercreate = [];
}
this._fragment = create_main_fragment(this, this._state); this._fragment = create_main_fragment(this, this._state);
if (options.target) { if (options.target) {
this._fragment.c(); this._fragment.c();
this._mount(options.target, options.anchor); this._mount(options.target, options.anchor);
this._lock = true; flush(this);
callAll(this._beforecreate);
callAll(this._oncreate);
callAll(this._aftercreate);
this._lock = false;
} }
} }
@ -69,11 +59,18 @@ function noop() {}
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function assign(tar, src) { function assign(tar, src) {
@ -81,8 +78,12 @@ function assign(tar, src) {
return tar; return tar;
} }
function callAll(fns) { function flush(component) {
while (fns && fns.length) fns.shift()(); component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
} }
function destroy(detach) { function destroy(detach) {
@ -133,11 +134,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {
@ -172,4 +169,8 @@ function _differs(a, b) {
function blankObject() { function blankObject() {
return Object.create(null); return Object.create(null);
} }
function callAll(fns) {
while (fns && fns.length) fns.shift()();
}
export default Main; export default Main;

21
test/cli/samples/dir/expected/Widget.js
Unescape View File

@ -65,11 +65,18 @@ function detachNode(node) {
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function assign(tar, src) { function assign(tar, src) {
@ -125,11 +132,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {
@ -165,6 +168,14 @@ function blankObject() {
return Object.create(null); return Object.create(null);
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function callAll(fns) { function callAll(fns) {
while (fns && fns.length) fns.shift()(); while (fns && fns.length) fns.shift()();
} }

21
test/cli/samples/globals/expected/Main.js
Unescape View File

@ -90,11 +90,18 @@ var Main = (function(answer) { "use strict";
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function assign(tar, src) { function assign(tar, src) {
@ -150,11 +157,7 @@ var Main = (function(answer) { "use strict";
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {
@ -192,6 +195,14 @@ var Main = (function(answer) { "use strict";
return Object.create(null); return Object.create(null);
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function callAll(fns) { function callAll(fns) {
while (fns && fns.length) fns.shift()(); while (fns && fns.length) fns.shift()();
} }

23
test/cli/samples/sourcemap-inline/expected/Main.js
Unescape View File

@ -65,11 +65,18 @@ function detachNode(node) {
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function assign(tar, src) { function assign(tar, src) {
@ -125,11 +132,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {
@ -165,8 +168,16 @@ function blankObject() {
return Object.create(null); return Object.create(null);
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function callAll(fns) { function callAll(fns) {
while (fns && fns.length) fns.shift()(); while (fns && fns.length) fns.shift()();
} }
export default Main; export default Main;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTWFpbi5qcyIsInNvdXJjZXMiOlsiLi4vc3JjL01haW4uaHRtbCJdLCJzb3VyY2VzQ29udGVudCI6WyI8cD5IZWxsbyB3b3JsZCE8L3A+XG5cbjxzY3JpcHQ+XG5cdGV4cG9ydCBkZWZhdWx0IHtcblx0XHRvbnJlbmRlciAoKSB7XG5cdFx0XHRjb25zb2xlLmxvZyggJ2hlcmUnICk7XG5cdFx0fVxuXHR9O1xuPC9zY3JpcHQ+Il0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9 //# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTWFpbi5qcyIsInNvdXJjZXMiOlsiLi4vc3JjL01haW4uaHRtbCJdLCJzb3VyY2VzQ29udGVudCI6WyI8cD5IZWxsbyB3b3JsZCE8L3A+XG5cbjxzY3JpcHQ+XG5cdGV4cG9ydCBkZWZhdWx0IHtcblx0XHRvbnJlbmRlciAoKSB7XG5cdFx0XHRjb25zb2xlLmxvZyggJ2hlcmUnICk7XG5cdFx0fVxuXHR9O1xuPC9zY3JpcHQ+Il0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

21
test/cli/samples/sourcemap/expected/Main.js
Unescape View File

@ -65,11 +65,18 @@ function detachNode(node) {
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function assign(tar, src) { function assign(tar, src) {
@ -125,11 +132,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {
@ -165,6 +168,14 @@ function blankObject() {
return Object.create(null); return Object.create(null);
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function callAll(fns) { function callAll(fns) {
while (fns && fns.length) fns.shift()(); while (fns && fns.length) fns.shift()();
} }

2
test/cli/samples/sourcemap/expected/Main.js.map
Unescape View File

@ -1 +1 @@
{"version":3,"file":"Main.js","sources":["../src/Main.html"],"sourcesContent":["<p>Hello world!</p>\n\n<script>\n\texport default {\n\t\tonrender () {\n\t\t\tconsole.log( 'here' );\n\t\t}\n\t};\n</script>"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"} {"version":3,"file":"Main.js","sources":["../src/Main.html"],"sourcesContent":["<p>Hello world!</p>\n\n<script>\n\texport default {\n\t\tonrender () {\n\t\t\tconsole.log( 'here' );\n\t\t}\n\t};\n</script>"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

21
test/cli/samples/store/expected/Main.js
Unescape View File

@ -85,11 +85,18 @@ function detachNode(node) {
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function assign(tar, src) { function assign(tar, src) {
@ -149,11 +156,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {
@ -191,6 +194,14 @@ function blankObject() {
return Object.create(null); return Object.create(null);
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function callAll(fns) { function callAll(fns) {
while (fns && fns.length) fns.shift()(); while (fns && fns.length) fns.shift()();
} }

21
test/js/samples/action/expected-bundle.js
Unescape View File

@ -54,17 +54,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -82,11 +97,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {

28
test/js/samples/bind-width-height/expected-bundle.js
Unescape View File

@ -86,17 +86,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -114,11 +129,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {
@ -200,18 +211,13 @@ function SvelteComponent(options) {
this._state = assign({}, options.data); this._state = assign({}, options.data);
this._intro = true; this._intro = true;
if (!options.root) {
this._oncreate = [];
this._beforecreate = [];
}
this._fragment = create_main_fragment(this, this._state); this._fragment = create_main_fragment(this, this._state);
if (options.target) { if (options.target) {
this._fragment.c(); this._fragment.c();
this._mount(options.target, options.anchor); this._mount(options.target, options.anchor);
callAll(this._beforecreate); flush(this);
} }
} }

9
test/js/samples/bind-width-height/expected.js
Unescape View File

@ -1,5 +1,5 @@
/* generated by Svelte vX.Y.Z */ /* generated by Svelte vX.Y.Z */
import { addResizeListener, assign, callAll, createElement, detachNode, init, insert, noop, proto } from "svelte/shared.js"; import { addResizeListener, assign, createElement, detachNode, flush, init, insert, noop, proto } from "svelte/shared.js";
function create_main_fragment(component, ctx) { function create_main_fragment(component, ctx) {
var div, div_resize_listener; var div, div_resize_listener;
@ -37,18 +37,13 @@ function SvelteComponent(options) {
this._state = assign({}, options.data); this._state = assign({}, options.data);
this._intro = true; this._intro = true;
if (!options.root) {
this._oncreate = [];
this._beforecreate = [];
}
this._fragment = create_main_fragment(this, this._state); this._fragment = create_main_fragment(this, this._state);
if (options.target) { if (options.target) {
this._fragment.c(); this._fragment.c();
this._mount(options.target, options.anchor); this._mount(options.target, options.anchor);
callAll(this._beforecreate); flush(this);
} }
} }

21
test/js/samples/collapses-text-around-comments/expected-bundle.js
Unescape View File

@ -66,17 +66,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -94,11 +109,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {

33
test/js/samples/component-static-array/expected-bundle.js
Unescape View File

@ -42,17 +42,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -70,11 +85,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {
@ -153,23 +164,13 @@ function SvelteComponent(options) {
this._state = assign({}, options.data); this._state = assign({}, options.data);
this._intro = true; this._intro = true;
if (!options.root) {
this._oncreate = [];
this._beforecreate = [];
this._aftercreate = [];
}
this._fragment = create_main_fragment(this, this._state); this._fragment = create_main_fragment(this, this._state);
if (options.target) { if (options.target) {
this._fragment.c(); this._fragment.c();
this._mount(options.target, options.anchor); this._mount(options.target, options.anchor);
this._lock = true; flush(this);
callAll(this._beforecreate);
callAll(this._oncreate);
callAll(this._aftercreate);
this._lock = false;
} }
} }

14
test/js/samples/component-static-array/expected.js
Unescape View File

@ -1,5 +1,5 @@
/* generated by Svelte vX.Y.Z */ /* generated by Svelte vX.Y.Z */
import { assign, callAll, init, noop, proto } from "svelte/shared.js"; import { assign, flush, init, noop, proto } from "svelte/shared.js";
var Nested = window.Nested; var Nested = window.Nested;
@ -34,23 +34,13 @@ function SvelteComponent(options) {
this._state = assign({}, options.data); this._state = assign({}, options.data);
this._intro = true; this._intro = true;
if (!options.root) {
this._oncreate = [];
this._beforecreate = [];
this._aftercreate = [];
}
this._fragment = create_main_fragment(this, this._state); this._fragment = create_main_fragment(this, this._state);
if (options.target) { if (options.target) {
this._fragment.c(); this._fragment.c();
this._mount(options.target, options.anchor); this._mount(options.target, options.anchor);
this._lock = true; flush(this);
callAll(this._beforecreate);
callAll(this._oncreate);
callAll(this._aftercreate);
this._lock = false;
} }
} }

33
test/js/samples/component-static-immutable/expected-bundle.js
Unescape View File

@ -46,17 +46,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -74,11 +89,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {
@ -157,23 +168,13 @@ function SvelteComponent(options) {
this._state = assign({}, options.data); this._state = assign({}, options.data);
this._intro = true; this._intro = true;
if (!options.root) {
this._oncreate = [];
this._beforecreate = [];
this._aftercreate = [];
}
this._fragment = create_main_fragment(this, this._state); this._fragment = create_main_fragment(this, this._state);
if (options.target) { if (options.target) {
this._fragment.c(); this._fragment.c();
this._mount(options.target, options.anchor); this._mount(options.target, options.anchor);
this._lock = true; flush(this);
callAll(this._beforecreate);
callAll(this._oncreate);
callAll(this._aftercreate);
this._lock = false;
} }
} }

14
test/js/samples/component-static-immutable/expected.js
Unescape View File

@ -1,5 +1,5 @@
/* generated by Svelte vX.Y.Z */ /* generated by Svelte vX.Y.Z */
import { _differsImmutable, assign, callAll, init, noop, proto } from "svelte/shared.js"; import { _differsImmutable, assign, flush, init, noop, proto } from "svelte/shared.js";
var Nested = window.Nested; var Nested = window.Nested;
@ -34,23 +34,13 @@ function SvelteComponent(options) {
this._state = assign({}, options.data); this._state = assign({}, options.data);
this._intro = true; this._intro = true;
if (!options.root) {
this._oncreate = [];
this._beforecreate = [];
this._aftercreate = [];
}
this._fragment = create_main_fragment(this, this._state); this._fragment = create_main_fragment(this, this._state);
if (options.target) { if (options.target) {
this._fragment.c(); this._fragment.c();
this._mount(options.target, options.anchor); this._mount(options.target, options.anchor);
this._lock = true; flush(this);
callAll(this._beforecreate);
callAll(this._oncreate);
callAll(this._aftercreate);
this._lock = false;
} }
} }

33
test/js/samples/component-static-immutable2/expected-bundle.js
Unescape View File

@ -46,17 +46,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -74,11 +89,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {
@ -157,23 +168,13 @@ function SvelteComponent(options) {
this._state = assign({}, options.data); this._state = assign({}, options.data);
this._intro = true; this._intro = true;
if (!options.root) {
this._oncreate = [];
this._beforecreate = [];
this._aftercreate = [];
}
this._fragment = create_main_fragment(this, this._state); this._fragment = create_main_fragment(this, this._state);
if (options.target) { if (options.target) {
this._fragment.c(); this._fragment.c();
this._mount(options.target, options.anchor); this._mount(options.target, options.anchor);
this._lock = true; flush(this);
callAll(this._beforecreate);
callAll(this._oncreate);
callAll(this._aftercreate);
this._lock = false;
} }
} }

14
test/js/samples/component-static-immutable2/expected.js
Unescape View File

@ -1,5 +1,5 @@
/* generated by Svelte vX.Y.Z */ /* generated by Svelte vX.Y.Z */
import { _differsImmutable, assign, callAll, init, noop, proto } from "svelte/shared.js"; import { _differsImmutable, assign, flush, init, noop, proto } from "svelte/shared.js";
var Nested = window.Nested; var Nested = window.Nested;
@ -34,23 +34,13 @@ function SvelteComponent(options) {
this._state = assign({}, options.data); this._state = assign({}, options.data);
this._intro = true; this._intro = true;
if (!options.root) {
this._oncreate = [];
this._beforecreate = [];
this._aftercreate = [];
}
this._fragment = create_main_fragment(this, this._state); this._fragment = create_main_fragment(this, this._state);
if (options.target) { if (options.target) {
this._fragment.c(); this._fragment.c();
this._mount(options.target, options.anchor); this._mount(options.target, options.anchor);
this._lock = true; flush(this);
callAll(this._beforecreate);
callAll(this._oncreate);
callAll(this._aftercreate);
this._lock = false;
} }
} }

33
test/js/samples/component-static/expected-bundle.js
Unescape View File

@ -42,17 +42,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -70,11 +85,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {
@ -153,23 +164,13 @@ function SvelteComponent(options) {
this._state = assign({}, options.data); this._state = assign({}, options.data);
this._intro = true; this._intro = true;
if (!options.root) {
this._oncreate = [];
this._beforecreate = [];
this._aftercreate = [];
}
this._fragment = create_main_fragment(this, this._state); this._fragment = create_main_fragment(this, this._state);
if (options.target) { if (options.target) {
this._fragment.c(); this._fragment.c();
this._mount(options.target, options.anchor); this._mount(options.target, options.anchor);
this._lock = true; flush(this);
callAll(this._beforecreate);
callAll(this._oncreate);
callAll(this._aftercreate);
this._lock = false;
} }
} }

14
test/js/samples/component-static/expected.js
Unescape View File

@ -1,5 +1,5 @@
/* generated by Svelte vX.Y.Z */ /* generated by Svelte vX.Y.Z */
import { assign, callAll, init, noop, proto } from "svelte/shared.js"; import { assign, flush, init, noop, proto } from "svelte/shared.js";
var Nested = window.Nested; var Nested = window.Nested;
@ -34,23 +34,13 @@ function SvelteComponent(options) {
this._state = assign({}, options.data); this._state = assign({}, options.data);
this._intro = true; this._intro = true;
if (!options.root) {
this._oncreate = [];
this._beforecreate = [];
this._aftercreate = [];
}
this._fragment = create_main_fragment(this, this._state); this._fragment = create_main_fragment(this, this._state);
if (options.target) { if (options.target) {
this._fragment.c(); this._fragment.c();
this._mount(options.target, options.anchor); this._mount(options.target, options.anchor);
this._lock = true; flush(this);
callAll(this._beforecreate);
callAll(this._oncreate);
callAll(this._aftercreate);
this._lock = false;
} }
} }

21
test/js/samples/computed-collapsed-if/expected-bundle.js
Unescape View File

@ -42,17 +42,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -70,11 +85,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {

21
test/js/samples/css-media-query/expected-bundle.js
Unescape View File

@ -58,17 +58,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -86,11 +101,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {

21
test/js/samples/css-shadow-dom-keyframes/expected-bundle.js
Unescape View File

@ -54,17 +54,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -82,11 +97,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {

21
test/js/samples/debug-empty/expected-bundle.js
Unescape View File

@ -79,17 +79,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -107,11 +122,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {

21
test/js/samples/debug-foo-bar-baz-things/expected-bundle.js
Unescape View File

@ -85,17 +85,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -113,11 +128,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {

21
test/js/samples/debug-foo/expected-bundle.js
Unescape View File

@ -85,17 +85,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -113,11 +128,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {

21
test/js/samples/deconflict-builtins/expected-bundle.js
Unescape View File

@ -76,17 +76,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -104,11 +119,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {

27
test/js/samples/deconflict-globals/expected-bundle.js
Unescape View File

@ -47,17 +47,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -75,11 +90,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {
@ -152,10 +163,6 @@ function SvelteComponent(options) {
this._state = assign(data_1(), options.data); this._state = assign(data_1(), options.data);
this._intro = true; this._intro = true;
if (!options.root) {
this._oncreate = [];
}
this._fragment = create_main_fragment(this, this._state); this._fragment = create_main_fragment(this, this._state);
this.root._oncreate.push(() => { this.root._oncreate.push(() => {
@ -167,7 +174,7 @@ function SvelteComponent(options) {
this._fragment.c(); this._fragment.c();
this._mount(options.target, options.anchor); this._mount(options.target, options.anchor);
callAll(this._oncreate); flush(this);
} }
} }

8
test/js/samples/deconflict-globals/expected.js
Unescape View File

@ -1,5 +1,5 @@
/* generated by Svelte vX.Y.Z */ /* generated by Svelte vX.Y.Z */
import { assign, assignTrue, callAll, init, noop, proto } from "svelte/shared.js"; import { assign, assignTrue, flush, init, noop, proto } from "svelte/shared.js";
function data_1() { function data_1() {
return { return {
@ -29,10 +29,6 @@ function SvelteComponent(options) {
this._state = assign(data_1(), options.data); this._state = assign(data_1(), options.data);
this._intro = true; this._intro = true;
if (!options.root) {
this._oncreate = [];
}
this._fragment = create_main_fragment(this, this._state); this._fragment = create_main_fragment(this, this._state);
this.root._oncreate.push(() => { this.root._oncreate.push(() => {
@ -44,7 +40,7 @@ function SvelteComponent(options) {
this._fragment.c(); this._fragment.c();
this._mount(options.target, options.anchor); this._mount(options.target, options.anchor);
callAll(this._oncreate); flush(this);
} }
} }

21
test/js/samples/dev-warning-missing-data-computed/expected-bundle.js
Unescape View File

@ -79,17 +79,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -107,11 +122,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {

21
test/js/samples/do-use-dataset/expected-bundle.js
Unescape View File

@ -58,17 +58,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -86,11 +101,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {

21
test/js/samples/dont-use-dataset-in-legacy/expected-bundle.js
Unescape View File

@ -62,17 +62,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -90,11 +105,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {

21
test/js/samples/dont-use-dataset-in-svg/expected-bundle.js
Unescape View File

@ -62,17 +62,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -90,11 +105,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {

21
test/js/samples/each-block-changed-check/expected-bundle.js
Unescape View File

@ -78,17 +78,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -106,11 +121,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {

21
test/js/samples/each-block-keyed-animated/expected-bundle.js
Unescape View File

@ -381,17 +381,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -409,11 +424,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {

21
test/js/samples/each-block-keyed/expected-bundle.js
Unescape View File

@ -161,17 +161,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -189,11 +204,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {

21
test/js/samples/event-handlers-custom/expected-bundle.js
Unescape View File

@ -54,17 +54,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -82,11 +97,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {

21
test/js/samples/head-no-whitespace/expected-bundle.js
Unescape View File

@ -54,17 +54,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -82,11 +97,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {

21
test/js/samples/if-block-no-update/expected-bundle.js
Unescape View File

@ -58,17 +58,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -86,11 +101,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {

21
test/js/samples/if-block-simple/expected-bundle.js
Unescape View File

@ -58,17 +58,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -86,11 +101,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {

21
test/js/samples/inline-style-optimized-multiple/expected-bundle.js
Unescape View File

@ -58,17 +58,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -86,11 +101,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {

21
test/js/samples/inline-style-optimized-url/expected-bundle.js
Unescape View File

@ -58,17 +58,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -86,11 +101,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {

21
test/js/samples/inline-style-optimized/expected-bundle.js
Unescape View File

@ -58,17 +58,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -86,11 +101,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {

21
test/js/samples/inline-style-unoptimized/expected-bundle.js
Unescape View File

@ -58,17 +58,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -86,11 +101,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {

21
test/js/samples/input-files/expected-bundle.js
Unescape View File

@ -66,17 +66,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -94,11 +109,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {

21
test/js/samples/input-range/expected-bundle.js
Unescape View File

@ -70,17 +70,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -98,11 +113,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {

21
test/js/samples/input-without-blowback-guard/expected-bundle.js
Unescape View File

@ -66,17 +66,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -94,11 +109,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {

21
test/js/samples/legacy-input-type/expected-bundle.js
Unescape View File

@ -60,17 +60,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -88,11 +103,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {

28
test/js/samples/media-bindings/expected-bundle.js
Unescape View File

@ -70,17 +70,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -98,11 +113,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {
@ -232,18 +243,13 @@ function SvelteComponent(options) {
this._state = assign({}, options.data); this._state = assign({}, options.data);
this._intro = true; this._intro = true;
if (!options.root) {
this._oncreate = [];
this._beforecreate = [];
}
this._fragment = create_main_fragment(this, this._state); this._fragment = create_main_fragment(this, this._state);
if (options.target) { if (options.target) {
this._fragment.c(); this._fragment.c();
this._mount(options.target, options.anchor); this._mount(options.target, options.anchor);
callAll(this._beforecreate); flush(this);
} }
} }

9
test/js/samples/media-bindings/expected.js
Unescape View File

@ -1,5 +1,5 @@
/* generated by Svelte vX.Y.Z */ /* generated by Svelte vX.Y.Z */
import { addListener, assign, callAll, createElement, detachNode, init, insert, proto, removeListener, timeRangesToArray } from "svelte/shared.js"; import { addListener, assign, createElement, detachNode, flush, init, insert, proto, removeListener, timeRangesToArray } from "svelte/shared.js";
function create_main_fragment(component, ctx) { function create_main_fragment(component, ctx) {
var audio, audio_is_paused = true, audio_updating = false, audio_animationframe; var audio, audio_is_paused = true, audio_updating = false, audio_animationframe;
@ -85,18 +85,13 @@ function SvelteComponent(options) {
this._state = assign({}, options.data); this._state = assign({}, options.data);
this._intro = true; this._intro = true;
if (!options.root) {
this._oncreate = [];
this._beforecreate = [];
}
this._fragment = create_main_fragment(this, this._state); this._fragment = create_main_fragment(this, this._state);
if (options.target) { if (options.target) {
this._fragment.c(); this._fragment.c();
this._mount(options.target, options.anchor); this._mount(options.target, options.anchor);
callAll(this._beforecreate); flush(this);
} }
} }

33
test/js/samples/non-imported-component/expected-bundle.js
Unescape View File

@ -56,17 +56,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -84,11 +99,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {
@ -180,23 +191,13 @@ function SvelteComponent(options) {
this._state = assign({}, options.data); this._state = assign({}, options.data);
this._intro = true; this._intro = true;
if (!options.root) {
this._oncreate = [];
this._beforecreate = [];
this._aftercreate = [];
}
this._fragment = create_main_fragment(this, this._state); this._fragment = create_main_fragment(this, this._state);
if (options.target) { if (options.target) {
this._fragment.c(); this._fragment.c();
this._mount(options.target, options.anchor); this._mount(options.target, options.anchor);
this._lock = true; flush(this);
callAll(this._beforecreate);
callAll(this._oncreate);
callAll(this._aftercreate);
this._lock = false;
} }
} }

14
test/js/samples/non-imported-component/expected.js
Unescape View File

@ -1,5 +1,5 @@
/* generated by Svelte vX.Y.Z */ /* generated by Svelte vX.Y.Z */
import { assign, callAll, createText, detachNode, init, insert, noop, proto } from "svelte/shared.js"; import { assign, createText, detachNode, flush, init, insert, noop, proto } from "svelte/shared.js";
import Imported from 'Imported.html'; import Imported from 'Imported.html';
@ -48,23 +48,13 @@ function SvelteComponent(options) {
this._state = assign({}, options.data); this._state = assign({}, options.data);
this._intro = true; this._intro = true;
if (!options.root) {
this._oncreate = [];
this._beforecreate = [];
this._aftercreate = [];
}
this._fragment = create_main_fragment(this, this._state); this._fragment = create_main_fragment(this, this._state);
if (options.target) { if (options.target) {
this._fragment.c(); this._fragment.c();
this._mount(options.target, options.anchor); this._mount(options.target, options.anchor);
this._lock = true; flush(this);
callAll(this._beforecreate);
callAll(this._oncreate);
callAll(this._aftercreate);
this._lock = false;
} }
} }

21
test/js/samples/setup-method/expected-bundle.js
Unescape View File

@ -42,17 +42,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -70,11 +85,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {

21
test/js/samples/svg-title/expected-bundle.js
Unescape View File

@ -62,17 +62,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -90,11 +105,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {

21
test/js/samples/title/expected-bundle.js
Unescape View File

@ -42,17 +42,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -70,11 +85,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {

21
test/js/samples/use-elements-as-anchors/expected-bundle.js
Unescape View File

@ -66,17 +66,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -94,11 +109,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {

21
test/js/samples/window-binding-scroll/expected-bundle.js
Unescape View File

@ -66,17 +66,32 @@ function fire(eventName, data) {
} }
} }
function flush(component) {
component._lock = true;
callAll(component._beforecreate);
callAll(component._oncreate);
callAll(component._aftercreate);
component._lock = false;
}
function get() { function get() {
return this._state; return this._state;
} }
function init(component, options) { function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
component.store = options.store || component.root.store; component.store = options.store || component.root.store;
if (!options.root) {
component._beforecreate = [];
component._oncreate = [];
component._aftercreate = [];
}
} }
function on(eventName, handler) { function on(eventName, handler) {
@ -94,11 +109,7 @@ function on(eventName, handler) {
function set(newState) { function set(newState) {
this._set(assign({}, newState)); this._set(assign({}, newState));
if (this.root._lock) return; if (this.root._lock) return;
this.root._lock = true; flush(this.root);
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
} }
function _set(newState) { function _set(newState) {

Write Preview
Loading…
Cancel
Save