ember-legacy-class-transform/.node_modules.ember-try/@glimmer/runtime/dist/modules/es5/lib/builder.js

The default blueprint for ember-cli addons.

function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

import { clear } from './bounds';
import { Stack, assert } from '@glimmer/util';
import { SimpleElementOperations } from './compiled/opcodes/dom';

var First = function () {
    function First(node) {
        _classCallCheck(this, First);

        this.node = node;
    }

    First.prototype.firstNode = function firstNode() {
        return this.node;
    };

    return First;
}();

var Last = function () {
    function Last(node) {
        _classCallCheck(this, Last);

        this.node = node;
    }

    Last.prototype.lastNode = function lastNode() {
        return this.node;
    };

    return Last;
}();

export var Fragment = function () {
    function Fragment(bounds) {
        _classCallCheck(this, Fragment);

        this.bounds = bounds;
    }

    Fragment.prototype.parentElement = function parentElement() {
        return this.bounds.parentElement();
    };

    Fragment.prototype.firstNode = function firstNode() {
        return this.bounds.firstNode();
    };

    Fragment.prototype.lastNode = function lastNode() {
        return this.bounds.lastNode();
    };

    Fragment.prototype.update = function update(bounds) {
        this.bounds = bounds;
    };

    return Fragment;
}();
export var ElementStack = function () {
    function ElementStack(env, parentNode, nextSibling) {
        _classCallCheck(this, ElementStack);

        this.constructing = null;
        this.operations = null;
        this.elementStack = new Stack();
        this.nextSiblingStack = new Stack();
        this.blockStack = new Stack();
        this.env = env;
        this.dom = env.getAppendOperations();
        this.updateOperations = env.getDOM();
        this.element = parentNode;
        this.nextSibling = nextSibling;
        this.defaultOperations = new SimpleElementOperations(env);
        this.pushSimpleBlock();
        this.elementStack.push(this.element);
        this.nextSiblingStack.push(this.nextSibling);
    }

    ElementStack.forInitialRender = function forInitialRender(env, parentNode, nextSibling) {
        return new ElementStack(env, parentNode, nextSibling);
    };

    ElementStack.resume = function resume(env, tracker, nextSibling) {
        var parentNode = tracker.parentElement();
        var stack = new ElementStack(env, parentNode, nextSibling);
        stack.pushBlockTracker(tracker);
        return stack;
    };

    ElementStack.prototype.expectConstructing = function expectConstructing(method) {
        return this.constructing;
    };

    ElementStack.prototype.expectOperations = function expectOperations(method) {
        return this.operations;
    };

    ElementStack.prototype.block = function block() {
        return this.blockStack.current;
    };

    ElementStack.prototype.popElement = function popElement() {
        var elementStack = this.elementStack,
            nextSiblingStack = this.nextSiblingStack;

        var topElement = elementStack.pop();
        nextSiblingStack.pop();
        // LOGGER.debug(`-> element stack ${this.elementStack.toArray().map(e => e.tagName).join(', ')}`);
        this.element = elementStack.current;
        this.nextSibling = nextSiblingStack.current;
        return topElement;
    };

    ElementStack.prototype.pushSimpleBlock = function pushSimpleBlock() {
        var tracker = new SimpleBlockTracker(this.element);
        this.pushBlockTracker(tracker);
        return tracker;
    };

    ElementStack.prototype.pushUpdatableBlock = function pushUpdatableBlock() {
        var tracker = new UpdatableBlockTracker(this.element);
        this.pushBlockTracker(tracker);
        return tracker;
    };

    ElementStack.prototype.pushBlockTracker = function pushBlockTracker(tracker) {
        var isRemote = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;

        var current = this.blockStack.current;
        if (current !== null) {
            current.newDestroyable(tracker);
            if (!isRemote) {
                current.newBounds(tracker);
            }
        }
        this.blockStack.push(tracker);
        return tracker;
    };

    ElementStack.prototype.pushBlockList = function pushBlockList(list) {
        var tracker = new BlockListTracker(this.element, list);
        var current = this.blockStack.current;
        if (current !== null) {
            current.newDestroyable(tracker);
            current.newBounds(tracker);
        }
        this.blockStack.push(tracker);
        return tracker;
    };

    ElementStack.prototype.popBlock = function popBlock() {
        this.block().finalize(this);
        return this.blockStack.pop();
    };

    ElementStack.prototype.openElement = function openElement(tag, _operations) {
        // workaround argument.length transpile of arg initializer
        var operations = _operations === undefined ? this.defaultOperations : _operations;
        var element = this.dom.createElement(tag, this.element);
        this.constructing = element;
        this.operations = operations;
        return element;
    };

    ElementStack.prototype.flushElement = function flushElement() {
        var parent = this.element;
        var element = this.constructing;
        this.dom.insertBefore(parent, element, this.nextSibling);
        this.constructing = null;
        this.operations = null;
        this.pushElement(element, null);
        this.block().openElement(element);
    };

    ElementStack.prototype.pushRemoteElement = function pushRemoteElement(element) {
        var nextSibling = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;

        this.pushElement(element, nextSibling);
        var tracker = new RemoteBlockTracker(element);
        this.pushBlockTracker(tracker, true);
    };

    ElementStack.prototype.popRemoteElement = function popRemoteElement() {
        this.popBlock();
        this.popElement();
    };

    ElementStack.prototype.pushElement = function pushElement(element, nextSibling) {
        this.element = element;
        this.elementStack.push(element);
        // LOGGER.debug(`-> element stack ${this.elementStack.toArray().map(e => e.tagName).join(', ')}`);
        this.nextSibling = nextSibling;
        this.nextSiblingStack.push(nextSibling);
    };

    ElementStack.prototype.newDestroyable = function newDestroyable(d) {
        this.block().newDestroyable(d);
    };

    ElementStack.prototype.newBounds = function newBounds(bounds) {
        this.block().newBounds(bounds);
    };

    ElementStack.prototype.appendText = function appendText(string) {
        var dom = this.dom;

        var text = dom.createTextNode(string);
        dom.insertBefore(this.element, text, this.nextSibling);
        this.block().newNode(text);
        return text;
    };

    ElementStack.prototype.appendComment = function appendComment(string) {
        var dom = this.dom;

        var comment = dom.createComment(string);
        dom.insertBefore(this.element, comment, this.nextSibling);
        this.block().newNode(comment);
        return comment;
    };

    ElementStack.prototype.setStaticAttribute = function setStaticAttribute(name, value) {
        this.expectOperations('setStaticAttribute').addStaticAttribute(this.expectConstructing('setStaticAttribute'), name, value);
    };

    ElementStack.prototype.setStaticAttributeNS = function setStaticAttributeNS(namespace, name, value) {
        this.expectOperations('setStaticAttributeNS').addStaticAttributeNS(this.expectConstructing('setStaticAttributeNS'), namespace, name, value);
    };

    ElementStack.prototype.setDynamicAttribute = function setDynamicAttribute(name, reference, isTrusting) {
        this.expectOperations('setDynamicAttribute').addDynamicAttribute(this.expectConstructing('setDynamicAttribute'), name, reference, isTrusting);
    };

    ElementStack.prototype.setDynamicAttributeNS = function setDynamicAttributeNS(namespace, name, reference, isTrusting) {
        this.expectOperations('setDynamicAttributeNS').addDynamicAttributeNS(this.expectConstructing('setDynamicAttributeNS'), namespace, name, reference, isTrusting);
    };

    ElementStack.prototype.closeElement = function closeElement() {
        this.block().closeElement();
        this.popElement();
    };

    return ElementStack;
}();
export var SimpleBlockTracker = function () {
    function SimpleBlockTracker(parent) {
        _classCallCheck(this, SimpleBlockTracker);

        this.parent = parent;
        this.first = null;
        this.last = null;
        this.destroyables = null;
        this.nesting = 0;
    }

    SimpleBlockTracker.prototype.destroy = function destroy() {
        var destroyables = this.destroyables;

        if (destroyables && destroyables.length) {
            for (var i = 0; i < destroyables.length; i++) {
                destroyables[i].destroy();
            }
        }
    };

    SimpleBlockTracker.prototype.parentElement = function parentElement() {
        return this.parent;
    };

    SimpleBlockTracker.prototype.firstNode = function firstNode() {
        return this.first && this.first.firstNode();
    };

    SimpleBlockTracker.prototype.lastNode = function lastNode() {
        return this.last && this.last.lastNode();
    };

    SimpleBlockTracker.prototype.openElement = function openElement(element) {
        this.newNode(element);
        this.nesting++;
    };

    SimpleBlockTracker.prototype.closeElement = function closeElement() {
        this.nesting--;
    };

    SimpleBlockTracker.prototype.newNode = function newNode(node) {
        if (this.nesting !== 0) return;
        if (!this.first) {
            this.first = new First(node);
        }
        this.last = new Last(node);
    };

    SimpleBlockTracker.prototype.newBounds = function newBounds(bounds) {
        if (this.nesting !== 0) return;
        if (!this.first) {
            this.first = bounds;
        }
        this.last = bounds;
    };

    SimpleBlockTracker.prototype.newDestroyable = function newDestroyable(d) {
        this.destroyables = this.destroyables || [];
        this.destroyables.push(d);
    };

    SimpleBlockTracker.prototype.finalize = function finalize(stack) {
        if (!this.first) {
            stack.appendComment('');
        }
    };

    return SimpleBlockTracker;
}();

