Function createClassProxy

src/proxy/createClassProxy.js:100–451

(InitialComponent, proxyKey, options = {})

export const forEachKnownClass = cb => knownClassComponents.forEach(cb);

function createClassProxy(InitialComponent, proxyKey, options = {}) {
  const renderOptions = {
    ...defaultRenderOptions,
    ...options,
  };
  const proxyConfig = {
    ...config,
    ...options.proxy,
  };
  // Prevent double wrapping.
  // Given a proxy class, return the existing proxy managing it.
  const existingProxy = proxies.get(InitialComponent);

  if (existingProxy) {
    return existingProxy;
  }

  let CurrentComponent;
  let savedDescriptors = {};
  let injectedMembers = {};
  let proxyGeneration = 0;
  let classUpdatePostponed = null;
  let instancesCount = 0;
  let isFunctionalComponent = !isReactClass(InitialComponent);

  let lastInstance = null;

  function postConstructionAction() {
    this[GENERATION] = 0;

    lastInstance = this;
    // is there is an update pending
    if (classUpdatePostponed) {
      const callUpdate = classUpdatePostponed;
      classUpdatePostponed = null;
      callUpdate();
    }
    // As long we can't override constructor
    // every class shall evolve from a base class
    inject(this, proxyGeneration, injectedMembers);
  }

  function proxiedUpdate() {
    if (this) {
      inject(this, proxyGeneration, injectedMembers);
    }
  }

  function lifeCycleWrapperFactory(wrapperName, sideEffect = identity) {
    return copyMethodDescriptors(function wrappedMethod(...rest) {
      proxiedUpdate.call(this);
      sideEffect(this);
      return (
        !isFunctionalComponent &&
        CurrentComponent.prototype[wrapperName] &&
        CurrentComponent.prototype[wrapperName].apply(this, rest)
      );
    }, InitialComponent.prototype && InitialComponent.prototype[wrapperName]);