Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

[WIP] only track contextual names that are used in a given block #1194

Closed
wants to merge 1 commit into from
Closed

[WIP] only track contextual names that are used in a given block #1194

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
367 changes: 367 additions & 0 deletions test/js/samples/unreferenced-context/expected-bundle.js
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,367 @@
function noop() {}

function assign(target) {
var k,
source,
i = 1,
len = arguments.length;
for (; i < len; i++) {
source = arguments[i];
for (k in source) target[k] = source[k];
}

return target;
}

function appendNode(node, target) {
target.appendChild(node);
}

function insertNode(node, target, anchor) {
target.insertBefore(node, anchor);
}

function detachNode(node) {
node.parentNode.removeChild(node);
}

function destroyEach(iterations) {
for (var i = 0; i < iterations.length; i += 1) {
if (iterations[i]) iterations[i].d();
}
}

function createElement(name) {
return document.createElement(name);
}

function createText(data) {
return document.createTextNode(data);
}

function createComment() {
return document.createComment('');
}

function blankObject() {
return Object.create(null);
}

function destroy(detach) {
this.destroy = noop;
this.fire('destroy');
this.set = this.get = noop;

if (detach !== false) this._fragment.u();
this._fragment.d();
this._fragment = this._state = null;
}

function _differs(a, b) {
return a != a ? b == b : a !== b || ((a && typeof a === 'object') || typeof a === 'function');
}

function dispatchObservers(component, group, changed, newState, oldState) {
for (var key in group) {
if (!changed[key]) continue;

var newValue = newState[key];
var oldValue = oldState[key];

var callbacks = group[key];
if (!callbacks) continue;

for (var i = 0; i < callbacks.length; i += 1) {
var callback = callbacks[i];
if (callback.__calling) continue;

callback.__calling = true;
callback.call(component, newValue, oldValue);
callback.__calling = false;
}
}
}

function fire(eventName, data) {
var handlers =
eventName in this._handlers && this._handlers[eventName].slice();
if (!handlers) return;

for (var i = 0; i < handlers.length; i += 1) {
handlers[i].call(this, data);
}
}

function get(key) {
return key ? this._state[key] : this._state;
}

function init(component, options) {
component._observers = { pre: blankObject(), post: blankObject() };
component._handlers = blankObject();
component._bind = options._bind;

component.options = options;
component.root = options.root || component;
component.store = component.root.store || options.store;
}

function observe(key, callback, options) {
var group = options && options.defer
? this._observers.post
: this._observers.pre;

(group[key] || (group[key] = [])).push(callback);

if (!options || options.init !== false) {
callback.__calling = true;
callback.call(this, this._state[key]);
callback.__calling = false;
}

return {
cancel: function() {
var index = group[key].indexOf(callback);
if (~index) group[key].splice(index, 1);
}
};
}

function on(eventName, handler) {
if (eventName === 'teardown') return this.on('destroy', handler);

var handlers = this._handlers[eventName] || (this._handlers[eventName] = []);
handlers.push(handler);

return {
cancel: function() {
var index = handlers.indexOf(handler);
if (~index) handlers.splice(index, 1);
}
};
}

function set(newState) {
this._set(assign({}, newState));
if (this.root._lock) return;
this.root._lock = true;
callAll(this.root._beforecreate);
callAll(this.root._oncreate);
callAll(this.root._aftercreate);
this.root._lock = false;
}

function _set(newState) {
var oldState = this._state,
changed = {},
dirty = false;

for (var key in newState) {
if (this._differs(newState[key], oldState[key])) changed[key] = dirty = true;
}
if (!dirty) return;

this._state = assign({}, oldState, newState);
this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state);

if (this._fragment) {
dispatchObservers(this, this._observers.pre, changed, this._state, oldState);
this._fragment.p(changed, this._state);
dispatchObservers(this, this._observers.post, changed, this._state, oldState);
}
}

function callAll(fns) {
while (fns && fns.length) fns.shift()();
}

function _mount(target, anchor) {
this._fragment.m(target, anchor);
}

function _unmount() {
if (this._fragment) this._fragment.u();
}

var proto = {
destroy: destroy,
get: get,
fire: fire,
observe: observe,
on: on,
set: set,
teardown: destroy,
_recompute: noop,
_set: _set,
_mount: _mount,
_unmount: _unmount,
_differs: _differs
};

/* generated by Svelte vX.Y.Z */
function create_main_fragment(component, state) {
var each_anchor;

var things = state.things;

var each_blocks = [];

for (var i = 0; i < things.length; i += 1) {
each_blocks[i] = create_each_block(component, assign({}, state, {
thing: things[i]
}));
}

return {
c: function create() {
for (var i = 0; i < each_blocks.length; i += 1) {
each_blocks[i].c();
}

each_anchor = createComment();
},

m: function mount(target, anchor) {
for (var i = 0; i < each_blocks.length; i += 1) {
each_blocks[i].m(target, anchor);
}

insertNode(each_anchor, target, anchor);
},

p: function update(changed, state) {
var things = state.things;

if (changed.things) {
for (var i = 0; i < things.length; i += 1) {
var each_context = assign({}, state, {
thing: things[i]
});

if (each_blocks[i]) {
each_blocks[i].p(changed, each_context);
} else {
each_blocks[i] = create_each_block(component, each_context);
each_blocks[i].c();
each_blocks[i].m(each_anchor.parentNode, each_anchor);
}
}

for (; i < each_blocks.length; i += 1) {
each_blocks[i].u();
each_blocks[i].d();
}
each_blocks.length = things.length;
}
},

u: function unmount() {
for (var i = 0; i < each_blocks.length; i += 1) {
each_blocks[i].u();
}

detachNode(each_anchor);
},

d: function destroy() {
destroyEach(each_blocks);
}
};
}

// (1:0) {{#each things as thing}}
function create_each_block(component, state) {
var thing = state.thing;
var p, text_value = thing, text, text_1, if_block_anchor;

var if_block = (true) && create_if_block(component, state);

return {
c: function create() {
p = createElement("p");
text = createText(text_value);
text_1 = createText("\n\n\t");
if (if_block) if_block.c();
if_block_anchor = createComment();
},

m: function mount(target, anchor) {
insertNode(p, target, anchor);
appendNode(text, p);
insertNode(text_1, target, anchor);
if (if_block) if_block.m(target, anchor);
insertNode(if_block_anchor, target, anchor);
},

p: function update(changed, state) {
thing = state.thing;
if ((changed.things) && text_value !== (text_value = thing)) {
text.data = text_value;
}

if (true) {
if (!if_block) {
if_block = create_if_block(component, state);
if_block.c();
if_block.m(if_block_anchor.parentNode, if_block_anchor);
}
} else if (if_block) {
if_block.u();
if_block.d();
if_block = null;
}
},

u: function unmount() {
detachNode(p);
detachNode(text_1);
if (if_block) if_block.u();
detachNode(if_block_anchor);
},

d: function destroy() {
if (if_block) if_block.d();
}
};
}

// (4:1) {{#if true}}
function create_if_block(component, state) {
var p;

return {
c: function create() {
p = createElement("p");
p.textContent = "thing is unused";
},

m: function mount(target, anchor) {
insertNode(p, target, anchor);
},

p: noop,

u: function unmount() {
detachNode(p);
},

d: noop
};
}

function SvelteComponent(options) {
init(this, options);
this._state = assign({}, options.data);

this._fragment = create_main_fragment(this, this._state);

if (options.target) {
this._fragment.c();
this._fragment.m(options.target, options.anchor || null);
}
}

assign(SvelteComponent.prototype, proto);

export default SvelteComponent;
Loading