@ygracs/xobj-lib-js 0.0.13 → 0.0.14-rc2

package/lib/xObj-lib.js

@@ -1,10 +1,11 @@
-// [v0.1.022-20220822]
+// [v0.1.051-20230227]
 
 // === module init block ===
 
 const {
-  valueToIndex, readAsBool, readAsString,
-  readAsBoolEx, readAsNumberEx, isNotEmptyString, isNullOrUndef,
+  valueToIndex,
+  readAsString, readAsBoolEx, readAsNumberEx,
+  isNullOrUndef,
   isArray, isObject, isPlainObject, readAsListS,
 } = require('@ygracs/bsfoc-lib-js');
 
@@ -12,12 +13,18 @@ const XOBJ_DEF_PARAM_TNAME = '__text';
 const XOBJ_DEF_ATTR_TNAME = '__attr';
 
 const XOBJ_TE_INVARG_EMSG = 'invalid argument';
-const XOBJ_TE_NOBJ_EMSG = XOBJ_TE_INVARG_EMSG + '(an object is expected)';
-const XOBJ_TE_NARR_EMSG = XOBJ_TE_INVARG_EMSG + '(an array is expected)';
-const XOBJ_TE_NSTR_EMSG = XOBJ_TE_INVARG_EMSG + '(a string is expected)';
-const XOBJ_TE_NPOBJ_EMSG = XOBJ_TE_INVARG_EMSG + '(a plain object is expected)';
+const XOBJ_TE_NOBJ_EMSG = `${XOBJ_TE_INVARG_EMSG} (an object expected)`;
+const XOBJ_TE_NOBJ_ECODE = 'ERR_XOBJ_NOBJ';
+const XOBJ_TE_NARR_EMSG = `${XOBJ_TE_INVARG_EMSG} (an array expected)`;
+const XOBJ_TE_NARR_ECODE = 'ERR_XOBJ_NARR';
+const XOBJ_TE_NSTR_EMSG = `${XOBJ_TE_INVARG_EMSG} (a string expected)`;
+const XOBJ_TE_NSTR_ECODE = 'ERR_XOBJ_NSTR';
+const XOBJ_TE_NPOBJ_EMSG = `${XOBJ_TE_INVARG_EMSG} (a plain object expected)`;
+const XOBJ_TE_NPOBJ_ECODE = 'ERR_XOBJ_NPOBJ';
 const XOBJ_TE_ANES_EMSG = '<attr_name> must be a non-empty string';
+const XOBJ_TE_ANES_ECODE = 'ERR_XOBJ_INVARG_ATTR';
 const XOBJ_TE_KNES_EMSG = '<key_name> must be a non-empty string';
