remove legacy prop stuff, now that we emit ES2015

pull/1348/head
Rich Harris 7 years ago
parent fb9d7cdb28
commit 6ff02b263e

@ -73,11 +73,11 @@ export default class Component extends Node {
const componentInitProperties = [`root: #component.root`];
if (this.children.length > 0) {
const slots = Array.from(this._slots).map(name => `${quoteIfNecessary(name, generator.legacy)}: @createFragment()`);
const slots = Array.from(this._slots).map(name => `${quoteIfNecessary(name)}: @createFragment()`);
componentInitProperties.push(`slots: { ${slots.join(', ')} }`);
this.children.forEach((child: Node) => {
child.build(block, `${this.var}._slotted${generator.legacy ? `["default"]` : `.default`}`, 'nodes');
child.build(block, `${this.var}._slotted.default`, 'nodes');
});
}
@ -139,7 +139,7 @@ export default class Component extends Node {
const condition = dependencies && dependencies.map(d => `changed.${d}`).join(' || ');
changes.push(condition ? `${condition} && ${value}` : value);
} else {
const obj = `{ ${quoteIfNecessary(name, this.generator.legacy)}: ${value} }`;
const obj = `{ ${quoteIfNecessary(name)}: ${value} }`;
initialProps.push(obj);
const condition = dependencies && dependencies.map(d => `changed.${d}`).join(' || ');
@ -440,7 +440,7 @@ export default class Component extends Node {
}
remount(name: string) {
return `${this.var}._mount(${name}._slotted${this.generator.legacy ? `["default"]` : `.default`}, null);`;
return `${this.var}._mount(${name}._slotted.default, null);`;
}
}

@ -455,6 +455,6 @@ export default class EachBlock extends Node {
remount(name: string) {
// TODO consider keyed blocks
return `for (var #i = 0; #i < ${this.iterations}.length; #i += 1) ${this.iterations}[#i].m(${name}._slotted${this.generator.legacy ? `["default"]` : `.default`}, null);`;
return `for (var #i = 0; #i < ${this.iterations}.length; #i += 1) ${this.iterations}[#i].m(${name}._slotted.default, null);`;
}
}

@ -461,7 +461,7 @@ export default class Element extends Node {
if (attr.type === 'Attribute') {
const { dynamic, value, dependencies } = mungeAttribute(attr, block);
const snippet = `{ ${quoteIfNecessary(attr.name, this.generator.legacy)}: ${value} }`;
const snippet = `{ ${quoteIfNecessary(attr.name)}: ${value} }`;
initialProps.push(snippet);
const condition = dependencies && dependencies.map(d => `changed.${d}`).join(' || ');
@ -781,7 +781,7 @@ export default class Element extends Node {
return `@appendNode(${this.var}, ${name}._slotted.${this.getStaticAttributeValue('slot')});`;
}
return `@appendNode(${this.var}, ${name}._slotted${this.generator.legacy ? `["default"]` : `.default`});`;
return `@appendNode(${this.var}, ${name}._slotted.default);`;
}
addCssClass() {
@ -831,7 +831,7 @@ function getClaimStatement(
) {
const attributes = node.attributes
.filter((attr: Node) => attr.type === 'Attribute')
.map((attr: Node) => `${quoteProp(attr.name, generator.legacy)}: true`)
.map((attr: Node) => `${quoteIfNecessary(attr.name)}: true`)
.join(', ');
const name = namespace ? node.name : node.name.toUpperCase();
@ -841,13 +841,6 @@ function getClaimStatement(
: `{}`}, ${namespace === namespaces.svg ? true : false})`;
}
function quoteProp(name: string, legacy: boolean) {
const isLegacyPropName = legacy && reservedNames.has(name);
if (/[^a-zA-Z_$0-9]/.test(name) || isLegacyPropName) return `"${name}"`;
return name;
}
function stringifyAttributeValue(value: Node | true) {
if (value === true) return '';
if (value.length === 0) return `=""`;

@ -28,6 +28,6 @@ export default class MustacheTag extends Tag {
}
remount(name: string) {
return `@appendNode(${this.var}, ${name}._slotted${this.generator.legacy ? `["default"]` : `.default`});`;
return `@appendNode(${this.var}, ${name}._slotted.default);`;
}
}

@ -91,6 +91,6 @@ export default class RawMustacheTag extends Tag {
}
remount(name: string) {
return `@appendNode(${this.var}, ${name}._slotted${this.generator.legacy ? `["default"]` : `.default`});`;
return `@appendNode(${this.var}, ${name}._slotted.default);`;
}
}

@ -37,7 +37,7 @@ export default class Slot extends Element {
generator.slots.add(slotName);
const content_name = block.getUniqueName(`slot_content_${slotName}`);
const prop = !isValidIdentifier(slotName) || (generator.legacy && reservedNames.has(slotName)) ? `["${slotName}"]` : `.${slotName}`;
const prop = !isValidIdentifier(slotName) ? `["${slotName}"]` : `.${slotName}`;
block.addVariable(content_name, `#component._slotted${prop}`);
const needsAnchorBefore = this.prev ? this.prev.type !== 'Element' : !parentNode;

@ -60,6 +60,6 @@ export default class Text extends Node {
}
remount(name: string) {
return `@appendNode(${this.var}, ${name}._slotted${this.generator.legacy ? `["default"]` : `.default`});`;
return `@appendNode(${this.var}, ${name}._slotted.default);`;
}
}

@ -163,6 +163,6 @@ export default class Node {
}
remount(name: string) {
return `${this.var}.m(${name}._slotted${this.generator.legacy ? `["default"]` : `.default`}, null);`;
return `${this.var}.m(${name}._slotted.default, null);`;
}
}

@ -1,7 +1,7 @@
import isValidIdentifier from './isValidIdentifier';
import reservedNames from './reservedNames';
export default function quoteIfNecessary(name: string, legacy?: boolean) {
if (!isValidIdentifier(name) || (legacy && reservedNames.has(name))) return `"${name}"`;
export default function quoteIfNecessary(name) {
if (!isValidIdentifier(name)) return `"${name}"`;
return name;
}

@ -1,5 +0,0 @@
export default {
options: {
legacy: true
}
};

@ -1,241 +0,0 @@
function noop() {}
function assign(tar, src) {
for (var k in src) tar[k] = src[k];
return tar;
}
function appendNode(node, target) {
target.appendChild(node);
}
function insertNode(node, target, anchor) {
target.insertBefore(node, anchor);
}
function detachNode(node) {
node.parentNode.removeChild(node);
}
function reinsertBetween(before, after, target) {
while (before.nextSibling && before.nextSibling !== after) {
target.appendChild(before.parentNode.removeChild(before.nextSibling));
}
}
function createFragment() {
return document.createDocumentFragment();
}
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 fire(eventName, data) {
var handlers =
eventName in this._handlers && this._handlers[eventName].slice();
if (!handlers) return;
for (var i = 0; i < handlers.length; i += 1) {
var handler = handlers[i];
if (!handler.__calling) {
handler.__calling = true;
handler.call(this, data);
handler.__calling = false;
}
}
}
function get() {
return this._state;
}
function init(component, options) {
component._handlers = blankObject();
component._bind = options._bind;
component.options = options;
component.root = options.root || component;
component.store = component.root.store || options.store;
}
function on(eventName, handler) {
var handlers = this._handlers[eventName] || (this._handlers[eventName] = []);
handlers.push(handler);
return {
cancel: function() {
var index = handlers.indexOf(handler);
if (~index) handlers.splice(index, 1);
}
};
}
function set(newState) {
this._set(assign({}, newState));
if (this.root._lock) return;
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(assign({}, oldState), newState);
this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state);
if (this._fragment) {
this.fire("state", { changed: changed, current: this._state, previous: oldState });
this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState });
}
}
function callAll(fns) {
while (fns && fns.length) fns.shift()();
}
function _mount(target, anchor) {
this._fragment[this._fragment.i ? 'i' : 'm'](target, anchor || null);
}
function _unmount() {
if (this._fragment) this._fragment.u();
}
var proto = {
destroy,
get,
fire,
on,
set,
_recompute: noop,
_set,
_mount,
_unmount,
_differs
};
/* generated by Svelte vX.Y.Z */
function create_main_fragment(component, state) {
var text, p, text_1, text_2, text_3, slot_content_default = component._slotted["default"], slot_content_default_before, slot_content_default_after;
var foo = new Foo({
root: component.root,
slots: { "default": createFragment() }
});
return {
c: function create() {
text = createText("\n\t");
p = createElement("p");
text_1 = createText("some default slotted content");
text_2 = createText("\n");
foo._fragment.c();
text_3 = createText("\n\n");
},
m: function mount(target, anchor) {
appendNode(text, foo._slotted["default"]);
appendNode(p, foo._slotted["default"]);
appendNode(text_1, p);
appendNode(text_2, foo._slotted["default"]);
foo._mount(target, anchor);
insertNode(text_3, target, anchor);
if (slot_content_default) {
insertNode(slot_content_default_before || (slot_content_default_before = createComment()), target, anchor);
insertNode(slot_content_default, target, anchor);
insertNode(slot_content_default_after || (slot_content_default_after = createComment()), target, anchor);
}
},
p: noop,
u: function unmount() {
foo._unmount();
detachNode(text_3);
if (slot_content_default) {
reinsertBetween(slot_content_default_before, slot_content_default_after, slot_content_default);
detachNode(slot_content_default_before);
detachNode(slot_content_default_after);
}
},
d: function destroy$$1() {
foo.destroy(false);
}
};
}
function SvelteComponent(options) {
init(this, options);
this._state = assign({}, options.data);
this._slotted = options.slots || {};
if (!options.root) {
this._oncreate = [];
this._beforecreate = [];
this._aftercreate = [];
}
this.slots = {};
this._fragment = create_main_fragment(this, this._state);
if (options.target) {
this._fragment.c();
this._mount(options.target, options.anchor);
this._lock = true;
callAll(this._beforecreate);
callAll(this._oncreate);
callAll(this._aftercreate);
this._lock = false;
}
}
assign(SvelteComponent.prototype, proto);
export default SvelteComponent;

