@b9g/crank 0.4.1 → 0.4.4

package/umd.js

@@ -960,13 +960,170 @@
 	        provisions.set(key, value);
 	    }
 	    addEventListener(type, listener, options) {
-	        return addEventListener(this[$ContextImpl], type, listener, options);
+	        const impl = this[$ContextImpl];
+	        let listeners;
+	        if (!isListenerOrListenerObject(listener)) {
+	            return;
+	        }
+	        else {
+	            const listeners1 = listenersMap.get(impl);
+	            if (listeners1) {
+	                listeners = listeners1;
+	            }
+	            else {
+	                listeners = [];
+	                listenersMap.set(impl, listeners);
+	            }
+	        }
+	        options = normalizeListenerOptions(options);
+	        let callback;
+	        if (typeof listener === "object") {
+	            callback = () => listener.handleEvent.apply(listener, arguments);
+	        }
+	        else {
+	            callback = listener;
+	        }
+	        const record = { type, callback, listener, options };
+	        if (options.once) {
+	            record.callback = function () {
+	                const i = listeners.indexOf(record);
+	                if (i !== -1) {
+	                    listeners.splice(i, 1);
+	                }
+	                return callback.apply(this, arguments);
+	            };
+	        }
+	        if (listeners.some((record1) => record.type === record1.type &&
+	            record.listener === record1.listener &&
+	            !record.options.capture === !record1.options.capture)) {
+	            return;
+	        }
+	        listeners.push(record);
+	        // TODO: is it possible to separate out the EventTarget delegation logic
+	        for (const value of getChildValues(impl.ret)) {
+	            if (isEventTarget(value)) {
+	                value.addEventListener(record.type, record.callback, record.options);
+	            }
+	        }
 	    }
 	    removeEventListener(type, listener, options) {
-	        return removeEventListener(this[$ContextImpl], type, listener, options);
+	        const impl = this[$ContextImpl];
+	        const listeners = listenersMap.get(impl);
+	        if (listeners == null || !isListenerOrListenerObject(listener)) {
+	            return;
+	        }
+	        const options1 = normalizeListenerOptions(options);
+	        const i = listeners.findIndex((record) => record.type === type &&
+	            record.listener === listener &&
+	            !record.options.capture === !options1.capture);
+	        if (i === -1) {
+	            return;
+	        }
+	        const record = listeners[i];
+	        listeners.splice(i, 1);
+	        // TODO: is it possible to separate out the EventTarget delegation logic
+	        for (const value of getChildValues(impl.ret)) {
+	            if (isEventTarget(value)) {
+	                value.removeEventListener(record.type, record.callback, record.options);
+	            }
+	        }
 	    }
 	    dispatchEvent(ev) {
-	        return dispatchEvent(this[$ContextImpl], ev);
+	        const impl = this[$ContextImpl];
+	        const path = [];
+	        for (let parent = impl.parent; parent !== undefined; parent = parent.parent) {
+	            path.push(parent);
+	        }
+	        // We patch the stopImmediatePropagation method because ev.cancelBubble
+	        // only informs us if stopPropagation was called and there are no
+	        // properties which inform us if stopImmediatePropagation was called.
+	        let immediateCancelBubble = false;
+	        const stopImmediatePropagation = ev.stopImmediatePropagation;
+	        setEventProperty(ev, "stopImmediatePropagation", () => {
+	            immediateCancelBubble = true;
+	            return stopImmediatePropagation.call(ev);
+	        });
+	        setEventProperty(ev, "target", impl.ctx);
+	        // The only possible errors in this block are errors thrown by callbacks,
+	        // and dispatchEvent will only log these errors rather than throwing
+	        // them. Therefore, we place all code in a try block, log errors in the
+	        // catch block, and use an unsafe return statement in the finally block.
+	        //
+	        // Each early return within the try block returns true because while the
+	        // return value is overridden in the finally block, TypeScript
+	        // (justifiably) does not recognize the unsafe return statement.
+	        //
+	        // TODO: Run all callbacks even if one of them errors
+	        try {
+	            setEventProperty(ev, "eventPhase", CAPTURING_PHASE);
+	            for (let i = path.length - 1; i >= 0; i--) {
+	                const target = path[i];
+	                const listeners = listenersMap.get(target);
+	                if (listeners) {
+	                    setEventProperty(ev, "currentTarget", target.ctx);
+	                    for (const record of listeners) {
+	                        if (record.type === ev.type && record.options.capture) {
+	                            record.callback.call(target.ctx, ev);
+	                            if (immediateCancelBubble) {
+	                                return true;
+	                            }
+	                        }
+	                    }
+	                }
+	                if (ev.cancelBubble) {
+	                    return true;
+	                }
+	            }
+	            {
+	                const listeners = listenersMap.get(impl);
+	                if (listeners) {
+	                    setEventProperty(ev, "eventPhase", AT_TARGET);
+	                    setEventProperty(ev, "currentTarget", impl.ctx);
+	                    for (const record of listeners) {
+	                        if (record.type === ev.type) {
+	                            record.callback.call(impl.ctx, ev);
+	                            if (immediateCancelBubble) {
+	                                return true;
+	                            }
+	                        }
+	                    }
+	                    if (ev.cancelBubble) {
+	                        return true;
+	                    }
+	                }
+	            }
+	            if (ev.bubbles) {
+	                setEventProperty(ev, "eventPhase", BUBBLING_PHASE);
+	                for (let i = 0; i < path.length; i++) {
+	                    const target = path[i];
+	                    const listeners = listenersMap.get(target);
+	                    if (listeners) {
+	                        setEventProperty(ev, "currentTarget", target.ctx);
+	                        for (const record of listeners) {
+	                            if (record.type === ev.type && !record.options.capture) {
+	                                record.callback.call(target.ctx, ev);
+	                                if (immediateCancelBubble) {
+	                                    return true;
+	                                }
+	                            }
+	                        }
+	                    }
+	                    if (ev.cancelBubble) {
+	                        return true;
+	                    }
+	                }
+	            }
+	        }
+	        catch (err) {
+	            // TODO: Use setTimeout to rethrow the error.
+	            console.error(err);
+	        }
+	        finally {
+	            setEventProperty(ev, "eventPhase", NONE);
+	            setEventProperty(ev, "currentTarget", null);
+	            // eslint-disable-next-line no-unsafe-finally
+	            return !ev.defaultPrevented;
+	        }
 	    }
 	}
 	/*** PRIVATE CONTEXT FUNCTIONS ***/