+const XOBJ_TE_KNES_ECODE = 'ERR_XOBJ_INVARG_KEY';
 
 const DEF_XML_PARSE_OPTIONS = {
   compact: true,
@@ -46,74 +53,174 @@ const DEF_XML_PARSE_OPTIONS = {
 
 // === module main block (function definitions) ===
 
-function getXObjElement(obj, name){
-  if (!isPlainObject(obj)) throw new TypeError(XOBJ_TE_NPOBJ_EMSG);
-  const key = typeof name === 'string' ? name.trim() : '';
-  if (key === '') throw new TypeError(XOBJ_TE_KNES_EMSG);
-  // TODO: check type of obj[key_name]
-  return obj[key] !== undefined ? obj[key] : null;
+function evalXObjEName(value){
+  let name = value;
+  if (!isNullOrUndef(name)) {
+    switch (typeof name) {
+      case 'number' : {
+        if (Number.isNaN(name) || name < 0) name = null;
+        break;
+      }
+      case 'string' : {
+        name = name.trim();
+        if (name !== '') {
+          let value = Number(name);
+          if (!Number.isNaN(value)) {
+            name = value < 0 ? null : value;
+          };
+        };
+        break;
+      }
+      default: {
+        name = null;
+        break;
+      }
+    };
+  };
+  return name;
 };
 
-function getXObjAttributes(obj, key_name = XOBJ_DEF_ATTR_TNAME){
-  return getXObjElement(obj, readAsString(key_name, XOBJ_DEF_ATTR_TNAME, true));
+function getXObjElement(obj, name){
+  let err = null;
+  if (!isPlainObject(obj)) {
+    err = new TypeError(XOBJ_TE_NPOBJ_EMSG);
+    err.code = XOBJ_TE_NPOBJ_ECODE;
+    throw err;
+  };
+  if (typeof name !== 'string') {
+    err = new TypeError(XOBJ_TE_NSTR_EMSG);
+    err.code = XOBJ_TE_NSTR_ECODE;
+    throw err;
+  };
+  const key = name.trim();
+  if (key === '') {
+    err = new TypeError(XOBJ_TE_KNES_EMSG);
+    err.code = XOBJ_TE_KNES_ECODE;
+    throw err;
+  };
+  // TODO: [?] check type of obj[key_name]
+  return obj[key] !== undefined ? obj[key] : null;
 };
 
-function insertXObjElement(obj, name, opt){
-  if (!isPlainObject(obj)) throw new TypeError(XOBJ_TE_NPOBJ_EMSG);
-  const key = typeof name === 'string' ? name.trim() : '';
-  if (key === '') throw new TypeError(XOBJ_TE_KNES_EMSG);
-  let force_act = false;
-  let rip_oldies = false;
-  if (typeof opt === 'boolean') {
-    force_act = opt;
-  } else if (isPlainObject(opt)) {
-    force_act = readAsBool(opt.force, false);
-    if (force_act) rip_oldies = readAsBool(opt.rip_oldies, false);
-  };
-  let isACCEPTED = false;
-  if (isNullOrUndef(obj[key])) {
-    obj[key] = {};
-    isACCEPTED = true;
-  } else if (force_act) {
-    if (rip_oldies || !isPlainObject(obj[key])) obj[key] = {};
-    isACCEPTED = true;
-  } else {
-    isACCEPTED = isPlainObject(obj[key]);
+function getXObjAttributes(obj, key = XOBJ_DEF_ATTR_TNAME){
+  let result = null;
+  try {
+    result = getXObjElement(obj, key);
+  } catch (err) {
+    switch (err.code) {
+      case XOBJ_TE_NSTR_ECODE :
+      case XOBJ_TE_KNES_ECODE : {
+        break;
+      }
+      default: {
+        throw err;
+        break;
+      }
+    };
   };
-  return isACCEPTED ? obj[key] : null;
+  return isPlainObject(result) ? result : null;
 };
 
 function addXObjElement(obj, name){
-  if (!isPlainObject(obj)) throw new TypeError(XOBJ_TE_NPOBJ_EMSG);
-  const key = typeof name === 'string' ? name.trim() : '';
-  if (key === '') throw new TypeError(XOBJ_TE_KNES_EMSG);
+  let err = null;
+  if (!isPlainObject(obj)) {
+    err = new TypeError(XOBJ_TE_NPOBJ_EMSG);
+    err.code = XOBJ_TE_NPOBJ_ECODE;
+    throw err;
+  };
+  if (typeof name !== 'string') {
+    err = new TypeError(XOBJ_TE_NSTR_EMSG);
+    err.code = XOBJ_TE_NSTR_ECODE;
+    throw err;
+  };
+  const key = name.trim();
+  if (key === '') {
+    err = new TypeError(XOBJ_TE_KNES_EMSG);
+    err.code = XOBJ_TE_KNES_ECODE;
+    throw err;
+  };
+  const item = {};
   let prop = obj[key];
-  let item = {};
-  let result = false;
-  // // TODO:  consider wheter or not do ops if new_key exists
+  let isSUCCEED = false;
+  // // TODO: [?] consider wheter or not do ops if new_key exists
   if (isNullOrUndef(prop)) {
-    obj[key] = {};
-    prop = obj[key];
-    result = true;
-  } else if (isPlainObject(prop)) {
-    obj[key] = [ prop, item ];
-    prop = item;
-    result = true;
-  } else if (isArray(prop)) {
-    prop.push(item);
-    prop = item;
-    result = true;
+    obj[key] = prop = item;
+    isSUCCEED = true;
+  } else if (isObject(prop)) {
+    isSUCCEED = true;
+    if (isArray(prop)) {
+      prop.push(item);
+      prop = item;
+    } else {
+      obj[key] = [ prop, item ];
+      prop = item;
+    };
   };
   return {
-    isSucceed: result,
-    item: result ? prop : null,
+    isSucceed: isSUCCEED,
+    item: isSUCCEED ? prop : null,
+  };
+};
+
+function insertXObjElement(obj, name, opt){
+  let err = null;
+  if (!isPlainObject(obj)) {
+    err = new TypeError(XOBJ_TE_NPOBJ_EMSG);
+    err.code = XOBJ_TE_NPOBJ_ECODE;
+    throw err;
+  };
+  if (typeof name !== 'string') {
+    err = new TypeError(XOBJ_TE_NSTR_EMSG);
+    err.code = XOBJ_TE_NSTR_ECODE;
+    throw err;
+  };
+  const key = name.trim();
+  if (key === '') {
+    err = new TypeError(XOBJ_TE_KNES_EMSG);
+    err.code = XOBJ_TE_KNES_ECODE;
+    throw err;
   };
+  let _options = opt;
+  if (typeof opt === 'boolean') {
+    _options = { force: _options };
+  } else if (!isPlainObject(_options)) {
+    _options = {};
+  };
+  let { force, rip_oldies, ripOldies } = _options;
+  if (typeof force !== 'boolean') force = false;
+  if (ripOldies === undefined) ripOldies = rip_oldies;
+  if (typeof ripOldies !== 'boolean') ripOldies = false;
+  let prop = obj[key];
+  let isACCEPTED = (
+    isNullOrUndef(prop)
+    || (force && (ripOldies || !isPlainObject(prop)))
+  );
+  if (isACCEPTED) {
+    obj[key] = prop = {};
+  } else {
+    isACCEPTED = isPlainObject(prop);
+  };
+  return isACCEPTED ? prop : null;
 };
 
 function deleteXObjElement(obj, name){
-  if (!isPlainObject(obj)) throw new TypeError(XOBJ_TE_NPOBJ_EMSG);
-  const key = typeof name === 'string' ? name.trim() : '';
-  if (key === '') throw new TypeError(XOBJ_TE_KNES_EMSG);
+  let err = null;
+  if (!isPlainObject(obj)) {
+    err = new TypeError(XOBJ_TE_NPOBJ_EMSG);
+    err.code = XOBJ_TE_NPOBJ_ECODE;
+    throw err;
+  };
+  if (typeof name !== 'string') {
+    err = new TypeError(XOBJ_TE_NSTR_EMSG);
+    err.code = XOBJ_TE_NSTR_ECODE;
+    throw err;
+  };
+  const key = name.trim();
+  if (key === '') {
+    err = new TypeError(XOBJ_TE_KNES_EMSG);
+    err.code = XOBJ_TE_KNES_ECODE;
+    throw err;
+  };
   let result = false;
   // // TODO: catch errors in strict mode
   result = delete obj[key];
@@ -121,9 +228,23 @@ function deleteXObjElement(obj, name){
 };
 
 function deleteXObjElementEx(obj, name){
-  if (!isPlainObject(obj)) throw new TypeError(XOBJ_TE_NPOBJ_EMSG);
-  const key = typeof name === 'string' ? name.trim() : '';
-  if (key === '') throw new TypeError(XOBJ_TE_KNES_EMSG);
+  let err = null;
+  if (!isPlainObject(obj)) {
+    err = new TypeError(XOBJ_TE_NPOBJ_EMSG);
+    err.code = XOBJ_TE_NPOBJ_ECODE;
+    throw err;
+  };
+  if (typeof name !== 'string') {
+    err = new TypeError(XOBJ_TE_NSTR_EMSG);
+    err.code = XOBJ_TE_NSTR_ECODE;
+    throw err;
+  };
+  const key = name.trim();
+  if (key === '') {
+    err = new TypeError(XOBJ_TE_KNES_EMSG);
+    err.code = XOBJ_TE_KNES_ECODE;
+    throw err;
+  };
   let prop = obj[key];
   let result = false;
   // // TODO: catch errors in strict mode
@@ -135,16 +256,29 @@ function deleteXObjElementEx(obj, name){
 };
 
 function renameXObjElement(obj, name, newName){
-  if (!isPlainObject(obj)) throw new TypeError(XOBJ_TE_NPOBJ_EMSG);
-  const key = typeof name === 'string' ? name.trim() : '';
-  if (key === '') throw new TypeError(XOBJ_TE_KNES_EMSG);
-  const newKey = typeof newName === 'string' ? newName.trim() : '';
-  if (newKey === '') throw new TypeError(XOBJ_TE_KNES_EMSG);
-  let prop = obj[key];
+  let err = null;
+  if (!isPlainObject(obj)) {
+    err = new TypeError(XOBJ_TE_NPOBJ_EMSG);
+    err.code = XOBJ_TE_NPOBJ_ECODE;
+    throw err;
+  };
+  if (typeof name !== 'string' || typeof newName !== 'string') {
+    err = new TypeError(XOBJ_TE_NSTR_EMSG);
+    err.code = XOBJ_TE_NSTR_ECODE;
+    throw err;
+  };
+  const key = name.trim();
+  const newKey = newName.trim();
+  if (key === '' || newKey === '') {
+    err = new TypeError(XOBJ_TE_KNES_EMSG);
+    err.code = XOBJ_TE_KNES_ECODE;
+    throw err;
+  };
+  const prop = obj[key];
   let result = false;
-  // // TODO:  consider wheter or not do ops if new_key exists
   if (prop !== undefined) {
-    if (key === newKey) return isObject(prop) ? true : false;
+    if (key === newKey) return isObject(prop);
+    // // TODO:  consider wheter or not do ops if new_key exists
     // // TODO: catch errors in strict mode
     result = delete obj[key];
     if (result) {
@@ -154,252 +288,650 @@ function renameXObjElement(obj, name, newName){
   return result;
 };
 
-function readXObjParamRaw(obj, key_name = XOBJ_DEF_PARAM_TNAME){
-  if (!isPlainObject(obj)) throw new TypeError(XOBJ_TE_NPOBJ_EMSG);
-  key_name = readAsString(key_name, XOBJ_DEF_PARAM_TNAME, true);
-  return isNotEmptyString(key_name) ? obj[key_name] : undefined;
+function checkXObjAttribute(obj, attr = '', key){
+  if (typeof attr !== 'string') {
+    let err = new TypeError(XOBJ_TE_NSTR_EMSG);
+    err.code = XOBJ_TE_NSTR_ECODE;
+    throw err;
+  };
+  let objAttr = null;
+  try {
+    objAttr = getXObjAttributes(obj, key);
+  } catch (err) {
+    throw err;
+  };
+  const attrName = attr.trim();
+  let result = false;
+  if (
+    objAttr !== null
+    && attrName !== ''
+    && objAttr[attrName] !== undefined
+  ) {
+    result = true;
+  };
+  return result;
+};
+
+function deleteXObjAttribute(obj, attr = '', key){
+  if (typeof attr !== 'string') {
+    let err = new TypeError(XOBJ_TE_NSTR_EMSG);
+    err.code = XOBJ_TE_NSTR_ECODE;
+    throw err;
+  };
+  let objAttr = null;
+  try {
+    objAttr = getXObjAttributes(obj, key);
+  } catch (err) {
+    throw err;
+  };
+  const attrName = attr.trim();
+  let result = false;
+  if (objAttr !== null && attrName !== '') {
+    // // TODO: catch errors in strict mode
+    result = delete objAttr[attrName];
+  };
+  return result;
+};
+
+function readXObjParamRaw(obj, key = XOBJ_DEF_PARAM_TNAME){
+  let err = null;
+  if (!isPlainObject(obj)) {
+    err = new TypeError(XOBJ_TE_NPOBJ_EMSG);
+    err.code = XOBJ_TE_NPOBJ_ECODE;
+    throw err;
+  };
+  if (typeof key !== 'string') {
+    err = new TypeError(XOBJ_TE_NSTR_EMSG);
+    err.code = XOBJ_TE_NSTR_ECODE;
+    throw err;
+  };
+  const _key = key.trim();
+  return _key !== '' ? obj[_key] : undefined;
 };
 
-function writeXObjParamRaw(obj, value, key_name = XOBJ_DEF_PARAM_TNAME){
-  if (!isPlainObject(obj)) throw new TypeError(XOBJ_TE_NPOBJ_EMSG);
-  key_name = readAsString(key_name, XOBJ_DEF_PARAM_TNAME, true);
-  let isACCEPTED = isNotEmptyString(key_name);
-  if (isACCEPTED) obj[key_name] = value;
-  return isACCEPTED;
+function writeXObjParamRaw(obj, value, key = XOBJ_DEF_PARAM_TNAME){
+  let err = null;
+  if (!isPlainObject(obj)) {
+    err = new TypeError(XOBJ_TE_NPOBJ_EMSG);
+    err.code = XOBJ_TE_NPOBJ_ECODE;
+    throw err;
+  };
+  if (typeof key !== 'string') {
+    err = new TypeError(XOBJ_TE_NSTR_EMSG);
+    err.code = XOBJ_TE_NSTR_ECODE;
+    throw err;
+  };
+  const _key = key.trim();
+  let isSUCCEED = false;
+  if (_key !== '' && value !== undefined){
+    obj[_key] = value;
+    isSUCCEED = true;
+  };
+  return isSUCCEED;
 };
 
-function readXObjAttrRaw(obj, attr, key_name = XOBJ_DEF_ATTR_TNAME){
-  const attrName = typeof attr === 'string' ? attr.trim() : '';
-  if (attrName === '') throw new TypeError(XOBJ_TE_ANES_EMSG);
-  obj = getXObjElement(obj, readAsString(key_name, XOBJ_DEF_ATTR_TNAME, true));
-  return isPlainObject(obj) ? obj[attrName] : undefined ;
+function readXObjAttrRaw(obj, attr = '', key){
+  if (typeof attr !== 'string') {
+    let err = new TypeError(XOBJ_TE_NSTR_EMSG);
+    err.code = XOBJ_TE_NSTR_ECODE;
+    throw err;
+  };
+  let objAttr = null;
+  try {
+    objAttr = getXObjAttributes(obj, key);
+  } catch (err) {
+    throw err;
+  };
+  const attrName = attr.trim();
+  if (objAttr !== null && attrName !== '') return objAttr[attrName];
 };
 
-function writeXObjAttrRaw(obj, attr, value, key_name = XOBJ_DEF_ATTR_TNAME){
-  if (!isPlainObject(obj)) throw new TypeError(XOBJ_TE_NPOBJ_EMSG);
-  const attrName = typeof attr === 'string' ? attr.trim() : '';
-  if (attrName === '') throw new TypeError(XOBJ_TE_ANES_EMSG);
-  key_name = readAsString(key_name, XOBJ_DEF_ATTR_TNAME, true);
-  let isACCEPTED = isNotEmptyString(key_name);
-  if (isACCEPTED) {
-    if (!isPlainObject(obj[key_name])) obj[key_name] = {};
-    obj[key_name][attrName] = value;
+function writeXObjAttrRaw(obj, attr = '', value, key = XOBJ_DEF_ATTR_TNAME){
+  if (typeof attr !== 'string') {
+    let err = new TypeError(XOBJ_TE_NSTR_EMSG);
+    err.code = XOBJ_TE_NSTR_ECODE;
+    throw err;
+  };
+  const attrName = attr.trim();
+  let objAttr = null;
+  let isSUCCEED = false;
+  if (attrName !== '' && value !== undefined) {
+    try {
+      objAttr = insertXObjElement(obj, key, { force: true });
+    } catch (err) {
+      switch (err.code) {
+        case XOBJ_TE_NSTR_ECODE :
+        case XOBJ_TE_KNES_ECODE : {
+          break;
+        }
+        default: {
+          throw err;
+          break;
+        }
+      };
+    };
+    if (objAttr !== null) {
+      objAttr[attrName] = value;
+      isSUCCEED = true;
+    };
   };
-  return isACCEPTED;
+  return isSUCCEED;
 };
 
-function readXObjParam(obj, defKey){
-  const param = readXObjParamRaw(obj, defKey);
-  return readAsString(param, {
+function readXObjParam(obj, key){
+  let result = undefined;
+  try {
+    result = readXObjParamRaw(obj, key);
+  } catch (err) {
+    switch (err.code) {
+      case XOBJ_TE_NSTR_ECODE : {
+        break;
+      }
+      default: {
+        throw err;
+        break;
+      }
+    };
+  };
+  return readAsString(result, {
     useTrim: false,
     numberToString: true,
     boolToString: true,
   });
 };
 
-function readXObjParamAsBool(obj, defValue = false, defKey){
-  const param = readXObjParamRaw(obj, defKey);
-  return readAsBoolEx(param, defValue);
+function readXObjParamAsBool(obj, defValue, key){
+  let result = undefined;
+  try {
+    result = readXObjParamRaw(obj, key);
+  } catch (err) {
+    switch (err.code) {
+      case XOBJ_TE_NSTR_ECODE : {
+        break;
+      }
+      default: {
+        throw err;
+        break;
+      }
+    };
+  };
+  return readAsBoolEx(result, defValue);
 };
 
-function readXObjParamAsNum(obj, defValue = 0, defKey){
-  const param = readXObjParamRaw(obj, defKey);
-  return readAsNumberEx(param, defValue);
+function readXObjParamAsNum(obj, defValue, key){
+  let result = undefined;
+  try {
+    result = readXObjParamRaw(obj, key);
+  } catch (err) {
+    switch (err.code) {
+      case XOBJ_TE_NSTR_ECODE : {
+        break;
+      }
+      default: {
+        throw err;
+        break;
+      }
+    };
+  };
+  return readAsNumberEx(result, defValue);
 };
 
-function readXObjParamAsStr(obj, defValue = '', defKey){
-  const param = readXObjParamRaw(obj, defKey);
-  return readAsString(param, defValue, {
+function readXObjParamAsStr(obj, defValue, key){
+  let result = undefined;
+  try {
+    result = readXObjParamRaw(obj, key);
+  } catch (err) {
+    switch (err.code) {
+      case XOBJ_TE_NSTR_ECODE : {
+        break;
+      }
+      default: {
+        throw err;
+        break;
+      }
+    };
+  };
+  return readAsString(result, defValue, {
     useTrim: false,
     numberToString: true,
     boolToString: true,
   });
 };
 
-function readXObjParamAsIndex(obj, defKey){
-  return valueToIndex(readXObjParamRaw(obj, defKey));
+function readXObjParamAsIndex(obj, key){
+  let result = undefined;
+  try {
+    result = readXObjParamRaw(obj, key);
+  } catch (err) {
+    switch (err.code) {
+      case XOBJ_TE_NSTR_ECODE : {
+        break;
+      }
+      default: {
+        throw err;
+        break;
+      }
+    };
+  };
+  return valueToIndex(result);
 };
 
-function writeXObjParam(obj, value, defKey){
-  const _value = readAsString(value, {
-    useTrim: false,
-    numberToString: true,
-    boolToString: true,
-  });
-  return writeXObjParamRaw(obj, _value, defKey);
+function writeXObjParam(obj, value, key){
+  let isSUCCEED = false;
+  if (value !== undefined) {
+    const _value = readAsString(value, {
+      useTrim: false,
+      numberToString: true,
+      boolToString: true,
+    });
+    try {
+      isSUCCEED = writeXObjParamRaw(obj, _value, key);
+    } catch (err) {
+      switch (err.code) {
+        case XOBJ_TE_NSTR_ECODE : {
+          break;
+        }
+        default: {
+          throw err;
+          break;
+        }
+      };
+    };
+  };
+  return isSUCCEED;
 };
 
-function writeXObjParamAsBool(obj, value, defValue = false, defKey){
-  const _value = readAsBoolEx(value, defValue).toString();
-  return writeXObjParamRaw(obj, _value, defKey);
+function writeXObjParamAsBool(obj, value, defValue, key){
+  let isSUCCEED = false;
+  if (value !== undefined) {
+    const _value = readAsBoolEx(value, defValue).toString();
+    try {
+      isSUCCEED = writeXObjParamRaw(obj, _value, key);
+    } catch (err) {
+      switch (err.code) {
+        case XOBJ_TE_NSTR_ECODE : {
+          break;
+        }
+        default: {
+          throw err;
+          break;
+        }
+      };
+    };
+  };
+  return isSUCCEED;
 };
 
-function writeXObjParamAsNum(obj, value, defValue = 0, defKey){
-  const _value = readAsNumberEx(value, defValue).toString();
-  return writeXObjParamRaw(obj, _value, defKey);
+function writeXObjParamAsNum(obj, value, defValue, key){
+  let isSUCCEED = false;
+  if (value !== undefined) {
+    const _value = readAsNumberEx(value, defValue).toString();
+    try {
+      isSUCCEED = writeXObjParamRaw(obj, _value, key);
+    } catch (err) {
+      switch (err.code) {
+        case XOBJ_TE_NSTR_ECODE : {
+          break;
+        }
+        default: {
+          throw err;
+          break;
+        }
+      };
+    };
+  };
+  return isSUCCEED;
 };
 
-function writeXObjParamAsIndex(obj, value, defKey){
-  const _value = valueToIndex(value).toString();
-  return writeXObjParamRaw(obj, _value, defKey);
+function writeXObjParamAsIndex(obj, value, key){
+  let isSUCCEED = false;
+  if (value !== undefined) {
+    const _value = valueToIndex(value).toString();
+    try {
+      isSUCCEED = writeXObjParamRaw(obj, _value, key);
+    } catch (err) {
+      switch (err.code) {
+        case XOBJ_TE_NSTR_ECODE : {
+          break;
+        }
+        default: {
+          throw err;
+          break;
+        }
+      };
+    };
+  };
+  return isSUCCEED;
 };
 
-function writeXObjParamEx(obj, value, defValue, defKey){
-  const _defValue = readAsString(defValue, {
-    useTrim: false,
-    numberToString: true,
-    boolToString: true,
-  });
-  const _value = readAsString(value, _defValue, {
-    useTrim: false,
-    numberToString: true,
-    boolToString: true,
-  });
-  return writeXObjParamRaw(obj, _value, defKey);
+function writeXObjParamEx(obj, value, defValue, key){
+  let isSUCCEED = false;
+  if (value !== undefined) {
+    const _defValue = readAsString(defValue, {
+      useTrim: false,
+      numberToString: true,
+      boolToString: true,
+    });
+    const _value = readAsString(value, _defValue, {
+      useTrim: false,
+      numberToString: true,
+      boolToString: true,
+    });
+    try {
+      isSUCCEED = writeXObjParamRaw(obj, _value, key);
+    } catch (err) {
+      switch (err.code) {
+        case XOBJ_TE_NSTR_ECODE : {
+          break;
+        }
+        default: {
+          throw err;
+          break;
+        }
+      };
+    };
+  };
+  return isSUCCEED;
 };
 
-function readXObjAttr(obj, name, defKey){
-  const param = readXObjAttrRaw(obj, name, defKey);
-  return readAsString(param, {
+function readXObjAttr(obj, attr, key){
+  let result = undefined;
+  try {
+    result = readXObjAttrRaw(obj, attr, key);
+  } catch (err) {
+    switch (err.code) {
+      case XOBJ_TE_NSTR_ECODE : {
+        break;
+      }
+      default: {
+        throw err;
+        break;
+      }
+    };
+  };
+  return readAsString(result, {
     useTrim: true,
     numberToString: true,
     boolToString: true,
   });
 };
 
-function readXObjAttrAsBool(obj, name, defValue = false, defKey){
-  const param = readXObjAttrRaw(obj, name, defKey);
-  return readAsBoolEx(param, defValue);
+function readXObjAttrAsBool(obj, attr, defValue, key){
+  let result = undefined;
+  try {
+    result = readXObjAttrRaw(obj, attr, key);
+  } catch (err) {
+    switch (err.code) {
+      case XOBJ_TE_NSTR_ECODE : {
+        break;
+      }
+      default: {
+        throw err;
+        break;
+      }
+    };
+  };
+  return readAsBoolEx(result, defValue);
 };
 
-function readXObjAttrAsNum(obj, name, defValue = 0, defKey){
-  const param = readXObjAttrRaw(obj, name, defKey);
-  return readAsNumberEx(param, defValue);
+function readXObjAttrAsNum(obj, attr, defValue, key){
+  let result = undefined;
+  try {
+    result = readXObjAttrRaw(obj, attr, key);
+  } catch (err) {
+    switch (err.code) {
+      case XOBJ_TE_NSTR_ECODE : {
+        break;
+      }
+      default: {
+        throw err;
+        break;
+      }
+    };
+  };
+  return readAsNumberEx(result, defValue);
 };
 
-function readXObjAttrAsStr(obj, name, defValue = '', defKey){
-  const param = readXObjAttrRaw(obj, name, defKey);
-  return readAsString(param, defValue, {
+function readXObjAttrAsStr(obj, attr, defValue, key){
+  let result = undefined;
+  try {
+    result = readXObjAttrRaw(obj, attr, key);
+  } catch (err) {
+    switch (err.code) {
+      case XOBJ_TE_NSTR_ECODE : {
+        break;
+      }
+      default: {
+        throw err;
+        break;
+      }
+    };
+  };
+  return readAsString(result, defValue, {
     useTrim: true,
     numberToString: true,
     boolToString: true,
   });
 };
 
-function readXObjAttrAsIndex(obj, name, defKey){
-  return valueToIndex(readXObjAttrRaw(obj, name, defKey));
+function readXObjAttrAsIndex(obj, attr, key){
+  let result = undefined;
+  try {
+    result = readXObjAttrRaw(obj, attr, key);
+  } catch (err) {
+    switch (err.code) {
+      case XOBJ_TE_NSTR_ECODE : {
+        break;
+      }
+      default: {
+        throw err;
+        break;
+      }
+    };
+  };
+  return valueToIndex(result);
 };
 
-function writeXObjAttr(obj, name, value, defKey){
-  const _value = readAsString(value, {
-    useTrim: true,
-    numberToString: true,
-    boolToString: true,
-  });
-  return writeXObjAttrRaw(obj, name, _value, defKey);
+function writeXObjAttr(obj, attr, value, key){
+  let isSUCCEED = false;
+  if (value !== undefined) {
+    const _value = readAsString(value, {
+      useTrim: true,
+      numberToString: true,
+      boolToString: true,
+    });
+    try {
+      isSUCCEED = writeXObjAttrRaw(obj, attr, _value, key);
+    } catch (err) {
+      switch (err.code) {
+        case XOBJ_TE_NSTR_ECODE : {
+          break;
+        }
+        default: {
+          throw err;
+          break;
+        }
+      };
+    };
+  };
+  return isSUCCEED;
 };
 
-function writeXObjAttrAsBool(obj, name, value, defValue = false, defKey){
-  const _value = readAsBoolEx(value, defValue).toString();
-  return  writeXObjAttrRaw(obj, name, _value, defKey);
+function writeXObjAttrAsBool(obj, attr, value, defValue, key){
+  let isSUCCEED = false;
+  if (value !== undefined) {
+    const _value = readAsBoolEx(value, defValue).toString();
+    try {
+      isSUCCEED = writeXObjAttrRaw(obj, attr, _value, key);
+    } catch (err) {
+      switch (err.code) {
+        case XOBJ_TE_NSTR_ECODE : {
+          break;
+        }
+        default: {
+          throw err;
+          break;
+        }
+      };
+    };
+  };
+  return isSUCCEED;
 };
 
-function writeXObjAttrAsNum(obj, name, value, defValue = 0, defKey){
-  const _value = readAsNumberEx(value, defValue).toString();
-  return writeXObjAttrRaw(obj, name, _value, defKey);
+function writeXObjAttrAsNum(obj, attr, value, defValue, key){
+  let isSUCCEED = false;
+  if (value !== undefined) {
+    const _value = readAsNumberEx(value, defValue).toString();
+    try {
+      isSUCCEED = writeXObjAttrRaw(obj, attr, _value, key);
+    } catch (err) {
+      switch (err.code) {
+        case XOBJ_TE_NSTR_ECODE : {
+          break;
+        }
+        default: {
+          throw err;
+          break;
+        }
+      };
+    };
+  };
+  return isSUCCEED;
 };
 
-function writeXObjAttrAsIndex(obj, name, value, defKey){
-  const _value = valueToIndex(value).toString();
-  return writeXObjAttrRaw(obj, name, _value, defKey);
+function writeXObjAttrAsIndex(obj, attr, value, key){
+  let isSUCCEED = false;
+  if (value !== undefined) {
+    const _value = valueToIndex(value).toString();
+    try {
+      isSUCCEED = writeXObjAttrRaw(obj, attr, _value, key);
+    } catch (err) {
+      switch (err.code) {
+        case XOBJ_TE_NSTR_ECODE : {
+          break;
+        }
+        default: {
+          throw err;
+          break;
+        }
+      };
+    };
+  };
+  return isSUCCEED;
 };
 
-function writeXObjAttrEx(obj, name, value, defValue, defKey){
-  const _defValue = readAsString(defValue, {
-    useTrim: true,
-    numberToString: true,
-    boolToString: true,
-  });
-  const _value = readAsString(value, _defValue, {
-    useTrim: true,
-    numberToString: true,
-    boolToString: true,
-  });
-  return writeXObjAttrRaw(obj, name, _value, defKey);
+function writeXObjAttrEx(obj, attr, value, defValue, key){
+  let isSUCCEED = false;
+  if (value !== undefined) {
+    const _defValue = readAsString(defValue, {
+      useTrim: true,
+      numberToString: true,
+      boolToString: true,
+    });
+    const _value = readAsString(value, _defValue, {
+      useTrim: true,
+      numberToString: true,
+      boolToString: true,
+    });
+    try {
+      isSUCCEED = writeXObjAttrRaw(obj, attr, _value, key);
+    } catch (err) {
+      switch (err.code) {
+        case XOBJ_TE_NSTR_ECODE : {
+          break;
+        }
+        default: {
+          throw err;
+          break;
+        }
+      };
+    };
+  };
+  return isSUCCEED;
 };
 
 function insertXObjElements(obj, ...args){
-  if (!isPlainObject(obj)) throw new TypeError(XOBJ_TE_NPOBJ_EMSG);
-  let opt = {};
-  let count = 0;
-  let args_len = args.length;
-  if (args_len > 0) {
-    let pos = args_len-1;
-    if (typeof args[pos] === 'boolean') {
-      opt.force = args.pop();
-    } else if (isPlainObject(args[pos])) {
-      opt = args.pop();
-    };
+  if (!isPlainObject(obj)) {
+    let err = new TypeError(XOBJ_TE_NPOBJ_EMSG);
+    err.code = XOBJ_TE_NPOBJ_ECODE;
+    throw err;
   };
-  const key_names = readAsListS({
+  const len = args.length;
+  const hasOpt = len > 0 && isPlainObject(args[len - 1]);
+  const opt = hasOpt ? args.pop() : {};
+  const names = readAsListS({
     trim: true,
     keep_empty: false,
   }, ...args);
-  for (let key_name of key_names) {
-    if (insertXObjElement(obj, key_name, opt) !== null) count++;
+  let count = 0;
+  for (let key of names) {
+    if (insertXObjElement(obj, key, opt) !== null) count++;
   };
   return count;
 };
 
 function insertXObjEList(obj, name, opt){
-  if (!isPlainObject(obj)) throw new TypeError(XOBJ_TE_NPOBJ_EMSG);
-  const key = typeof name === 'string' ? name.trim() : '';
-  if (key === '') throw new TypeError(XOBJ_TE_KNES_EMSG);
-  let force_act = false;
-  let rip_oldies = false;
+  let err = null;
+  if (!isPlainObject(obj)) {
+    err = new TypeError(XOBJ_TE_NPOBJ_EMSG);
+    err.code = XOBJ_TE_NPOBJ_ECODE;
+    throw err;
+  };
+  if (typeof name !== 'string') {
+    err = new TypeError(XOBJ_TE_NSTR_EMSG);
+    err.code = XOBJ_TE_NSTR_ECODE;
+    throw err;
+  };
+  const key = name.trim();
+  if (key === '') {
+    err = new TypeError(XOBJ_TE_KNES_EMSG);
+    err.code = XOBJ_TE_KNES_ECODE;
+    throw err;
+  };
+  let _options = opt;
   if (typeof opt === 'boolean') {
-    force_act = opt;
-  } else if (isPlainObject(opt)) {
-    force_act = readAsBool(opt.force, false);
-    if (force_act) rip_oldies = readAsBool(opt.rip_oldies, false);
-  };
-  let isACCEPTED = false;
-  if (isNullOrUndef(obj[key])) {
-    obj[key] = [];
-    isACCEPTED = true;
-  } else if (force_act) {
-    if (rip_oldies || !isArray(obj[key])) obj[key] = [];
-    isACCEPTED = true;
+    _options = { force: _options };
+  } else if (!isPlainObject(_options)) {
+    _options = {};
+  };
+  let { force, rip_oldies, ripOldies } = _options;
+  if (typeof force !== 'boolean') force = false;
+  if (ripOldies === undefined) ripOldies = rip_oldies;
+  if (typeof ripOldies !== 'boolean') ripOldies = false;
+  let item = obj[key];
+  let isACCEPTED = (
+    isNullOrUndef(item)
+    || (force && (ripOldies || !isArray(item)))
+  );
+  if (isACCEPTED) {
+    obj[key] = item = [];
   } else {
-    isACCEPTED = isArray(obj[key]);
-    if (!isACCEPTED && isPlainObject(obj[key])) {
-      obj[key] = [ obj[key] ];
+    isACCEPTED = isArray(item);
+    if (!isACCEPTED && isPlainObject(item)) {
+      obj[key] = item = [ item ];
       isACCEPTED = true;
     };
   };
-  return isACCEPTED ? obj[key] : null;
+  return isACCEPTED ? item  : null;
 };
 
 function insertXObjEChain(obj, ...args){
-  if (!isPlainObject(obj)) throw new TypeError(XOBJ_TE_NPOBJ_EMSG);
-  let opt = {};
-  let args_len = args.length;
-  if (args_len > 0) {
-    let pos = args_len-1;
-    if (typeof args[pos] === 'boolean') {
-      opt.force = args.pop();
-    } else if (isPlainObject(args[pos])) {
-      opt = args.pop();
-    };
+  if (!isPlainObject(obj)) {
+    let err = new TypeError(XOBJ_TE_NPOBJ_EMSG);
+    err.code = XOBJ_TE_NPOBJ_ECODE;
+    throw err;
   };
-  let key_names = readAsListS({
+  const len = args.length;
+  const hasOpt = len > 0 && isPlainObject(args[len - 1]);
+  const opt = hasOpt ? args.pop() : {};
+  const names = readAsListS({
     trim: true,
     keep_empty: false,
   }, ...args);
   let curObj = obj;
   let isSUCCEED = false;
-  for (let key_name of key_names) {
-    obj = insertXObjElement(obj, key_name, opt);
+  for (let key of names) {
+    obj = insertXObjElement(obj, key, opt);
     isSUCCEED = isPlainObject(obj);
     if (!isSUCCEED) break;
     curObj = obj;
@@ -508,6 +1040,8 @@ exports.DEF_XML_PARSE_OPTIONS = DEF_XML_PARSE_OPTIONS;
 
 exports.TXmlContentParseOptions = TXmlContentParseOptions;
 
+exports.evalXObjEName = evalXObjEName;
+
 exports.readXObjParamRaw = readXObjParamRaw;
 exports.readXObjParam = readXObjParam;
 exports.readXObjParamAsBool = readXObjParamAsBool;
@@ -535,6 +1069,8 @@ exports.writeXObjAttrAsIndex = writeXObjAttrAsIndex;
 exports.writeXObjAttrEx = writeXObjAttrEx;
 
 exports.getXObjAttributes = getXObjAttributes;
+exports.checkXObjAttribute = checkXObjAttribute;
+exports.deleteXObjAttribute = deleteXObjAttribute;
 
 exports.getXObjElement = getXObjElement;
 exports.insertXObjElement = insertXObjElement;