@ -1,85 +0,0 @@
/* generated by Svelte vX.Y.Z */
import { appendNode, assign, callAll, createComment, createElement, createFragment, createText, detachNode, init, insertNode, noop, proto, reinsertBetween } from "svelte/shared.js";
function create_main_fragment(component, state) {
var text, p, text_1, text_2, text_3, slot_content_default = component._slotted["default"], slot_content_default_before, slot_content_default_after;
var foo = new Foo({
root: component.root,
slots: { "default": createFragment() }
});
return {
c: function create() {
text = createText("\n\t");
p = createElement("p");
text_1 = createText("some default slotted content");
text_2 = createText("\n");
foo._fragment.c();
text_3 = createText("\n\n");
},
m: function mount(target, anchor) {
appendNode(text, foo._slotted["default"]);
appendNode(p, foo._slotted["default"]);
appendNode(text_1, p);
appendNode(text_2, foo._slotted["default"]);
foo._mount(target, anchor);
insertNode(text_3, target, anchor);
if (slot_content_default) {
insertNode(slot_content_default_before || (slot_content_default_before = createComment()), target, anchor);
insertNode(slot_content_default, target, anchor);
insertNode(slot_content_default_after || (slot_content_default_after = createComment()), target, anchor);
}
},
p: noop,
u: function unmount() {
foo._unmount();
detachNode(text_3);
if (slot_content_default) {
reinsertBetween(slot_content_default_before, slot_content_default_after, slot_content_default);
detachNode(slot_content_default_before);
detachNode(slot_content_default_after);
}
},
d: function destroy() {
foo.destroy(false);
}
};
}
function SvelteComponent(options) {
init(this, options);
this._state = assign({}, options.data);
this._slotted = options.slots || {};
if (!options.root) {
this._oncreate = [];
this._beforecreate = [];
this._aftercreate = [];
}
this.slots = {};
this._fragment = create_main_fragment(this, this._state);
if (options.target) {
this._fragment.c();
this._mount(options.target, options.anchor);
this._lock = true;
callAll(this._beforecreate);
callAll(this._oncreate);
callAll(this._aftercreate);
this._lock = false;
}
}
assign(SvelteComponent.prototype, proto);
export default SvelteComponent;

