knate/src/KNateAbstractDom.js

const K = window.K;

// -----------------------------------------------------------------------------
//                                  Prototypes
// -----------------------------------------------------------------------------

K.NateAbstractDomProto = Object.assign({}, K.BSC.NateAbstractProto,
{
  init(parentOrElem, namespace)
  {
    K.BSC.NateAbstractProto.init.call(this, parentOrElem, namespace);

    this.nateParent = null;
    this.elem       = null;
    this.isDeleted  = false;

    // If there is parentOrElem, check the type of it.
    if (K.Object.isNotNull(parentOrElem))
    {
      if (parentOrElem.addNateChild)
      {
        // Possible improvement: Better way to check is it nate object?
        parentOrElem.addNateChild(this)
      }
      else if (K.Elem.isElem(parentOrElem) || K.Elem.isText(parentOrElem))
      {
        if (K.Object.isNotNull(parentOrElem.nate))
        {
          throw 'Cannot create 2nd Nate object for same elem! The element you provided as elem for Nate is already a elem for different nate object';
        }
        else
        {
          // First, attach this Nate object to element.
          this.attachNateToElem(parentOrElem);

          // Then, check if DOM parent is Nate object - if yes, tell it about me.
          if (K.Object.isNotNull(parentOrElem.parentNode) &&
              K.Object.isNotNull(parentOrElem.parentNode.nate))
          {
            parentOrElem.parentNode.nate.addNateChild(this);
          }
        }
      }
      else
      {
        throw new K.Error({
          errorCode: 'invalidNateParent',
          ext: {
            parent: parentOrElem,
            hint: 'parentOrElem should be Nate object or nate-element'
          }
        })
      }
    }
    else
    {
      throw new K.Error({
        errorCode: 'invalidNateParent',
        ext: {
          parent: parentOrElem,
          hint: 'parentOrElem should be Nate object or nate-element - cannot be null'
        }
      })
    }
  },

  _confirmIsNotDeleted()
  {
    if (this.isDeleted)
    {
      console.log('PANIC! Nate item', this.elem, 'already deleted');

      throw new K.Error({
        errorCode: 'nateItemAlreadyDeleted',
        ext: {elem: this.elem}});
    }
  },

  deleteAllChildren()
  {
    this._confirmIsNotDeleted();
    // Possible improvement: optimize this
    while (this.children.length > 0)
    {
      this.children[0].delete();
    }
    this.isNateChildAllowed = true;
  },

  delete()
  {
    this._confirmIsNotDeleted();

    K.BSC.NateAbstractProto.delete.call(this);

    // Remove nate elem from tree.
    if (K.Object.isNotNull(this.nateParent))
    {
      this.isDeleted = true;
      this.nateParent.removeNateChild(this);
    }
    else
    {
      try
      {
        this.elem.parentNode.removeChild(this.elem);
      }
      catch(err)
      {
        console.log('Error during removeChild parent is:', this.elem.parentNode, 'child is:', this.elem);
      }
    }
  },

  addNateChild(nateChild)
  {
    this._confirmIsNateChildAllowed();

    if (K.Object.isNotNull(nateChild.nateParent))
    {
      throw 'Moving nate-child between parents not yet supported.';
    }

    nateChild.nateParent = this;

    this.children.push(nateChild);

    if (K.Object.isNotNull(this.elem) &&
        K.Object.isNotNull(nateChild.elem) &&
        (nateChild.elem.parentNode != this.elem))
    {
      this.elem.appendChild(nateChild.elem);
    }
  },

  removeNateChild(nateChild)
  {
    if (nateChild.nateParent != this)
    {
      throw 'Can\'t remove nateChild from me, as the child claims his parent is another object.';
    }

    K.Array.removeAll(this.children, nateChild);

    if (K.Object.isNotNull(this.elem) &&
        K.Object.isNotNull(nateChild.elem))
    {
      try
      {
        this.elem.removeChild(nateChild.elem);
      }
      catch(err)
      {
        console.log('Error during removeChild parent is:', this.elem, 'child is:', nateChild.elem);
      }
    }

    nateChild.nateParent = null;
  },

  attachNateToElem(elem)
  {
    this._confirmIsNotDeleted();

    // Avoid registering >1 Nate objects to one elem.
    if (K.Object.isNotNull(elem.nate))
    {
      throw 'Provided elem already has Nate object';
    }

    // Remove from current element is not supported.
    if (K.Object.isNotNull(this.elem))
    {
      throw 'This nate object is already attached to element.';
    }

    // Attach this object to elem.
    this.elem      = elem;
    this.elem.nate = this;

    for (let child in this.children)
    {
      throw 'This needs to be updated...';

      this.elem.appendChild(child);
    }
  },

  attachElemToNate(elem)
  {
    // First, attach this Nate object to element.
    this.attachNateToElem(elem)

    if (K.Object.isNotNull(newNate.nateParent.elem) &&
        K.Object.isNotNull(newNate.elem) &&
        (newNate.elem.parentNode != newNate.nateParent))
    {
      newNate.nateParent.elem.appendChild(newNate.elem);
    }
  },

  getElem()
  {
    this._confirmIsNotDeleted();

    return this.elem;
  },

  commonInnerContentSetter(nNode, key, value) {
    nNode._confirmThereAreNoNateChildren()

    if (K.Object.isUndefinedOrNull(value) || (value === '')) {
      // Clear inner content, enable newXxx() calls to create nate-childs.
      nNode.elem[key]          = ''
      nNode.isNateChildAllowed = true

    } else {
      // Set new inner content - disable newXxx() calls to forbid nate-childs.
      nNode.elem[key]          = value
      nNode.isNateChildAllowed = false
    }
  }
})