var RemoteBlockTracker = function (_SimpleBlockTracker) {
    _inherits(RemoteBlockTracker, _SimpleBlockTracker);

    function RemoteBlockTracker() {
        _classCallCheck(this, RemoteBlockTracker);

        return _possibleConstructorReturn(this, _SimpleBlockTracker.apply(this, arguments));
    }

    RemoteBlockTracker.prototype.destroy = function destroy() {
        _SimpleBlockTracker.prototype.destroy.call(this);
        clear(this);
    };

    return RemoteBlockTracker;
}(SimpleBlockTracker);

export var UpdatableBlockTracker = function (_SimpleBlockTracker2) {
    _inherits(UpdatableBlockTracker, _SimpleBlockTracker2);

    function UpdatableBlockTracker() {
        _classCallCheck(this, UpdatableBlockTracker);

        return _possibleConstructorReturn(this, _SimpleBlockTracker2.apply(this, arguments));
    }

    UpdatableBlockTracker.prototype.reset = function reset(env) {
        var destroyables = this.destroyables;

        if (destroyables && destroyables.length) {
            for (var i = 0; i < destroyables.length; i++) {
                env.didDestroy(destroyables[i]);
            }
        }
        var nextSibling = clear(this);
        this.first = null;
        this.last = null;
        this.destroyables = null;
        this.nesting = 0;
        return nextSibling;
    };

    return UpdatableBlockTracker;
}(SimpleBlockTracker);

