knate/src/KNateXmlStatic.js

const K = require('kcore');
require('./KNateAbstractStatic');

const COMPACT = true;
// hard LB - always present.
const LBH = '\n';
// soft LB - present only when COMPACT = false
const LB = COMPACT ? '' : '\n';

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

K.NateXmlAbstractProto = Object.assign({}, K.NateAbstractProto,
{
  NOTHING:            0,
  JUST_CHILDREN:      1,
  JUST_THE_INNER:     2,
  OPEN_CLOSE_AT_ONCE: 3,
  OPEN_THEN_CLOSE:    4,

  escapeXmlTags(unsafe) {
    // https://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references
    return unsafe
          .replace(/&/g, '&')
          .replace(/</g, '&lt;')
          .replace(/>/g, '&gt;');
  },

  commonAttributeSetter(nNode, key, value) {
    if (!nNode.isAttributeNamesCaseSensitive) {
      key = key.toLowerCase();
    }
    nNode.tagParamsList[key] = value
  },

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

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

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

  commonOnOffAttributeSetter(nNode, key, value) {
    if (value) {
      nNode.tagParamsList[key] = key
    } else if (nNode.tagParamsList[key]) {
      delete nNode.tagParamsList[key]
    }
  },

  init(parent, namespace)
  {
    K.NateAbstractProto.init.call(this, parent, namespace);

    this.enabled          = true;
    this.tagOpenCloseMode = K.NateXmlAbstractProto.JUST_CHILDREN;
    this.tagParamsList    = {};

    this.isTagNameCaseSensitive        = false;
    this.isAttributeNamesCaseSensitive = false;
    this.addSlashToOpenCloseAtOnceTag  = false;
  },

  _getDefaultNamespace() {
    // Default namespace for all NateXmlStatic elements used when there is no
    // parent item.
    return K.nateXmlStaticNamespace
  },

  setText(txt)
  {
    this.tagInnerContent = txt;

    return this;
  },

  setTag(tagName, tagParams, tagInnerContent, tagOpenCloseMode)
  {
    if (this.isTagNameCaseSensitive)
    {
      this.tagName = tagName
    }
    else
    {
      this.tagName = tagName ? tagName.toLowerCase() : tagName;
    }

    this.tagOpenCloseMode = tagOpenCloseMode;

    //
    // Set inner text.
    //

    if (K.Object.isUndefinedOrNull(tagInnerContent))
    {
      // Inner text not specified - just init with empty string.
      this.tagInnerContent = '';
    }
    else if (K.Object.isString(tagInnerContent))
    {
      // Inner text specified as pure string - just save it as is
      // for render time.
      this.tagInnerContent = tagInnerContent;
    }
    else if (typeof tagInnerContent === 'number')
    {
      // Inner text specified as number - convert it to string.
      this.tagInnerContent = tagInnerContent.toString();
    }
    else
    {
      // Unexpected inner text type.
      this.tagInnerContent = '[error: wrong inner text type]';

      console.log('NateXmlAbstract::setTag(', tagName, '): PANIC! Unexpected inner text type', typeof(tagInnerContent));
    }

    //
    // Set params list.
    //

    if (K.Object.isUndefinedOrNull(tagParams))
    {
      // Do nothing with params - just leave them alone.
    }
    else if (K.Object.isObject(tagParams))
    {
      K.Object.merge(this.tagParamsList, tagParams);
    }
    else
    {
      console.log('NateXmlAbstract::setTag(', tagName, '): PANIC! Invalid params list:', tagParams);
    }
  },

  tagOpenClose(tag, params)
  {
    const rv = this.getNamespace().createNate(this);

    rv.setTag(tag, params, null, K.NateXmlAbstractProto.OPEN_THEN_CLOSE);

    return rv;
  },

  tagOpenCloseAtOnce(tagName, params)
  {
    const rv = this.getNamespace().createNate(this);

    rv.setTag(tagName, params, null, K.NateXmlAbstractProto.OPEN_CLOSE_AT_ONCE);

    return rv;
  },

  _renderParams()
  {
    let rv = ''

    for (let paramKey in this.tagParamsList) {
      const value = this.tagParamsList[paramKey]
      // If this is "boolean attribute", according to "2.4.2. Boolean attributes" of "HTML 5.3" spec
      // (http://w3c.github.io/html/infrastructure.html#sec-boolean-attributes)
      // then we just add the key without value.
      // For example in <script async> - the "async" is boolean
      // another example <input type="checkbox" checked> - the "checked" is boolean
      if (typeof value === 'boolean') {
        if (value) {
          rv += ' ' + paramKey
        }
      } else {
        rv += ' ' + paramKey + '="' + value + '"'
      }
    }

    return rv
  },

  render()
  {
    let rv = '';

    if (this.enabled)
    {
      switch (this.tagOpenCloseMode)
      {
        case K.NateXmlAbstractProto.JUST_THE_INNER:
        {
          rv = this.tagInnerContent;
          rv += K.NateAbstractProto.render.call(this); // TODO: super.render()

          break;
        }

        case K.NateXmlAbstractProto.OPEN_CLOSE_AT_ONCE:
        case K.NateXmlAbstractProto.OPEN_THEN_CLOSE:
        {
          rv = '<' + this.tagName;
          rv += this._renderParams();

          if (this.tagOpenCloseMode == K.NateXmlAbstractProto.OPEN_CLOSE_AT_ONCE)
          {
            if (this.addSlashToOpenCloseAtOnceTag)
            {
              rv += '/>';
            }
            else
            {
              rv += '>';
            }
          }
          else
          {
            rv += '>';
            rv += K.NateAbstractProto.render.call(this); // TODO: super.render()
            rv += this.tagInnerContent;
            rv += '</' + this.tagName + '>' + LB;
          }

          break;
        }

        case K.NateXmlAbstractProto.JUST_CHILDREN:
        {
          rv += K.NateAbstractProto.render.call(this); // TODO: super.render()

          break;
        }
      }
    }

    return rv;
  }
});

// -----------------------------------------------------------------------------
//                                  Common setters
// -----------------------------------------------------------------------------

K.nateXmlStaticNamespace =
  K.BSC.nateNullNamespace.createExtension('XmlStatic', {nateProto: K.NateXmlAbstractProto})

K.nateXmlStaticNamespace.addSetter('text', K.NateXmlAbstractProto.commonInnerContentSetter)

K.nateXmlStaticNamespace.addSetter('enabled', (nNode, key, value) => {
  nNode.enabled = value
})

K.nateXmlStaticNamespace.addSetter('on', (nNode, key, value) => {
  nNode.set('enabled', value)
})

// -----------------------------------------------------------------------------
//                                  Factory functions
// -----------------------------------------------------------------------------

K.NateXmlAbstract = function(parent, namespace)
{
  const thiz = Object.create(K.NateXmlAbstractProto);

  K.BSC.NateAbstractProto.init.call(thiz, parent, namespace);
  K.NateAbstractProto.init.call(thiz, parent);

  thiz.init(parent);

  return thiz;
}