@@ -1367,168 +1524,11 @@
 	const AT_TARGET = 2;
 	const BUBBLING_PHASE = 3;
 	const listenersMap = new WeakMap();
-	function addEventListener(ctx, type, listener, options) {
-	    let listeners;
-	    if (listener == null) {
-	        return;
-	    }
-	    else {
-	        const listeners1 = listenersMap.get(ctx);
-	        if (listeners1) {
-	            listeners = listeners1;
-	        }
-	        else {
-	            listeners = [];
-	            listenersMap.set(ctx, listeners);
-	        }
-	    }
-	    options = normalizeListenerOptions(options);
-	    let callback;
-	    if (typeof listener === "object") {
-	        callback = () => listener.handleEvent.apply(listener, arguments);
-	    }
-	    else {
-	        callback = listener;
-	    }
-	    const record = { type, callback, listener, options };
-	    if (options.once) {
-	        record.callback = function () {
-	            const i = listeners.indexOf(record);
-	            if (i !== -1) {
-	                listeners.splice(i, 1);
-	            }
-	            return callback.apply(this, arguments);
-	        };
-	    }
-	    if (listeners.some((record1) => record.type === record1.type &&
-	        record.listener === record1.listener &&
-	        !record.options.capture === !record1.options.capture)) {
-	        return;
-	    }
-	    listeners.push(record);
-	    // TODO: is it possible to separate out the EventTarget delegation logic
-	    for (const value of getChildValues(ctx.ret)) {
-	        if (isEventTarget(value)) {
-	            value.addEventListener(record.type, record.callback, record.options);
-	        }
-	    }
-	}
-	function removeEventListener(ctx, type, listener, options) {
-	    const listeners = listenersMap.get(ctx);
-	    if (listener == null || listeners == null) {
-	        return;
-	    }
-	    const options1 = normalizeListenerOptions(options);
-	    const i = listeners.findIndex((record) => record.type === type &&
-	        record.listener === listener &&
-	        !record.options.capture === !options1.capture);
-	    if (i === -1) {
-	        return;
-	    }
-	    const record = listeners[i];
-	    listeners.splice(i, 1);
-	    // TODO: is it possible to separate out the EventTarget delegation logic
-	    for (const value of getChildValues(ctx.ret)) {
-	        if (isEventTarget(value)) {
-	            value.removeEventListener(record.type, record.callback, record.options);
-	        }
-	    }
-	}
-	function dispatchEvent(ctx, ev) {
-	    const path = [];
-	    for (let parent = ctx.parent; parent !== undefined; parent = parent.parent) {
-	        path.push(parent);
-	    }
-	    // We patch the stopImmediatePropagation method because ev.cancelBubble
-	    // only informs us if stopPropagation was called and there are no
-	    // properties which inform us if stopImmediatePropagation was called.
-	    let immediateCancelBubble = false;
-	    const stopImmediatePropagation = ev.stopImmediatePropagation;
-	    setEventProperty(ev, "stopImmediatePropagation", () => {
-	        immediateCancelBubble = true;
-	        return stopImmediatePropagation.call(ev);
-	    });
-	    setEventProperty(ev, "target", ctx.ctx);
-	    // The only possible errors in this block are errors thrown by callbacks,
-	    // and dispatchEvent will only log these errors rather than throwing
-	    // them. Therefore, we place all code in a try block, log errors in the
-	    // catch block, and use an unsafe return statement in the finally block.
-	    //
-	    // Each early return within the try block returns true because while the
-	    // return value is overridden in the finally block, TypeScript
-	    // (justifiably) does not recognize the unsafe return statement.
-	    //
-	    // TODO: Run all callbacks even if one of them errors
-	    try {
-	        setEventProperty(ev, "eventPhase", CAPTURING_PHASE);
-	        for (let i = path.length - 1; i >= 0; i--) {
-	            const target = path[i];
-	            const listeners = listenersMap.get(target);
-	            if (listeners) {
-	                setEventProperty(ev, "currentTarget", target.ctx);
-	                for (const record of listeners) {
-	                    if (record.type === ev.type && record.options.capture) {
-	                        record.callback.call(target.ctx, ev);
-	                        if (immediateCancelBubble) {
-	                            return true;
-	                        }
-	                    }
-	                }
-	            }
-	            if (ev.cancelBubble) {
-	                return true;
-	            }
-	        }
-	        {
-	            const listeners = listenersMap.get(ctx);
-	            if (listeners) {
-	                setEventProperty(ev, "eventPhase", AT_TARGET);
-	                setEventProperty(ev, "currentTarget", ctx.ctx);
-	                for (const record of listeners) {
-	                    if (record.type === ev.type) {
-	                        record.callback.call(ctx.ctx, ev);
-	                        if (immediateCancelBubble) {
-	                            return true;
-	                        }
-	                    }
-	                }
-	                if (ev.cancelBubble) {
-	                    return true;
-	                }
-	            }
-	        }
-	        if (ev.bubbles) {
-	            setEventProperty(ev, "eventPhase", BUBBLING_PHASE);
-	            for (let i = 0; i < path.length; i++) {
-	                const target = path[i];
-	                const listeners = listenersMap.get(target);
-	                if (listeners) {
-	                    setEventProperty(ev, "currentTarget", target.ctx);
-	                    for (const record of listeners) {
-	                        if (record.type === ev.type && !record.options.capture) {
-	                            record.callback.call(target.ctx, ev);
-	                            if (immediateCancelBubble) {
-	                                return true;
-	                            }
-	                        }
-	                    }
-	                }
-	                if (ev.cancelBubble) {
-	                    return true;
-	                }
-	            }
-	        }
-	    }
-	    catch (err) {
-	        // TODO: Use setTimeout to rethrow the error.
-	        console.error(err);
-	    }
-	    finally {
-	        setEventProperty(ev, "eventPhase", NONE);
-	        setEventProperty(ev, "currentTarget", null);
-	        // eslint-disable-next-line no-unsafe-finally
-	        return !ev.defaultPrevented;
-	    }
+	function isListenerOrListenerObject(value) {
+	    return (typeof value === "function" ||
+	        (value !== null &&
+	            typeof value === "object" &&
+	            typeof value.handleEvent === "function"));
 	}
 	function normalizeListenerOptions(options) {
 	    if (typeof options === "boolean") {
@@ -1739,16 +1739,24 @@
 	                    // falsy properties, so we use attributes in this case.
 	                    !(typeof value === "string" &&
 	                        typeof node[name] === "boolean")) {
-	                    try {
-	                        if (node[name] !== value) {
-	                            node[name] = value;
+	                    // walk up the object's prototype chain to find the owner of the
+	                    // named property
+	                    let obj = node;
+	                    do {
+	                        if (Object.prototype.hasOwnProperty.call(obj, name)) {
+	                            break;
 	                        }
+	                    } while ((obj = Object.getPrototypeOf(obj)));
+	                    // get the descriptor for the named property and check whether it
+	                    // implies that the property is writable
+	                    const descriptor = Object.getOwnPropertyDescriptor(obj, name);
+	                    if (descriptor != null &&
+	                        (descriptor.writable === true || descriptor.set !== undefined)) {
+	                        node[name] = value;
 	                        return;
 	                    }
-	                    catch (err) {
-	                        // some properties are readonly so we fallback to setting them as
-	                        // attributes
-	                    }
+	                    // if the property wasn't writable, fall through to the code below
+	                    // which uses setAttribute() instead of assigning directly.
 	                }
 	                if (value === true) {
 	                    value = "";
@@ -1904,19 +1912,22 @@
 	            case name === "children":
 	            case name === "innerHTML":
 	                break;
-	            case name === "style":
+	            case name === "style": {
 	                if (typeof value === "string") {
 	                    attrs.push(`style="${escape(value)}"`);
 	                }
-	                else {
+	                else if (typeof value === "object") {
 	                    attrs.push(`style="${escape(printStyleObject(value))}"`);
 	                }
 	                break;
-	            case name === "className":
-	                if (!("class" in props)) {
-	                    attrs.push(`class="${escape(value)}"`);
+	            }
+	            case name === "className": {
+	                if ("class" in props || typeof value !== "string") {
+	                    continue;
 	                }
+	                attrs.push(`class="${escape(value)}"`);
 	                break;
+	            }
 	            case typeof value === "string":
 	                attrs.push(`${escape(name)}="${escape(value)}"`);
 	                break;