var BlockListTracker = function () {
    function BlockListTracker(parent, boundList) {
        _classCallCheck(this, BlockListTracker);

        this.parent = parent;
        this.boundList = boundList;
        this.parent = parent;
        this.boundList = boundList;
    }

    BlockListTracker.prototype.destroy = function destroy() {
        this.boundList.forEachNode(function (node) {
            return node.destroy();
        });
    };

    BlockListTracker.prototype.parentElement = function parentElement() {
        return this.parent;
    };

    BlockListTracker.prototype.firstNode = function firstNode() {
        var head = this.boundList.head();
        return head && head.firstNode();
    };

    BlockListTracker.prototype.lastNode = function lastNode() {
        var tail = this.boundList.tail();
        return tail && tail.lastNode();
    };

    BlockListTracker.prototype.openElement = function openElement(_element) {
        assert(false, 'Cannot openElement directly inside a block list');
    };

    BlockListTracker.prototype.closeElement = function closeElement() {
        assert(false, 'Cannot closeElement directly inside a block list');
    };

    BlockListTracker.prototype.newNode = function newNode(_node) {
        assert(false, 'Cannot create a new node directly inside a block list');
    };

    BlockListTracker.prototype.newBounds = function newBounds(_bounds) {};

    BlockListTracker.prototype.newDestroyable = function newDestroyable(_d) {};

    BlockListTracker.prototype.finalize = function finalize(_stack) {};

    return BlockListTracker;
}();
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["lib/builder.js"],"names":["clear","Stack","assert","SimpleElementOperations","First","node","firstNode","Last","lastNode","Fragment","bounds","parentElement","update","ElementStack","env","parentNode","nextSibling","constructing","operations","elementStack","nextSiblingStack","blockStack","dom","getAppendOperations","updateOperations","getDOM","element","defaultOperations","pushSimpleBlock","push","forInitialRender","resume","tracker","stack","pushBlockTracker","expectConstructing","method","expectOperations","block","current","popElement","topElement","pop","SimpleBlockTracker","pushUpdatableBlock","UpdatableBlockTracker","isRemote","newDestroyable","newBounds","pushBlockList","list","BlockListTracker","popBlock","finalize","openElement","tag","_operations","undefined","createElement","flushElement","parent","insertBefore","pushElement","pushRemoteElement","RemoteBlockTracker","popRemoteElement","d","appendText","string","text","createTextNode","newNode","appendComment","comment","createComment","setStaticAttribute","name","value","addStaticAttribute","setStaticAttributeNS","namespace","addStaticAttributeNS","setDynamicAttribute","reference","isTrusting","addDynamicAttribute","setDynamicAttributeNS","addDynamicAttributeNS","closeElement","first","last","destroyables","nesting","destroy","length","i","reset","didDestroy","boundList","forEachNode","head","tail","_element","_node","_bounds","_d","_stack"],"mappings":"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","file":"lib/builder.js","sourcesContent":["import { clear } from './bounds';\nimport { Stack, assert, expect } from '@glimmer/util';\nimport { SimpleElementOperations } from './compiled/opcodes/dom';\nclass First {\n    constructor(node) {\n        this.node = node;\n    }\n    firstNode() {\n        return this.node;\n    }\n}\nclass Last {\n    constructor(node) {\n        this.node = node;\n    }\n    lastNode() {\n        return this.node;\n    }\n}\nexport class Fragment {\n    constructor(bounds) {\n        this.bounds = bounds;\n    }\n    parentElement() {\n        return this.bounds.parentElement();\n    }\n    firstNode() {\n        return this.bounds.firstNode();\n    }\n    lastNode() {\n        return this.bounds.lastNode();\n    }\n    update(bounds) {\n        this.bounds = bounds;\n    }\n}\nexport class ElementStack {\n    constructor(env, parentNode, nextSibling) {\n        this.constructing = null;\n        this.operations = null;\n        this.elementStack = new Stack();\n        this.nextSiblingStack = new Stack();\n        this.blockStack = new Stack();\n        this.env = env;\n        this.dom = env.getAppendOperations();\n        this.updateOperations = env.getDOM();\n        this.element = parentNode;\n        this.nextSibling = nextSibling;\n        this.defaultOperations = new SimpleElementOperations(env);\n        this.pushSimpleBlock();\n        this.elementStack.push(this.element);\n        this.nextSiblingStack.push(this.nextSibling);\n    }\n    static forInitialRender(env, parentNode, nextSibling) {\n        return new ElementStack(env, parentNode, nextSibling);\n    }\n    static resume(env, tracker, nextSibling) {\n        let parentNode = tracker.parentElement();\n        let stack = new ElementStack(env, parentNode, nextSibling);\n        stack.pushBlockTracker(tracker);\n        return stack;\n    }\n    expectConstructing(method) {\n        return expect(this.constructing, `${method} should only be called while constructing an element`);\n    }\n    expectOperations(method) {\n        return expect(this.operations, `${method} should only be called while constructing an element`);\n    }\n    block() {\n        return expect(this.blockStack.current, \"Expected a current block tracker\");\n    }\n    popElement() {\n        let { elementStack, nextSiblingStack } = this;\n        let topElement = elementStack.pop();\n        nextSiblingStack.pop();\n        // LOGGER.debug(`-> element stack ${this.elementStack.toArray().map(e => e.tagName).join(', ')}`);\n        this.element = expect(elementStack.current, \"can't pop past the last element\");\n        this.nextSibling = nextSiblingStack.current;\n        return topElement;\n    }\n    pushSimpleBlock() {\n        let tracker = new SimpleBlockTracker(this.element);\n        this.pushBlockTracker(tracker);\n        return tracker;\n    }\n    pushUpdatableBlock() {\n        let tracker = new UpdatableBlockTracker(this.element);\n        this.pushBlockTracker(tracker);\n        return tracker;\n    }\n    pushBlockTracker(tracker, isRemote = false) {\n        let current = this.blockStack.current;\n        if (current !== null) {\n            current.newDestroyable(tracker);\n            if (!isRemote) {\n                current.newBounds(tracker);\n            }\n        }\n        this.blockStack.push(tracker);\n        return tracker;\n    }\n    pushBlockList(list) {\n        let tracker = new BlockListTracker(this.element, list);\n        let current = this.blockStack.current;\n        if (current !== null) {\n            current.newDestroyable(tracker);\n            current.newBounds(tracker);\n        }\n        this.blockStack.push(tracker);\n        return tracker;\n    }\n    popBlock() {\n        this.block().finalize(this);\n        return expect(this.blockStack.pop(), \"Expected popBlock to return a block\");\n    }\n    openElement(tag, _operations) {\n        // workaround argument.length transpile of arg initializer\n        let operations = _operations === undefined ? this.defaultOperations : _operations;\n        let element = this.dom.createElement(tag, this.element);\n        this.constructing = element;\n        this.operations = operations;\n        return element;\n    }\n    flushElement() {\n        let parent = this.element;\n        let element = expect(this.constructing, `flushElement should only be called when constructing an element`);\n        this.dom.insertBefore(parent, element, this.nextSibling);\n        this.constructing = null;\n        this.operations = null;\n        this.pushElement(element, null);\n        this.block().openElement(element);\n    }\n    pushRemoteElement(element, nextSibling = null) {\n        this.pushElement(element, nextSibling);\n        let tracker = new RemoteBlockTracker(element);\n        this.pushBlockTracker(tracker, true);\n    }\n    popRemoteElement() {\n        this.popBlock();\n        this.popElement();\n    }\n    pushElement(element, nextSibling) {\n        this.element = element;\n        this.elementStack.push(element);\n        // LOGGER.debug(`-> element stack ${this.elementStack.toArray().map(e => e.tagName).join(', ')}`);\n        this.nextSibling = nextSibling;\n        this.nextSiblingStack.push(nextSibling);\n    }\n    newDestroyable(d) {\n        this.block().newDestroyable(d);\n    }\n    newBounds(bounds) {\n        this.block().newBounds(bounds);\n    }\n    appendText(string) {\n        let { dom } = this;\n        let text = dom.createTextNode(string);\n        dom.insertBefore(this.element, text, this.nextSibling);\n        this.block().newNode(text);\n        return text;\n    }\n    appendComment(string) {\n        let { dom } = this;\n        let comment = dom.createComment(string);\n        dom.insertBefore(this.element, comment, this.nextSibling);\n        this.block().newNode(comment);\n        return comment;\n    }\n    setStaticAttribute(name, value) {\n        this.expectOperations('setStaticAttribute').addStaticAttribute(this.expectConstructing('setStaticAttribute'), name, value);\n    }\n    setStaticAttributeNS(namespace, name, value) {\n        this.expectOperations('setStaticAttributeNS').addStaticAttributeNS(this.expectConstructing('setStaticAttributeNS'), namespace, name, value);\n    }\n    setDynamicAttribute(name, reference, isTrusting) {\n        this.expectOperations('setDynamicAttribute').addDynamicAttribute(this.expectConstructing('setDynamicAttribute'), name, reference, isTrusting);\n    }\n    setDynamicAttributeNS(namespace, name, reference, isTrusting) {\n        this.expectOperations('setDynamicAttributeNS').addDynamicAttributeNS(this.expectConstructing('setDynamicAttributeNS'), namespace, name, reference, isTrusting);\n    }\n    closeElement() {\n        this.block().closeElement();\n        this.popElement();\n    }\n}\nexport class SimpleBlockTracker {\n    constructor(parent) {\n        this.parent = parent;\n        this.first = null;\n        this.last = null;\n        this.destroyables = null;\n        this.nesting = 0;\n    }\n    destroy() {\n        let { destroyables } = this;\n        if (destroyables && destroyables.length) {\n            for (let i = 0; i < destroyables.length; i++) {\n                destroyables[i].destroy();\n            }\n        }\n    }\n    parentElement() {\n        return this.parent;\n    }\n    firstNode() {\n        return this.first && this.first.firstNode();\n    }\n    lastNode() {\n        return this.last && this.last.lastNode();\n    }\n    openElement(element) {\n        this.newNode(element);\n        this.nesting++;\n    }\n    closeElement() {\n        this.nesting--;\n    }\n    newNode(node) {\n        if (this.nesting !== 0) return;\n        if (!this.first) {\n            this.first = new First(node);\n        }\n        this.last = new Last(node);\n    }\n    newBounds(bounds) {\n        if (this.nesting !== 0) return;\n        if (!this.first) {\n            this.first = bounds;\n        }\n        this.last = bounds;\n    }\n    newDestroyable(d) {\n        this.destroyables = this.destroyables || [];\n        this.destroyables.push(d);\n    }\n    finalize(stack) {\n        if (!this.first) {\n            stack.appendComment('');\n        }\n    }\n}\nclass RemoteBlockTracker extends SimpleBlockTracker {\n    destroy() {\n        super.destroy();\n        clear(this);\n    }\n}\nexport class UpdatableBlockTracker extends SimpleBlockTracker {\n    reset(env) {\n        let { destroyables } = this;\n        if (destroyables && destroyables.length) {\n            for (let i = 0; i < destroyables.length; i++) {\n                env.didDestroy(destroyables[i]);\n            }\n        }\n        let nextSibling = clear(this);\n        this.first = null;\n        this.last = null;\n        this.destroyables = null;\n        this.nesting = 0;\n        return nextSibling;\n    }\n}\nclass BlockListTracker {\n    constructor(parent, boundList) {\n        this.parent = parent;\n        this.boundList = boundList;\n        this.parent = parent;\n        this.boundList = boundList;\n    }\n    destroy() {\n        this.boundList.forEachNode(node => node.destroy());\n    }\n    parentElement() {\n        return this.parent;\n    }\n    firstNode() {\n        let head = this.boundList.head();\n        return head && head.firstNode();\n    }\n    lastNode() {\n        let tail = this.boundList.tail();\n        return tail && tail.lastNode();\n    }\n    openElement(_element) {\n        assert(false, 'Cannot openElement directly inside a block list');\n    }\n    closeElement() {\n        assert(false, 'Cannot closeElement directly inside a block list');\n    }\n    newNode(_node) {\n        assert(false, 'Cannot create a new node directly inside a block list');\n    }\n    newBounds(_bounds) {}\n    newDestroyable(_d) {}\n    finalize(_stack) {}\n}"]}