render: function render()

in assets/modelRepository/vue.js [8535:8665]
78 lines of code
29 McCabe index (conditional complexity)

    render: function render(h) {
      const this$1 = this;

      let children = this.$slots.default;
      if (!children) {
        return;
      }

      // filter out text nodes (possible whitespaces)
      children = children.filter(function(c) {
        return c.tag || isAsyncPlaceholder(c);
      });
      /* istanbul ignore if */
      if (!children.length) {
        return;
      }

      // warn multiple elements
      if ("development" !== "production" && children.length > 1) {
        warn(
          "<transition> can only be used on a single element. Use " +
            "<transition-group> for lists.",
          this.$parent
        );
      }

      const mode = this.mode;

      // warn invalid mode
      if (
        "development" !== "production" &&
        mode &&
        mode !== "in-out" &&
        mode !== "out-in"
      ) {
        warn("invalid <transition> mode: " + mode, this.$parent);
      }

      const rawChild = children[0];

      // if this is a component root node and the component's
      // parent container node also has transition, skip.
      if (hasParentTransition(this.$vnode)) {
        return rawChild;
      }

      // apply transition data to child
      // use getRealChild() to ignore abstract components e.g. keep-alive
      const child = getRealChild(rawChild);
      /* istanbul ignore if */
      if (!child) {
        return rawChild;
      }

      if (this._leaving) {
        return placeholder(h, rawChild);
      }

      // ensure a key that is unique to the vnode type and to this transition
      // component instance. This key will be used to remove pending leaving nodes
      // during entering.
      const id = "__transition-" + this._uid + "-";
      child.key =
        child.key == null
          ? child.isComment
            ? id + "comment"
            : id + child.tag
          : isPrimitive(child.key)
          ? String(child.key).indexOf(id) === 0
            ? child.key
            : id + child.key
          : child.key;

      const data = ((
        child.data || (child.data = {})
      ).transition = extractTransitionData(this));
      const oldRawChild = this._vnode;
      const oldChild = getRealChild(oldRawChild);

      // mark v-show
      // so that the transition module can hand over the control to the directive
      if (
        child.data.directives &&
        child.data.directives.some(function(d) {
          return d.name === "show";
        })
      ) {
        child.data.show = true;
      }

      if (
        oldChild &&
        oldChild.data &&
        !isSameChild(child, oldChild) &&
        !isAsyncPlaceholder(oldChild) &&
        // #6687 component root is a comment node
        !(
          oldChild.componentInstance &&
          oldChild.componentInstance._vnode.isComment
        )
      ) {
        // replace old child transition data with fresh one
        // important for dynamic transitions!
        const oldData = (oldChild.data.transition = extend({}, data));
        // handle transition mode
        if (mode === "out-in") {
          // return placeholder node and queue update when leave finishes
          this._leaving = true;
          mergeVNodeHook(oldData, "afterLeave", function() {
            this$1._leaving = false;
            this$1.$forceUpdate();
          });
          return placeholder(h, rawChild);
        } else if (mode === "in-out") {
          if (isAsyncPlaceholder(child)) {
            return oldRawChild;
          }
          let delayedLeave;
          const performLeave = function() {
            delayedLeave();
          };
          mergeVNodeHook(data, "afterEnter", performLeave);
          mergeVNodeHook(data, "enterCancelled", performLeave);
          mergeVNodeHook(oldData, "delayLeave", function(leave) {
            delayedLeave = leave;
          });
        }
      }

      return rawChild;
    }