marko/dist/runtime/vdom/hot-reload.js

UI Components + streaming, async, high performance, HTML templating for Node.js and the browser.

"use strict";var registry = require("@internal/components-registry");
var setImmediate = require("@internal/set-immediate")._j_;
var updateManager = require("../components/update-manager");
var runtime = require(".");

var createTemplate = runtime.t;
var createComponent = registry._G_;
var registered = {};
var instancesByType = {};
var queue;

exports.t = runtime.t = function (typeName) {
  if (registered[typeName]) {
    return registered[typeName];
  }

  var renderFn;
  var template = registered[typeName] = createTemplate(typeName);
  var instances = instancesByType[typeName] = new Set();
  Object.defineProperty(template, "_", {
    get: function () {
      return renderFn && proxyRenderer;
    },
    set: function (v) {
      renderFn = v;

      if (instances.size) {
        if (!queue) {
          queue = [];
          setImmediate(batchUpdate);
        }

        queue.push(function () {
          var newProto = registry._H_(typeName).prototype;
          instances.forEach(function (instance) {
            if (hasLifecycleChanged(instance.__proto__, newProto)) {
              var renderer = instance.Q_;
              instance.Q_ = (input, out) => {
                instance.aF_(input, out);
                if (instance.onInput) {
                  input = instance.onInput(input, out) || input;
                }
                instance.Q_ = renderer;
                instance.Q_(input, out);
              };

              instance.co_ = true;
              instance.ao_();
              instance._x_ = false;

              if (instance.ai_) {
                instance.ai_.removeAllListeners();
                instance.ai_ = null;
              }
            }

            instance.__proto__ = newProto;
            instance._F_(
              instance.O_, false).
            afterInsert(instance.B_);
          });
        });
      }
    }
  });

  return template;

  function proxyRenderer() {
    return renderFn.apply(this, arguments);
  }
};

registry._G_ = function (typeName, id) {
  var instances = instancesByType[typeName];
  var instance = createComponent(typeName, id);

  if (instances) {
    instances.add(instance);
    instance.once("destroy", function () {
      if (!instance.co_) {
        instances.delete(instance);
      }
    });
  }

  return instance;
};

function hasLifecycleChanged(oldProto, newProto) {
  return (
    hasMethodChanged("onCreate") ||
    hasMethodChanged("onInput") ||
    hasMethodChanged("onRender") ||
    hasMethodChanged("onMount"));


  function hasMethodChanged(method) {
    return (
      (oldProto[method] && oldProto[method].toString()) !== (
      newProto[method] && newProto[method].toString()));

  }
}

function batchUpdate() {
  updateManager.ay_(function () {
    var pending = queue;
    queue = undefined;

    for (var i = 0; i < pending.length; i++) {
      pending[i]();
    }
  });
}