@ -1,11 +0,0 @@
<Foo>
<p>some default slotted content</p>
</Foo>
<slot></slot>
<script>
export default {
components: { Foo }
};
</script>

@ -1,6 +0,0 @@
export default {
options: {
hydratable: true,
legacy: true
}
};

@ -1,211 +0,0 @@
function noop() {}
function assign(tar, src) {
for (var k in src) tar[k] = src[k];
return tar;
}
function insertNode(node, target, anchor) {
target.insertBefore(node, anchor);
}
function detachNode(node) {
node.parentNode.removeChild(node);
}
function createElement(name) {
return document.createElement(name);
}
function createSvgElement(name) {
return document.createElementNS('http://www.w3.org/2000/svg', name);
}
function children (element) {
return Array.from(element.childNodes);
}
function claimElement (nodes, name, attributes, svg) {
for (var i = 0; i < nodes.length; i += 1) {
var node = nodes[i];
if (node.nodeName === name) {
for (var j = 0; j < node.attributes.length; j += 1) {
var attribute = node.attributes[j];
if (!attributes[attribute.name]) node.removeAttribute(attribute.name);
}
return nodes.splice(i, 1)[0]; // TODO strip unwanted attributes
}
}
return svg ? createSvgElement(name) : createElement(name);
}
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 fire(eventName, data) {
var handlers =
eventName in this._handlers && this._handlers[eventName].slice();
if (!handlers) return;
for (var i = 0; i < handlers.length; i += 1) {
var handler = handlers[i];
if (!handler.__calling) {
handler.__calling = true;
handler.call(this, data);
handler.__calling = false;
}
}
}
function get() {
return this._state;
}
function init(component, options) {
component._handlers = blankObject();
component._bind = options._bind;
component.options = options;
component.root = options.root || component;
component.store = component.root.store || options.store;
}
function on(eventName, handler) {
var handlers = this._handlers[eventName] || (this._handlers[eventName] = []);
handlers.push(handler);
return {
cancel: function() {
var index = handlers.indexOf(handler);
if (~index) handlers.splice(index, 1);
}
};
}
function set(newState) {
this._set(assign({}, newState));
if (this.root._lock) return;
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(assign({}, oldState), newState);
this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state);
if (this._fragment) {
this.fire("state", { changed: changed, current: this._state, previous: oldState });
this._fragment.p(changed, this._state);
this.fire("update", { changed: changed, current: this._state, previous: oldState });
}
}
function callAll(fns) {
while (fns && fns.length) fns.shift()();
}
function _mount(target, anchor) {
this._fragment[this._fragment.i ? 'i' : 'm'](target, anchor || null);
}
function _unmount() {
if (this._fragment) this._fragment.u();
}
var proto = {
destroy,
get,
fire,
on,
set,
_recompute: noop,
_set,
_mount,
_unmount,
_differs
};
/* generated by Svelte vX.Y.Z */
function create_main_fragment(component, state) {
var div;
return {
c: function create() {
div = createElement("div");
this.h();
},
l: function claim(nodes) {
div = claimElement(nodes, "DIV", { "class": true }, false);
var div_nodes = children(div);
div_nodes.forEach(detachNode);
this.h();
},
h: function hydrate() {
div.className = "foo";
},
m: function mount(target, anchor) {
insertNode(div, target, anchor);
},
p: noop,
u: function unmount() {
detachNode(div);
},
d: noop
};
}
function SvelteComponent(options) {
init(this, options);
this._state = assign({}, options.data);
this._fragment = create_main_fragment(this, this._state);
if (options.target) {
var nodes = children(options.target);
options.hydrate ? this._fragment.l(nodes) : this._fragment.c();
nodes.forEach(detachNode);
this._mount(options.target, options.anchor);
}
}
assign(SvelteComponent.prototype, proto);
export default SvelteComponent;

@ -1,54 +0,0 @@
/* generated by Svelte vX.Y.Z */
import { assign, children, claimElement, createElement, detachNode, init, insertNode, noop, proto } from "svelte/shared.js";
function create_main_fragment(component, state) {
var div;
return {
c: function create() {
div = createElement("div");
this.h();
},
l: function claim(nodes) {
div = claimElement(nodes, "DIV", { "class": true }, false);
var div_nodes = children(div);
div_nodes.forEach(detachNode);
this.h();
},
h: function hydrate() {
div.className = "foo";
},
m: function mount(target, anchor) {
insertNode(div, target, anchor);
},
p: noop,
u: function unmount() {
detachNode(div);
},
d: noop
};
}
function SvelteComponent(options) {
init(this, options);
this._state = assign({}, options.data);
this._fragment = create_main_fragment(this, this._state);
if (options.target) {
var nodes = children(options.target);
options.hydrate ? this._fragment.l(nodes) : this._fragment.c();
nodes.forEach(detachNode);
this._mount(options.target, options.anchor);
}
}
assign(SvelteComponent.prototype, proto);
export default SvelteComponent;
Loading…
Cancel
Save