@ygracs/xepg-lib-js 0.0.15

package/lib/xepgdoc-lib.js

@@ -0,0 +1,1024 @@
+// [v0.1.050-20221206]
+
+// === module init block ===
+
+const fs = require('fs');
+const fse = require('fs').promises;
+const xmlParser = require('@ygracs/xml-js6');
+
+const {
+  valueToIndex,
+  readAsString, readAsNumberEx,
+  isNotEmptyString,
+  isArray, isObject, isPlainObject,
+} = require('@ygracs/bsfoc-lib-js');
+
+const {
+  convValueToTZString, convTZStringToValue,
+} = require('@ygracs/dtf-lib-js');
+
+const {
+  chkDTSysID, getDTSysName,
+  convStringToDTValue, convDTValueToString,
+} = require('./dts-helper.js');
+
+const xObj = require('@ygracs/xobj-lib-js');
+
+const TXmlContentParseOptions = xObj.TXmlContentParseOptions;
+const insertXObjElement = xObj.insertXObjElement;
+const getXObjElement = xObj.getXObjElement;
+
+const XEPG_ROOT_ETAG_NAME = 'epgdoc';
+const XEPG_DEF_NS_NAME = 'tvp';
+const XEPG_DEF_NS_PATH = 'urn:e-doc:epg-doc:xepg';
+const XEPG_HEADER_ETAG_NAME = `${XEPG_DEF_NS_NAME}:info`;
+const XEPG_BODY_ETAG_NAME = `${XEPG_DEF_NS_NAME}:list`;
+const XEPG_SCHED_ETAG_NAME = `${XEPG_DEF_NS_NAME}:item`;
+const XEPG_PRVINFO_ETAG_NAME = `${XEPG_DEF_NS_NAME}:provider`;
+const XEPG_DTSINFO_ETAG_NAME = `${XEPG_DEF_NS_NAME}:dtstype`;
+const XEPG_DOCDTO_ETAG_NAME = `${XEPG_DEF_NS_NAME}:time`;
+const XEPG_DOCDTE_ETAG_NAME = `${XEPG_DEF_NS_NAME}:expire`;
+const XEPG_DOCTZ_ETAG_NAME = `${XEPG_DEF_NS_NAME}:timezone`;
+const XEPG_DOCSCH_ETAG_NAME = `${XEPG_DEF_NS_NAME}:schema`;
+const XEPG_DOCTYP_ETAG_NAME = `${XEPG_DEF_NS_NAME}:doctype`;
+const XEPG_CHNID_ETAG_NAME = `${XEPG_DEF_NS_NAME}:chnid`;
+const XEPG_CHNNAME_ETAG_NAME = `${XEPG_DEF_NS_NAME}:chname`;
+const XEPG_CHNGID_ETAG_NAME = `${XEPG_DEF_NS_NAME}:chngid`;
+const XEPG_CHNURL_ETAG_NAME = `${XEPG_DEF_NS_NAME}:srcurl`;
+const XEPG_SCHEDTIME_ETAG_NAME = `${XEPG_DEF_NS_NAME}:time`;
+const XEPG_SCHEDTITL_ETAG_NAME = `${XEPG_DEF_NS_NAME}:title`;
+const XEPG_SCHEDCAT_ETAG_NAME = `${XEPG_DEF_NS_NAME}:cat`;
+const XEPG_SCHEDPMARK_ETAG_NAME = `${XEPG_DEF_NS_NAME}:pcmark`;
+const XEPG_SCHEDDESC_ETAG_NAME = `${XEPG_DEF_NS_NAME}:desc`;
+const XEPG_XML_DOC_VERSION = '1.0';
+const XEPG_DEF_ENCODING_VALUE = 'UTF-8';
+const XEPG_DEF_DOCUMENT_TYPE = 'xepg';
+const XEPG_DEF_DOCUMENT_SCHEMA = '0.2';
+const XEPG_DEF_PROVIDER_NAME = 'xepg-lib-js';
+const XEPG_DEF_PROVIDER_VER = '0.0.15';
+const defXEpgDocOptions = {
+  xmlns_xepg_pref: XEPG_DEF_NS_NAME,
+  xmlns_xepg_path: XEPG_DEF_NS_PATH,
+  rootElementTagName: XEPG_ROOT_ETAG_NAME,
+  docHeaderTagName: XEPG_HEADER_ETAG_NAME,
+  docBodyTagName: XEPG_BODY_ETAG_NAME,
+  docBodyElementTagName: XEPG_SCHED_ETAG_NAME,
+  docProviderElementTagName: XEPG_PRVINFO_ETAG_NAME,
+  defProviderParam: {
+    name: XEPG_DEF_PROVIDER_NAME,
+    version: XEPG_DEF_PROVIDER_VER,
+    doctype: XEPG_DEF_DOCUMENT_TYPE,
+    schema: XEPG_DEF_DOCUMENT_SCHEMA,
+    xml: XEPG_XML_DOC_VERSION,
+    encoding: XEPG_DEF_ENCODING_VALUE,
+  },
+};
+
+const defParseOptions = new TXmlContentParseOptions();
+//console.log('CHECK: defParseOptions => '+JSON.stringify(defParseOptions, null, 2));
+
+// === module extra block (helper functions) ===
+
+// === xObj-function wrappers (start) ===
+
+function readXObjParam(obj){
+  return xObj.readXObjParam(obj, defParseOptions.settings.textKey);
+};
+
+function writeXObjParam(obj, value){
+  return xObj.writeXObjParam(obj, value, defParseOptions.settings.textKey);
+};
+
+function writeXObjAttr(obj, name, value) {
+  return xObj.writeXObjAttr(
+    obj, name, value, defParseOptions.settings.attributesKey
+  );
+};
+
+// === xObj-function wrappers (end) ===
+
+function _getXmlChildElementParam(obj, elem){
+  const child = obj ? getXObjElement(obj, elem) : null;
+  return child ? readXObjParam(child) : '';
+};
+
+function writeXEpgDocDeclSection(obj, opt){
+  let xml_ver = XEPG_XML_DOC_VERSION;
+  let doc_def_enc = XEPG_DEF_ENCODING_VALUE;
+  let key_name = defParseOptions.settings.declarationKey;
+  if (isPlainObject(opt)) {
+    xml_ver = readAsString(opt.version, xml_ver);
+    doc_def_enc = readAsString(opt.encoding, doc_def_enc);
+  };
+  if (isPlainObject(obj) && isNotEmptyString(key_name)) {
+    obj[key_name] = {};
+    writeXObjAttr(obj[key_name], 'version', xml_ver);
+    writeXObjAttr(obj[key_name], 'encoding', doc_def_enc);
+  };
+};
+
+// === module main block (function definitions) ===
+
+// === module main block (class definitions) ===
+
+class TXEpgSchedulesList {
+  #_content = null;
+  #_options = null;
+  #_dts_src = null;
+  #_tz_src = null;
+
+  constructor(obj, opt) {
+    const _content = isArray(obj) ? obj : [];
+    const _options = isPlainObject(opt) ? opt : {};
+    let { dts_src, tz_src } = _options;
+    if (!isPlainObject(dts_src)) dts_src = null;
+    if (!isPlainObject(tz_src)) tz_src = null;
+    // save content source
+    this.#_content = _content;
+    // save options
+    this.#_options = _options;
+    // save refs to a time source priveders
+    this.#_dts_src = dts_src;
+    this.#_tz_src = tz_src;
+  }
+
+  #_getItem = function(value){
+    if (this.chkScheduleIndex(value)) {
+      return this.#_content[Number(value)];
+    };
+  };
+
+  get schedQty(){
+    return this.#_content.length;
+  }
+
+  // will deprecate
+  //get SchedulesQty(){ return this.#_content.length; }
+
+  get dtstype(){
+    let result = valueToIndex(
+      _getXmlChildElementParam(this.#_dts_src, 'value')
+    );
+    return chkDTSysID(result) ? result : -1;
+  }
+
+  get curDocTZ(){
+    return (
+      this.#_tz_src
+      ? convTZStringToValue(readXObjParam(this.#_tz_src).trim())
+      : 0
+    );
+  }
+
+  hasNoSchedules(){
+    return this.schedQty === 0;
+  }
+
+  hasSchedules(){
+    return this.schedQty > 0;
+  }
+
+  chkScheduleIndex(value){
+    const index = valueToIndex(value);
+    return index !== -1 && index < this.schedQty;
+  }
+
+  getScheduleInfo(index){
+    //console.log('TXEpgSchedulesList => getScheduleInfo() => was called...');
+    const curObj = this.#_getItem(index);
+    let tmpObj = {};
+    //console.log('TXEpgSchedulesList => getScheduleInfo() => index:['+index+']');
+    //console.log('TXEpgSchedulesList => getScheduleInfo('+index+') => '+JSON.stringify(curObj, null, 2));
+    //console.log('TXEpgSchedulesList => getScheduleInfo() => index:['+index+'] - [time]');
+    tmpObj.time = convStringToDTValue(
+      _getXmlChildElementParam(curObj, XEPG_SCHEDTIME_ETAG_NAME).trim(),
+      this.dtstype, this.curDocTZ
+    );
+    //console.log('TXEpgSchedulesList => getScheduleInfo() => index:['+index+'] - [title]');
+    tmpObj.title = _getXmlChildElementParam(curObj, XEPG_SCHEDTITL_ETAG_NAME).trim();
+    //console.log('TXEpgSchedulesList => getScheduleInfo() => index:['+index+'] - [category]');
+    tmpObj.cat = _getXmlChildElementParam(curObj, XEPG_SCHEDCAT_ETAG_NAME).trim();
+    //console.log('TXEpgSchedulesList => getScheduleInfo() => index:['+index+'] - [pcmark]');
+    tmpObj.pcmark = readAsNumberEx(
+      _getXmlChildElementParam(curObj, XEPG_SCHEDPMARK_ETAG_NAME), 0
+    );
+    //console.log('TXEpgSchedulesList => getScheduleInfo() => index:['+index+'] - [description]');
+    tmpObj.descr = _getXmlChildElementParam(curObj, XEPG_SCHEDDESC_ETAG_NAME);
+    //console.log('TXEpgSchedulesList => getScheduleInfo('+index+') => '+JSON.stringify(curObj, null, 2));
+    //console.log('TXEpgSchedulesList => getScheduleInfo('+index+') => '+JSON.stringify(tmpObj, null, 2));
+    // TODO: wrap tmpObj into container object
+    //console.log('TXEpgSchedulesList => getScheduleInfo() => was left...');
+    return tmpObj;
+  }
+
+  getAllSchedulesInfo(){
+    let result = [];
+    for (let i = 0; i < this.schedQty; i++) {
+      let item = this.getScheduleInfo(i);
+      if (isPlainObject(item)) result.push(item);
+    };
+    return result;
+  }
+
+  asJSON(){
+    return JSON.stringify(this.#_content, null, 2);
+  }
+
+};
+
+class TXEpgProviderContainer {
+  #_content = null;
+  #_options = null;
+
+  constructor(obj, opt) {
+    // load content
+    const _content = isPlainObject(obj) ? obj : {};
+    // load options
+    const _options = isPlainObject(opt) ? opt : {};
+    let {
+      parseOptions,
+    } = _options;
+    if (!(parseOptions instanceof TXmlContentParseOptions)) {
+      parseOptions = new TXmlContentParseOptions(parseOptions);
+      _options.parseOptions = parseOptions;
+    };
+    // save content source
+    this.#_content = _content;
+    // save options
+    this.#_options = _options;
+    // init instance
+    this.#_init();
+  }
+
+  #_init(){
+    //const _options = this.#_options;
+    //const { rootETagNS } = _options;
+    //let { docSchemaETagName, docTypeETagName } = _options;
+    //docSchemaETagName = `${rootETagNS}:schema`;
+    //docSchemaETagName = XEPG_DOCSCH_ETAG_NAME;
+    //docTypeETagName = `${rootETagNS}:doctype`;
+    //docTypeETagName = XEPG_DOCTYP_ETAG_NAME;
+    //_options.docSchemaETagName = docSchemaETagName;
+    //_options.docTypeETagName = docTypeETagName;
+  }
+
+  get name(){
+    return _getXmlChildElementParam(this.#_content, 'name').trim();
+  }
+
+  set name(value){
+    this.setName(value);
+  }
+
+  get version(){
+    return _getXmlChildElementParam(this.#_content, 'version').trim();
+  }
+
+  set version(value){
+    if (this.name !== '') {
+      const _value = typeof value === 'string' ? value.trim() : '';
+      const item = insertXObjElement(this.#_content, 'version', true);
+      if (item) writeXObjParam(item, _value);
+    };
+  }
+
+  get schema(){
+    return _getXmlChildElementParam(this.#_content, XEPG_DOCSCH_ETAG_NAME).trim();
+  }
+
+  set schema(value){
+    const _value = typeof value === 'string' ? value.trim() : '';
+    const item = insertXObjElement(this.#_content, XEPG_DOCSCH_ETAG_NAME, true);
+    if (item) writeXObjParam(item, _value);
+  }
+
+  get doctype(){
+    return _getXmlChildElementParam(this.#_content, XEPG_DOCTYP_ETAG_NAME).trim();
+  }
+
+  set doctype(value){
+    const _value = typeof value === 'string' ? value.trim() : '';
+    const item = insertXObjElement(this.#_content, XEPG_DOCTYP_ETAG_NAME, true);
+    if (item) writeXObjParam(item, _value);
+  }
+
+  setName(value){
+    let isSUCCEED = false;
+    let item = insertXObjElement(this.#_content, 'name', true);
+    if (item) {
+      const name = typeof value === 'string' ? value.trim() : '';
+      isSUCCEED = writeXObjParam(item, name);
+    };
+    return isSUCCEED;
+  }
+
+  getInfo(){
+    return {
+      name: this.name,
+      version: this.version,
+      schema: this.schema,
+      doctype: this.doctype,
+    };
+  }
+
+  setInfo(obj){
+    if (!isObject(obj)) return;
+    let name = '';
+    let version = '';
+    let schema = '';
+    let doctype = '';
+    if (isArray(obj)) {
+      [ name, version, schema, doctype ] = obj;
+    } else {
+      if (typeof obj.name === 'string') {
+        ({ name, version, schema, doctype } = obj);
+      } else {
+        name = _getXmlChildElementParam(obj, 'name');
+        version = _getXmlChildElementParam(obj, 'version');
+        schema = _getXmlChildElementParam(obj, XEPG_DOCSCH_ETAG_NAME);
+        doctype = _getXmlChildElementParam(obj, XEPG_DOCTYP_ETAG_NAME);
+      };
+    };
+    name = typeof name === 'string' ? name.trim() : '';
+    version = typeof version === 'string' ? version.trim() : '';
+    schema = typeof schema === 'string' ? schema.trim() : '';
+    doctype = typeof doctype === 'string' ? doctype.trim() : '';
+    if (name === '') version = '';
+    this.setName(name);
+    this.version = version;
+    this.schema = schema;
+    this.doctype = doctype;
+  }
+
+  init(opt){
+    let prov_opt = { ...defXEpgDocOptions.defProviderParam };
+    let name = '';
+    let version = '';
+    let schema = '';
+    let doctype = '';
+    const _options = isObject(opt) ? opt : {};
+    if (isArray(_options)) {
+      [ name, version, schema, doctype ] = _options;
+    } else {
+      ({ name, version, schema, doctype } = _options);
+    };
+    name = readAsString(name, prov_opt.name, true);
+    version = readAsString(version, prov_opt.version, true);
+    doctype = readAsString(doctype, prov_opt.doctype, true);
+    schema = readAsString(schema, prov_opt.schema, true);
+    this.name = name;
+    this.version = version;
+    this.schema = schema;
+    this.doctype = doctype;
+  }
+
+};
+
+class TXepgDTSProvider {
+  #_content = null;
+  #_options = null;
+
+  constructor(obj, opt) {
+    // load content
+    const _content = isPlainObject(obj) ? obj : {};
+    // load options
+    let _options = isPlainObject(opt) ? opt : {};
+    let {
+      parseOptions,
+    } = _options;
+    if (!(parseOptions instanceof TXmlContentParseOptions)) {
+      parseOptions = new TXmlContentParseOptions(parseOptions);
+      _options.parseOptions = parseOptions;
+    };
+    // save content source
+    this.#_content = _content;
+    // save options
+    this.#_options = _options;
+    // init instance
+    this.#_init();
+  }
+
+  #_init(){
+    insertXObjElement(this.#_content, XEPG_DTSINFO_ETAG_NAME);
+  }
+
+  get dtstype(){
+    const item = getXObjElement(this.#_content, XEPG_DTSINFO_ETAG_NAME);
+    let result = -1;
+    if (isPlainObject(item)) {
+      result = valueToIndex(_getXmlChildElementParam(item, 'value'));
+      if (!chkDTSysID(result)) result = -1;
+    };
+    return result;
+  }
+
+  set dtstype(value){
+    if (chkDTSysID(value)) {
+      const item = getXObjElement(this.#_content, XEPG_DTSINFO_ETAG_NAME);
+      if (item) {
+        let name = getDTSysName(value);
+        let curItem = insertXObjElement(item, 'value', true);
+        if (curItem) writeXObjParam(curItem, valueToIndex(value));
+        curItem = insertXObjElement(item, 'name', true);
+        if (curItem) writeXObjParam(curItem, name);
+      };
+    };
+  }
+
+  get curDocTZ(){
+    return convTZStringToValue(
+      _getXmlChildElementParam(this.#_content, XEPG_DOCTZ_ETAG_NAME)
+    );
+  }
+
+  set curDocTZ(value){
+    let item = insertXObjElement(this.#_content, XEPG_DOCTZ_ETAG_NAME, true);
+    if (item) writeXObjParam(item, convValueToTZString(value));
+  }
+
+};
+
+class TXEpgHeaderContainer {
+  #_content = null;
+  #_options = null;
+  #_dtsProv = null;
+
+  constructor(obj, opt) {
+    // load content
+    const _content = isPlainObject(obj) ? obj : {};
+    // load options
+    let _options = isPlainObject(opt) ? opt : {};
+    let {
+      parseOptions,
+    } = _options;
+    if (!(parseOptions instanceof TXmlContentParseOptions)) {
+      parseOptions = new TXmlContentParseOptions(parseOptions);
+      _options.parseOptions = parseOptions;
+    };
+    // save content source
+    this.#_content = _content;
+    // save options
+    this.#_options = _options;
+    // init DTS-provider
+    this.#_dtsProv = new TXepgDTSProvider(this.#_content, _options);
+  }
+
+  get dts(){
+    return this.#_dtsProv;
+  }
+
+  get dtstype(){
+    return this.#_dtsProv.dtstype;
+  }
+
+  set dtstype(value){
+    this.#_dtsProv.dtstype = value;
+  }
+
+  get curDocTZ(){
+    return this.#_dtsProv.curDocTZ;
+  }
+
+  set curDocTZ(value){
+    this.#_dtsProv.curDocTZ = value;
+  }
+
+  #_getProv(){
+    const docProv = getXObjElement(this.#_content, XEPG_PRVINFO_ETAG_NAME);
+    return isPlainObject(docProv) ? docProv : null;
+  }
+
+  #_initProv(){
+    const _content = this.#_content;
+    let docProv = getXObjElement(_content, XEPG_PRVINFO_ETAG_NAME);
+    if (!docProv) {
+      docProv = insertXObjElement(_content, XEPG_PRVINFO_ETAG_NAME);
+    };
+    return isPlainObject(docProv) ? docProv : null;
+  }
+
+  get Provider(){
+    const docProv = this.#_getProv();
+    return (
+      docProv
+      ? new TXEpgProviderContainer(docProv, this.#_options)
+      : null
+    );
+  }
+
+  getDocumentDT(){
+    let dt_str = _getXmlChildElementParam(this.#_content, XEPG_DOCDTO_ETAG_NAME).trim();
+    return (
+      dt_str !== ''
+      ? convStringToDTValue(dt_str, this.dtstype, this.curDocTZ)
+      : 0
+    );
+  }
+
+  setDocumentDT(){
+    let dt_val = Date.now();
+    let dt_str = convDTValueToString(dt_val, this.dtstype, this.curDocTZ);
+    let item = insertXObjElement(this.#_content, XEPG_DOCDTO_ETAG_NAME, true);
+    if (item) writeXObjParam(item, dt_str);
+  }
+
+  getDocumentEDT(){
+    let dt_str = _getXmlChildElementParam(this.#_content, XEPG_DOCDTE_ETAG_NAME).trim();
+    return (
+      dt_str !== ''
+      ? convStringToDTValue(dt_str, this.dtstype, this.curDocTZ)
+      : 0
+    );
+  }
+
+  setDocumentEDT(value){
+    // TODO: check if value is a DateTime-string
+    let dt_str = convDTValueToString(value, this.dtstype, this.curDocTZ);
+    let item = insertXObjElement(this.#_content, XEPG_DOCDTE_ETAG_NAME, true);
+    if (item) writeXObjParam(item, dt_str);
+  }
+
+  getChannelInfo(){
+    const _content = this.#_content;
+    let item = {
+      chnid: _getXmlChildElementParam(_content, XEPG_CHNID_ETAG_NAME).trim(),
+      chname: _getXmlChildElementParam(_content, XEPG_CHNNAME_ETAG_NAME).trim(),
+      chngid: _getXmlChildElementParam(_content, XEPG_CHNGID_ETAG_NAME).trim(),
+      srcurl: _getXmlChildElementParam(_content, XEPG_CHNURL_ETAG_NAME).trim(),
+    };
+    return item;
+  }
+
+  setChannelInfo(obj){
+    let chnid = '';
+    let chname = '';
+    let chngid = '';
+    let srcurl = '';
+    if (isArray(obj)) {
+      [ chnid, chname, chngid, srcurl ] = obj;
+    } else if (isObject(obj)) {
+      ({ chnid } = obj);
+      if (typeof chnid === 'string') {
+        ({ chname, chngid, srcurl } = obj);
+      } else {
+        chnid = _getXmlChildElementParam(obj, XEPG_CHNID_ETAG_NAME).trim();
+        chname = _getXmlChildElementParam(obj, XEPG_CHNNAME_ETAG_NAME).trim();
+        chngid = _getXmlChildElementParam(obj, XEPG_CHNGID_ETAG_NAME).trim();
+        srcurl = _getXmlChildElementParam(obj, XEPG_CHNURL_ETAG_NAME).trim();
+      };
+    } else if (typeof obj === 'string') {
+      chnid = obj;
+    } else {
+      return;
+    };
+    chnid = typeof chnid === 'string' ? chnid.trim() : '';
+    if (chnid === '') {
+      chname = '';
+      chngid = '';
+      srcurl = '';
+    } else {
+      chname = typeof chname === 'string' ? chname.trim() : '';
+      chngid = typeof chngid === 'string' ? chngid.trim() : '';
+      srcurl = typeof srcurl === 'string' ? srcurl.trim() : '';
+    };
+    let item = null;
+    const _content = this.#_content;
+    item = insertXObjElement(_content, XEPG_CHNID_ETAG_NAME, true);
+    if (item) writeXObjParam(item, chnid);
+    item = insertXObjElement(_content, XEPG_CHNNAME_ETAG_NAME, true);
+    if (item) writeXObjParam(item, chname);
+    item = insertXObjElement(_content, XEPG_CHNGID_ETAG_NAME, true);
+    if (item) writeXObjParam(item, chngid);
+    item = insertXObjElement(_content, XEPG_CHNURL_ETAG_NAME, true);
+    if (item) writeXObjParam(item, srcurl);
+  }
+
+  getProviderInfo(){
+    const docProv = this.Provider;
+    return docProv ? docProv.getInfo() : null;
+  }
+
+  setProviderInfo(obj){
+    if (isArray(obj) || isObject(obj)) {
+      let docProv = this.Provider;
+      if (!docProv) {
+        docProv = this.#_initProv();
+        if (docProv) docProv = this.Provider;
+      };
+      if (docProv) docProv.setInfo(obj);
+    };
+  }
+
+};
+
+class TXEpgContentProvider {
+  #_content = null;
+  #_options = null;
+
+  constructor(opt){
+    // load options
+    const _options = isPlainObject(opt) ? opt : {};
+    let {
+      parseOptions,
+      autoBindRoot,
+    } = _options;
+    if (!(parseOptions instanceof TXmlContentParseOptions)) {
+      parseOptions = new TXmlContentParseOptions(parseOptions);
+      _options.parseOptions = parseOptions;
+    };
+    if (typeof autoBindRoot !== 'boolean') autoBindRoot = false;
+    // save options
+    //_options.autoBindRoot = autoBindRoot; //* // TODO:
+    this.#_options = _options;
+    // init document content
+    this.#_content = {};
+    this.init();
+  }
+
+  #_getRoot(){
+    const docRoot = getXObjElement(this.#_content, XEPG_ROOT_ETAG_NAME);
+    return isPlainObject(docRoot) ? docRoot : null;
+  }
+
+  #_initRoot(){
+    const _content = this.#_content;
+    let docRoot = getXObjElement(_content, XEPG_ROOT_ETAG_NAME);
+    if (!docRoot) {
+      docRoot = insertXObjElement(_content, XEPG_ROOT_ETAG_NAME);
+      if (docRoot) {
+        writeXObjAttr(docRoot, `xmlns:${XEPG_DEF_NS_NAME}`, XEPG_DEF_NS_PATH);
+      };
+    };
+    return isPlainObject(docRoot) ? docRoot : null;
+  }
+
+  #_getHdr(){
+    const docRoot = this.#_getRoot();
+    let docHdr = null;
+    if (docRoot) {
+      docHdr = getXObjElement(docRoot, XEPG_HEADER_ETAG_NAME);
+    };
+    return isPlainObject(docHdr) ? docHdr : null;
+  }
+
+  #_initHdr(){
+    let docHdr = this.#_getHdr();
+    if (!docHdr) {
+      let docRoot = this.#_getRoot();
+      if (!docRoot) docRoot = this.#_initRoot();
+      if (docRoot) {
+        docHdr = insertXObjElement(docRoot, XEPG_HEADER_ETAG_NAME);
+      };
+    };
+    return isPlainObject(docHdr) ? docHdr : null;
+  }
+
+  #_getBody(){
+    const docRoot = this.#_getRoot();
+    let docBody = null;
+    if (docRoot) {
+      docBody = getXObjElement(docRoot, XEPG_BODY_ETAG_NAME);
+    };
+    return isPlainObject(docBody) ? docBody : null;
+  }
+
+  #_initBody(){
+    let docBody = this.#_getBody();
+    if (!docBody) {
+      let docRoot = this.#_getRoot();
+      if (!docRoot) docRoot = this.#_initRoot();
+      if (docRoot) {
+        docBody = insertXObjElement(docRoot, XEPG_BODY_ETAG_NAME);
+      };
+    };
+    return isPlainObject(docBody) ? docBody : null;
+  }
+
+  get Header(){
+    const docHdr = this.#_getHdr();
+    return (
+      docHdr
+      ? new TXEpgHeaderContainer(docHdr, this.#_options)
+      : null
+    );
+  }
+
+  get Provider(){
+    const docHdr = this.Header;
+    return docHdr ? docHdr.Provider : null;
+  }
+
+  get dts(){
+    const docHdr = this.Header;
+    return docHdr ? docHdr.dts : null;
+  }
+
+  /* [!] a temporary special method */
+  /* will deprecate */
+  get Content(){ return this; }
+
+  get SchedulesList(){
+    const _options = this.#_options;
+    const docBody = this.#_getBody();
+    if (docBody && isArray(docBody[XEPG_SCHED_ETAG_NAME])) {
+      const docHdr = this.#_getHdr();
+      return new TXEpgSchedulesList(
+        docBody[XEPG_SCHED_ETAG_NAME],
+        {
+          dts_src: getXObjElement(docHdr, XEPG_DTSINFO_ETAG_NAME),
+          tz_src: getXObjElement(docHdr, XEPG_DOCTZ_ETAG_NAME),
+        },
+      );
+    };
+  }
+
+  init(){
+    const _options = this.#_options;
+    const _content = this.#_content;
+    const {
+      parseOptions,
+    } = _options;
+    const { settings } = parseOptions;
+    const { ignoreDeclaration } = settings;
+    if (!ignoreDeclaration) {
+      // write document declaration section
+      writeXEpgDocDeclSection(_content);
+    };
+    // initiate document root element
+    let docRoot = this.#_getRoot();
+    if (!docRoot) docRoot = this.#_initRoot();
+    if (docRoot) {
+      // initiate document header element
+      let docHdr = this.#_getHdr();
+      if (!docHdr) docHdr = this.#_initHdr();
+      // initiate document provider element
+      let docProv = insertXObjElement(
+        docHdr,
+        XEPG_PRVINFO_ETAG_NAME,
+      );
+      if (docProv) this.Provider.init();
+      // initiate document body element
+      let docBody = this.#_getBody();
+      if (!docBody) docBody = this.#_initBody();
+      if (
+        docBody && !isArray(docBody[XEPG_SCHED_ETAG_NAME])
+      ) {
+        docBody[XEPG_SCHED_ETAG_NAME] = [];
+      };
+    };
+  }
+
+  saveToXMLString(){
+    return xmlParser.js2xml(
+      this.#_content,
+      this.#_options.parseOptions.js2xml,
+    );
+  }
+
+  saveToFile(src_link){
+    let saveFile = function(obj){
+      return new Promise(function(resolve, reject) {
+        let { src_link } = obj;
+        if (
+          typeof src_link !== 'string'
+          || ((src_link = src_link.trim()) === '')
+        ) {
+          resolve(false);
+        };
+        fs.writeFile(src_link, obj.content, (err) => {
+          if (err) reject(err);
+          resolve(true);
+        });
+      });
+    };
+    let loadContent = (opt) => { return this.asXML(opt); };
+    return new Promise(function(resolve, reject){
+      let tmpObj = { src_link: src_link };
+      tmpObj.content = loadContent();
+      saveFile(tmpObj).then(result => {
+        resolve(result);
+      }).catch(err => { reject(err); });
+    });
+  }
+
+  saveToFileSync(source){
+    //console.log('CHECK: TXEpgContentProvider.saveToFileSync() => was called...');
+    let data = {
+      isSucceed: false,
+      source: typeof source === 'string' ? source.trim() : '',
+      content: '',
+      isERR: false,
+      errEvent: '',
+    };
+    if (data.source !== '') {
+      try {
+        data.content = this.asXML();
+        fs.writeFileSync(data.source, data.content, 'utf8');
+      } catch (err) {
+        console.log('CHECK: TXEpgContentProvider.saveToFileSync() => Error => '+err);
+        console.log('CHECK: TXEpgContentProvider.saveToFileSync() => Error => '+err.code);
+        throw err;
+      };
+    } else {
+      data.isERR = true;
+      data.errEvent = 'EMPTY_SRCLINK';
+    };
+    //console.log('CHECK: TXEpgContentProvider.saveToFileSync() => was left...');
+    return data;
+  }
+
+  loadFromString(xmlString, opt){
+    let isSUCCEED = false;
+    if (typeof xmlString === 'string') {
+      let _options = this.#_options;
+      let parseOptions = null;
+      if (isPlainObject(opt)) {
+        parseOptions = new TXmlContentParseOptions(opt);
+        // // TODO: init user options
+      } else {
+        parseOptions = _options.parseOptions;
+      };
+      try {
+        this.#_content = xmlParser.xml2js(xmlString, parseOptions.xml2js);
+        // init a document header element
+        let docHdr = this.#_getHdr();
+        if (!docHdr) docHdr = this.#_initHdr();
+        // init a document body element
+        let docBody = this.#_getBody();
+        if (!docBody) docBody = this.#_initBody();
+        if (docBody) {
+          if (typeof docBody[XEPG_SCHED_ETAG_NAME] !== 'object') {
+            docBody[XEPG_SCHED_ETAG_NAME] = [];
+          } else if (!isArray(docBody[XEPG_SCHED_ETAG_NAME])) {
+            let tmpObj = [];
+            tmpObj.push(docBody[XEPG_SCHED_ETAG_NAME]);
+            docBody[XEPG_SCHED_ETAG_NAME] = tmpObj;
+          };
+          isSUCCEED = true;
+        };
+      } catch (err) {
+        console.log('CHECK: TXEpgContentProvider.loadFromString() => err => '+err);
+        throw err;
+      };
+    };
+    return isSUCCEED;
+  }
+
+  loadFromFile(source){
+    /**/// extend part that return promise as a result
+    const loadFile = function(source){
+      return new Promise((resolve, reject) => {
+        let data = {
+          isLoaded: false,
+          source: typeof source === 'string' ? source.trim() : '',
+          content: '',
+          isERR: false,
+          errEvent: '',
+        };
+        if (data.source === '') {
+          data.isERR = true;
+          data.errEvent = (
+            typeof source === 'string' ? 'EMPTY_SRCLINK' : 'NO_SRCLINK'
+          );
+          resolve(data);
+        } else {
+          fse.readFile(data.source, 'utf8').then(result => {
+            data.content = result;
+            if (result != '') {
+              data.isLoaded = true;
+              data.errEvent = 'OPS_IS_SUCCEED';
+            } else {
+              data.isERR = true;
+              data.errEvent = 'NO_CONTENT';
+            };
+            resolve(data);
+          }).catch(err => {
+            switch (err.code) {
+              case 'ENOENT':
+              case 'EISDIR':
+                data.isERR = true;
+                data.errEvent = err.code;
+                resolve(data);
+                break;
+              default:
+                console.log('CHECK: TXEpgContentProvider.loadFromFile() => [1] loadFile() => Error => '+err.code);
+                reject(err);
+                break;
+            };
+          });
+        };
+      });
+    };
+    /**/// main part that return promise as a result
+    return new Promise((resolve, reject) => {
+      loadFile(source).then(data => {
+        if (data.isLoaded) {
+          if (this.loadFromString(data.content)) {
+            data.isLoaded = true;
+            data.errEvent = 'OPS_IS_SUCCEED';
+          } else {
+            data.isERR = true;
+            data.errEvent = 'OPS_IS_FAILED';
+          };
+        } else {
+          //console.log('CHECK: TXEpgContentProvider.loadFromFile() => result.isERR:['+data.isERR+']');
+          //console.log('CHECK: TXEpgContentProvider.loadFromFile() => result.errEvent:['+data.errEvent+']');
+        };
+        resolve(data);
+      }).catch(err => {
+        console.log('CHECK: TXEpgContentProvider.loadFromFile() => loadFile().err() => '+err);
+        reject(err);
+      });
+    });
+  }
+
+  loadFromFileSync(source){
+    const loadFile = function(source){
+      let data = {
+        isLoaded: false,
+        source: typeof source === 'string' ? source.trim() : '',
+        content: '',
+        isERR: false,
+        errEvent: '',
+      };
+      if (data.source === '') {
+        data.isERR = true;
+        data.errEvent = (
+          typeof source === 'string' ? 'EMPTY_SRCLINK' : 'NO_SRCLINK'
+        );
+      } else {
+        try {
+          data.content = fs.readFileSync(data.source, 'utf8');
+          if (data.content !== '') {
+            data.isLoaded = true;
+            data.errEvent = 'OPS_IS_SUCCEED';
+          } else {
+            data.isERR = true;
+            data.errEvent = 'NO_CONTENT';
+          };
+        } catch (err) {
+          switch (err.code) {
+            case 'ENOENT':
+            case 'EISDIR':
+              data.isERR = true;
+              data.errEvent = err.code;
+              break;
+            default:
+              console.log('CHECK: TXEpgContentProvider.loadFromFileSync() => [1] loadFile() => Error => '+err.code);
+              throw err;
+              break;
+          };
+        };
+      };
+      return data;
+    };
+    let result = {
+      isLoaded: false,
+      isERR: false,
+      errEvent: '',
+    };
+    try {
+      result = loadFile(source);
+      if (result.isLoaded) {
+        if (this.loadFromString(result.content)) {
+          result.isLoaded = true;
+          result.errEvent = 'OPS_IS_SUCCEED';
+        } else {
+          result.isERR = true;
+          result.errEvent = 'OPS_IS_FAILED';
+        };
+      } else {
+        //console.log('CHECK: TXEpgContentProvider.loadFromFileSync() => result.isERR:['+result.isERR+']');
+        //console.log('CHECK: TXEpgContentProvider.loadFromFileSync() => result.errEvent:['+result.errEvent+']');
+      };
+    } catch (err) {
+      console.log('CHECK: TXEpgContentProvider.loadFromFileSync() => loadFile().err() => '+err);
+      throw err;
+    };
+    return result;
+  }
+
+  // will  deprecate
+  asXML(opt){
+    let parseOptions = isPlainObject(opt) ? opt : defParseOptions.js2xml;
+    return xmlParser.js2xml(this.#_content, parseOptions);
+  }
+
+  asJSON(){
+    return JSON.stringify(this.#_content, null, 2);
+  }
+
+}
+
+// === module exports block ===
+
+exports.TXepgDTSProvider = TXepgDTSProvider;
+exports.TXEpgSchedulesList = TXEpgSchedulesList;
+exports.TXEpgProviderContainer = TXEpgProviderContainer;
+exports.TXEpgHeaderContainer = TXEpgHeaderContainer;
+exports.TXEpgContentProvider = TXEpgContentProvider;
+
+exports.XEPG_DEF_PROVIDER_NAME = XEPG_DEF_PROVIDER_NAME;
+exports.XEPG_DEF_PROVIDER_VER = XEPG_DEF_PROVIDER_VER;
+exports.XEPG_DEF_DOCUMENT_TYPE = XEPG_DEF_DOCUMENT_TYPE;
+exports.XEPG_DEF_DOCUMENT_SCHEMA = XEPG_DEF_DOCUMENT_SCHEMA;