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

alternative approach to

Browse Source
pull/1691/head
Rich Harris 7 years ago
parent 33ed2f504e
commit c2f0ca3e2e
63 changed files with 655 additions and 868 deletions

2
src/compile/dom/index.ts
Unescape View File

@ -132,7 +132,7 @@ export default function dom(
? `@proto` ? `@proto`
: deindent` : deindent`
{ {
${['destroy', 'get', 'fire', 'on', 'set', '_set', '_mount', '_differs'] ${['destroy', 'get', 'fire', 'on', 'set', '_set', '_stage', '_mount', '_differs']
.map(n => `${n}: @${n}`) .map(n => `${n}: @${n}`)
.join(',\n')} .join(',\n')}
}`; }`;

27
src/shared/index.js
Unescape View File

@ -73,6 +73,7 @@ export function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -103,30 +104,21 @@ export function set(newState) {
flush(this.root); flush(this.root);
} }
export function _set(newState, options) { export function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -135,7 +127,10 @@ export function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
export function _stage(newState) {
assign(this._staged, newState);
} }
export function setDev(newState) { export function setDev(newState) {
@ -173,6 +168,7 @@ export var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };
@ -185,6 +181,7 @@ export var protoDev = {
set: setDev, set: setDev,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

38
store.js
Unescape View File

@ -60,27 +60,27 @@ assign(Store.prototype, {
current: this._state current: this._state
}); });
const dependents = this._dependents.slice(); // guard against mutations this._dependents
const options = { skipRender: true }; .filter(dependent => {
const empty = {}; const componentState = {};
const dirtyDependents = dependents.filter(dependent => { let dirty = false;
const componentState = {};
let dirty = false; for (let j = 0; j < dependent.props.length; j += 1) {
const prop = dependent.props[j];
for (let j = 0; j < dependent.props.length; j += 1) { if (prop in changed) {
const prop = dependent.props[j]; componentState['$' + prop] = this._state[prop];
if (prop in changed) { dirty = true;
componentState['$' + prop] = this._state[prop]; }
dirty = true;
} }
}
if (dirty) { if (dirty) {
return dependent.component._set(componentState, options); dependent.component._stage(componentState);
} return true;
}); }
})
dirtyDependents.forEach(dependent => dependent.component.set(empty)); .forEach(dependent => {
dependent.component.set();
});
this.fire('update', { this.fire('update', {
changed, changed,

26
test/cli/samples/amd/expected/Main.js
Unescape View File

@ -43,6 +43,7 @@ define("test", function() { "use strict";
on: on, on: on,
set: set, set: set,
_set: _set, _set: _set,
_stage: _stage,
_mount: _mount, _mount: _mount,
_differs: _differs _differs: _differs
}); });
@ -67,6 +68,7 @@ define("test", function() { "use strict";
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -135,30 +137,21 @@ define("test", function() { "use strict";
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -167,7 +160,10 @@ define("test", function() { "use strict";
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function _mount(target, anchor) { function _mount(target, anchor) {

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

@ -43,6 +43,7 @@ assign(Main.prototype, {
on: on, on: on,
set: set, set: set,
_set: _set, _set: _set,
_stage: _stage,
_mount: _mount, _mount: _mount,
_differs: _differs _differs: _differs
}); });
@ -67,6 +68,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -135,30 +137,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -167,7 +160,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function _mount(target, anchor) { function _mount(target, anchor) {

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

@ -57,6 +57,7 @@ assign(Main.prototype, {
on: on, on: on,
set: set, set: set,
_set: _set, _set: _set,
_stage: _stage,
_mount: _mount, _mount: _mount,
_differs: _differs _differs: _differs
}); });
@ -88,6 +89,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -156,30 +158,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -188,7 +181,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function _mount(target, anchor) { function _mount(target, anchor) {

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

@ -50,6 +50,7 @@ assign(Main.prototype, {
on: on, on: on,
set: setDev, set: setDev,
_set: _set, _set: _set,
_stage: _stage,
_mount: _mount, _mount: _mount,
_differs: _differs _differs: _differs
}); });
@ -91,6 +92,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -161,30 +163,21 @@ function setDev(newState) {
set.call(this, newState); set.call(this, newState);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -193,7 +186,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function _mount(target, anchor) { function _mount(target, anchor) {

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

@ -49,6 +49,7 @@ assign(Main.prototype, {
on: on, on: on,
set: set, set: set,
_set: _set, _set: _set,
_stage: _stage,
_mount: _mount, _mount: _mount,
_differs: _differs _differs: _differs
}); });
@ -61,6 +62,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -137,30 +139,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -169,7 +162,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function _mount(target, anchor) { function _mount(target, anchor) {

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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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

@ -43,6 +43,7 @@ assign(Widget.prototype, {
on: on, on: on,
set: set, set: set,
_set: _set, _set: _set,
_stage: _stage,
_mount: _mount, _mount: _mount,
_differs: _differs _differs: _differs
}); });
@ -67,6 +68,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -135,30 +137,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -167,7 +160,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function _mount(target, anchor) { function _mount(target, anchor) {

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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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

@ -49,6 +49,7 @@ assign(Main.prototype, {
on: on, on: on,
set: set, set: set,
_set: _set, _set: _set,
_stage: _stage,
_mount: _mount, _mount: _mount,
_differs: _differs _differs: _differs
}); });
@ -61,6 +62,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -137,30 +139,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -169,7 +162,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function _mount(target, anchor) { function _mount(target, anchor) {

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

@ -43,6 +43,7 @@ assign(Widget.prototype, {
on: on, on: on,
set: set, set: set,
_set: _set, _set: _set,
_stage: _stage,
_mount: _mount, _mount: _mount,
_differs: _differs _differs: _differs
}); });
@ -67,6 +68,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -135,30 +137,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -167,7 +160,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function _mount(target, anchor) { function _mount(target, anchor) {

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

@ -49,6 +49,7 @@ assign(Main.prototype, {
on: on, on: on,
set: set, set: set,
_set: _set, _set: _set,
_stage: _stage,
_mount: _mount, _mount: _mount,
_differs: _differs _differs: _differs
}); });
@ -61,6 +62,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -137,30 +139,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -169,7 +162,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function _mount(target, anchor) { function _mount(target, anchor) {

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

@ -43,6 +43,7 @@ assign(Widget.prototype, {
on: on, on: on,
set: set, set: set,
_set: _set, _set: _set,
_stage: _stage,
_mount: _mount, _mount: _mount,
_differs: _differs _differs: _differs
}); });
@ -67,6 +68,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -135,30 +137,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -167,7 +160,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function _mount(target, anchor) { function _mount(target, anchor) {

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

@ -1,4 +1,4 @@
/* src/Main.html generated by Svelte v2.11.0 */ /* src/Main.html generated by Svelte vx.y.z */
var Main = (function(answer) { "use strict"; var Main = (function(answer) { "use strict";
answer = (answer && answer.__esModule) ? answer["default"] : answer; answer = (answer && answer.__esModule) ? answer["default"] : answer;
@ -58,6 +58,7 @@ var Main = (function(answer) { "use strict";
on: on, on: on,
set: set, set: set,
_set: _set, _set: _set,
_stage: _stage,
_mount: _mount, _mount: _mount,
_differs: _differs _differs: _differs
}); });
@ -92,6 +93,7 @@ var Main = (function(answer) { "use strict";
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -160,30 +162,21 @@ var Main = (function(answer) { "use strict";
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -192,7 +185,10 @@ var Main = (function(answer) { "use strict";
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function _mount(target, anchor) { function _mount(target, anchor) {

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

@ -1,4 +1,4 @@
/* src/Main.html generated by Svelte v2.12.0 */ /* src/Main.html generated by Svelte vx.y.z */
function create_main_fragment(component, ctx) { function create_main_fragment(component, ctx) {
var p; var p;
@ -43,6 +43,7 @@ assign(Main.prototype, {
on: on, on: on,
set: set, set: set,
_set: _set, _set: _set,
_stage: _stage,
_mount: _mount, _mount: _mount,
_differs: _differs _differs: _differs
}); });
@ -67,6 +68,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -135,30 +137,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -167,7 +160,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function _mount(target, anchor) { function _mount(target, anchor) {
@ -194,4 +190,4 @@ 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+Il0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ== //# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTWFpbi5qcyIsInNvdXJjZXMiOlsiLi4vc3JjL01haW4uaHRtbCJdLCJzb3VyY2VzQ29udGVudCI6WyI8cD5IZWxsbyB3b3JsZCE8L3A+XG5cbjxzY3JpcHQ+XG5cdGV4cG9ydCBkZWZhdWx0IHtcblx0XHRvbnJlbmRlciAoKSB7XG5cdFx0XHRjb25zb2xlLmxvZyggJ2hlcmUnICk7XG5cdFx0fVxuXHR9O1xuPC9zY3JpcHQ+Il0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

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

@ -43,6 +43,7 @@ assign(Main.prototype, {
on: on, on: on,
set: set, set: set,
_set: _set, _set: _set,
_stage: _stage,
_mount: _mount, _mount: _mount,
_differs: _differs _differs: _differs
}); });
@ -67,6 +68,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -135,30 +137,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -167,7 +160,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function _mount(target, anchor) { function _mount(target, anchor) {

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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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

@ -53,6 +53,7 @@ assign(Main.prototype, {
on: on, on: on,
set: set, set: set,
_set: _set, _set: _set,
_stage: _stage,
_mount: _mount, _mount: _mount,
_differs: _differs _differs: _differs
}); });
@ -87,6 +88,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -159,30 +161,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -191,7 +184,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function _mount(target, anchor) { function _mount(target, anchor) {

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

@ -70,6 +70,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -100,30 +101,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -132,7 +124,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -151,6 +146,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -102,6 +102,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -132,30 +133,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -164,7 +156,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -183,6 +178,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -82,6 +82,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -112,30 +113,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -144,7 +136,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -163,6 +158,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -58,6 +58,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -88,30 +89,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -120,7 +112,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -139,6 +134,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -62,6 +62,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -92,30 +93,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -124,7 +116,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -143,6 +138,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -62,6 +62,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -92,30 +93,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -124,7 +116,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -143,6 +138,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -58,6 +58,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -88,30 +89,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -120,7 +112,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -139,6 +134,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -58,6 +58,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -88,30 +89,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -120,7 +112,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -139,6 +134,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -74,6 +74,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -104,30 +105,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -136,7 +128,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -155,6 +150,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -70,6 +70,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -100,30 +101,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -132,7 +124,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -151,6 +146,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -95,6 +95,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -125,30 +126,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -157,7 +149,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function setDev(newState) { function setDev(newState) {
@ -187,6 +182,7 @@ var protoDev = {
set: setDev, set: setDev,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -101,6 +101,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -131,30 +132,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -163,7 +155,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function setDev(newState) { function setDev(newState) {
@ -193,6 +188,7 @@ var protoDev = {
set: setDev, set: setDev,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -101,6 +101,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -131,30 +132,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -163,7 +155,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function setDev(newState) { function setDev(newState) {
@ -193,6 +188,7 @@ var protoDev = {
set: setDev, set: setDev,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -92,6 +92,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -122,30 +123,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -154,7 +146,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -173,6 +168,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -63,6 +63,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -93,30 +94,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -125,7 +117,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -144,6 +139,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -95,6 +95,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -125,30 +126,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -157,7 +149,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function setDev(newState) { function setDev(newState) {
@ -187,6 +182,7 @@ var protoDev = {
set: setDev, set: setDev,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -74,6 +74,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -104,30 +105,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -136,7 +128,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -155,6 +150,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -78,6 +78,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -108,30 +109,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -140,7 +132,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -159,6 +154,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -78,6 +78,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -108,30 +109,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -140,7 +132,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -159,6 +154,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -94,6 +94,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -124,30 +125,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -156,7 +148,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -175,6 +170,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -397,6 +397,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -427,30 +428,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -459,7 +451,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -478,6 +473,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -177,6 +177,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -207,30 +208,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -239,7 +231,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -258,6 +253,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -70,6 +70,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -100,30 +101,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -132,7 +124,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -151,6 +146,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -70,6 +70,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -100,30 +101,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -132,7 +124,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -151,6 +146,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -74,6 +74,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -104,30 +105,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -136,7 +128,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -155,6 +150,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -74,6 +74,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -104,30 +105,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -136,7 +128,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -155,6 +150,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -74,6 +74,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -104,30 +105,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -136,7 +128,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -155,6 +150,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -74,6 +74,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -104,30 +105,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -136,7 +128,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -155,6 +150,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -74,6 +74,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -104,30 +105,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -136,7 +128,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -155,6 +150,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -74,6 +74,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -104,30 +105,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -136,7 +128,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -155,6 +150,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -82,6 +82,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -112,30 +113,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -144,7 +136,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -163,6 +158,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -86,6 +86,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -116,30 +117,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -148,7 +140,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -167,6 +162,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -82,6 +82,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -112,30 +113,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -144,7 +136,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -163,6 +158,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -76,6 +76,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -106,30 +107,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -138,7 +130,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -157,6 +152,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -86,6 +86,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -116,30 +117,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -148,7 +140,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -167,6 +162,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -72,6 +72,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -102,30 +103,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -134,7 +126,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -153,6 +148,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

10
test/js/samples/select-dynamic-value/expected-bundle.js
Unescape View File

@ -78,6 +78,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -113,12 +114,16 @@ function _set(newState) {
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty) return; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -129,6 +134,10 @@ function _set(newState) {
} }
} }
function _stage(newState) {
assign(this._staged, newState);
}
function callAll(fns) { function callAll(fns) {
while (fns && fns.length) fns.shift()(); while (fns && fns.length) fns.shift()();
} }
@ -145,6 +154,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -58,6 +58,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -88,30 +89,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -120,7 +112,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -139,6 +134,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -78,6 +78,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -108,30 +109,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -140,7 +132,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -159,6 +154,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -58,6 +58,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -88,30 +89,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -120,7 +112,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -139,6 +134,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -82,6 +82,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -112,30 +113,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -144,7 +136,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -163,6 +158,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

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

@ -82,6 +82,7 @@ function init(component, options) {
component._handlers = blankObject(); component._handlers = blankObject();
component._slots = blankObject(); component._slots = blankObject();
component._bind = options._bind; component._bind = options._bind;
component._staged = {};
component.options = options; component.options = options;
component.root = options.root || component; component.root = options.root || component;
@ -112,30 +113,21 @@ function set(newState) {
flush(this.root); flush(this.root);
} }
function _set(newState, options) { function _set(newState) {
var oldState = this._state, var oldState = this._state,
changed = {}, changed = {},
dirty = false; dirty = false;
newState = assign(this._staged, newState);
this._staged = {};
for (var key in newState) { for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true; if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
} }
if (!dirty && !this._changed) return false; if (!dirty) return;
this._state = assign(assign({}, oldState), newState); this._state = assign(assign({}, oldState), newState);
if (options && options.skipRender) {
if (!this._oldState) this._oldState = oldState;
this._changed = assign(changed, this._changed);
return true;
}
if (this._changed) {
oldState = this._oldState;
changed = assign(changed, this._changed),
this._changed = this._oldState = null;
}
this._recompute(changed, this._state); this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state); if (this._bind) this._bind(changed, this._state);
@ -144,7 +136,10 @@ function _set(newState, options) {
this._fragment.p(changed, this._state); this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState }); this.fire("update", { changed: changed, current: this._state, previous: oldState });
} }
return true; }
function _stage(newState) {
assign(this._staged, newState);
} }
function callAll(fns) { function callAll(fns) {
@ -163,6 +158,7 @@ var proto = {
set, set,
_recompute: noop, _recompute: noop,
_set, _set,
_stage,
_mount, _mount,
_differs _differs
}; };

Write Preview
Loading…
Cancel
Save