@ygracs/xepg-lib-js 0.0.19 → 0.0.21

package/lib/dts-helper.js

@@ -1,32 +1,52 @@
-// [v0.1.043-20230711]
+// [v0.1.047-20250225]
 
 // === module init block ===
 
 const {
-  valueToIndex, readAsString, readAsNumberEx,
-  isDateObject,
+  valueToIndex,
 } = require('@ygracs/bsfoc-lib-js');
 
 const {
   convDTValueToISO8601,
   convDTValueToXMLTV, convXMLTVToDTValue,
   convDTValueToDateString,
+  tryDTValue,
 } = require('@ygracs/dtf-lib-js');
 
+// === module extra block (helper functions) ===
+
+// === module main block ===
+
+/***
+ * (* constant definitions *)
+ */
+
 const def_dts_param = [
   'default', 'iso8601', 'xmltv', 'timestamp', 'utc',
 ];
 
-// === module extra block (helper functions) ===
-
-// === module main block (function definitions) ===
+/***
+ * (* function definitions *)
+ */
 
-function chkDTSysID(value){
+/**
+ * @function chkDTSysID
+ * @param {(number|string)} value - value to verify
+ * @returns {boolean}
+ * @description Checs if a given value is a valid dtstype ID
+ */
+function chkDTSysID(value) {
   const _value = valueToIndex(value);
   return _value !== -1 && def_dts_param[_value] ? true : false;
 };
 
-function getDTSysName(value){
+/**
+ * @function getDTSysName
+ * @param {(number|string)} value - DTS-type identifier
+ * @returns {string}
+ * @description Returns a dtstype name by a given dtstype ID
+ */
+function getDTSysName(value) {
   let result = 'undefined';
   if (chkDTSysID(value)) {
     result = def_dts_param[Number(value)];
@@ -34,7 +54,20 @@ function getDTSysName(value){
   return result;
 };
 
-function getDTSysDescr(value){
+/**
+ * @typedef {Object} DTSysDescr
+ * @property {number} index - dtstype ID
+ * @property {string} name - dtstype name
+ * @description A DTS-type descriptor
+ */
+
+/**
+ * @function getDTSysDescr
+ * @param {(number|string)} value - DTS-type identifier
+ * @returns {DTSysDescr}
+ * @description Returns a dtstype description for a given dtstype ID
+ */
+function getDTSysDescr(value) {
   let index = valueToIndex(value);
   let name = 'undefined';
   if (index !== -1) {
@@ -50,15 +83,24 @@ function getDTSysDescr(value){
   return { index, name };
 };
 
-function convStringToDTValue(value, dts_id, tz){
+/**
+ * @function convStringToDTValue
+ * @param {string} value - some value
+ * @param {(number|string)} [dts_id=0] - DTS-type identifier
+ * @param {(number|string)} [tz] - <*reserved*>
+ * @returns {number}
+ * @description Tries to convert a given string to timestamp
+ * @todo check TZ
+ */
+function convStringToDTValue(value, dts_id = 0, tz) {
+  const dtstype = getDTSysName(dts_id);
   let result = 0;
-  let dtstype = valueToIndex(dts_id);
-  let dt_str = typeof value === 'string' ? value : '';
-  if (chkDTSysID(dtstype)) {
-    switch (getDTSysName(dtstype)) {
+  if (dtstype !== 'undefined') {
+    switch (dtstype) {
       case 'default': {
         // TODO: check TZ
         //console.log('convStringToDTValue => dtstype:[default]');
+        let dt_str = typeof value === 'string' ? value : '';
         result = (new Date(dt_str)).getTime();
         //console.log('convStringToDTValue => value:['+value+']');
         //console.log('convStringToDTValue => result:['+result+']');
@@ -67,7 +109,8 @@ function convStringToDTValue(value, dts_id, tz){
       case 'iso8601': {
         // TODO: check TZ
         //console.log('convStringToDTValue => dtstype:[iso8601]');
-        result = (new Date(dt_str)).getTime();
+        let dtStr = typeof value === 'string' ? value : '';
+        if (dtStr !== '') result = (new Date(dtStr)).getTime();
         //console.log('convStringToDTValue => value:['+value+']');
         //console.log('convStringToDTValue => result:['+result+']');
         break;
@@ -75,7 +118,8 @@ function convStringToDTValue(value, dts_id, tz){
       case 'xmltv': {
         // TODO: check TZ
         //console.log('convStringToDTValue => dtstype:[xmltv]');
-        result = (new Date(convXMLTVToDTValue(dt_str))).getTime();
+        const dtValue = convXMLTVToDTValue(value, true);
+        if (dtValue !== null) result = dtValue;
         //console.log('convStringToDTValue => value:['+value+']');
         //console.log('convStringToDTValue => result:['+result+']');
         break;
@@ -83,7 +127,8 @@ function convStringToDTValue(value, dts_id, tz){
       case 'timestamp': {
         // TODO: check TZ
         //console.log('convStringToDTValue => dtstype:[timestamp]');
-        result = Number(dt_str);
+        const { isSucceed, value: dtValue } = tryDTValue(value);
+        if (isSucceed) result = dtValue.getTime();
         //console.log('convStringToDTValue => value:['+value+']');
         //console.log('convStringToDTValue => result:['+result+']');
         break;
@@ -91,28 +136,32 @@ function convStringToDTValue(value, dts_id, tz){
       case 'utc': {
         // TODO: check TZ
         //console.log('convStringToDTValue => dtstype:[utc]');
-        result = (new Date(Date.UTC(dt_str))).getTime();
+        let dtStr = typeof value === 'string' ? value : '';
+        if (dtStr !== '') result = (new Date(Date.UTC(dtStr))).getTime();
         //console.log('convStringToDTValue => value:['+value+']');
         //console.log('convStringToDTValue => result:['+result+']');
         break;
       }
-      default: {
-        break;
-      }
+      default: {}
     };
     if (Number.isNaN(result)) result = 0;
   };
   return result;
 };
 
-function convDTValueToString(value, dts_id, tz){
+/**
+ * @function convDTValueToString
+ * @param {(number|string|Date)} value - some value
+ * @param {(number|string)} [dts_id=0] - DTS-type identifier
+ * @param {(number|string)} [tz] - <*reserved*>
+ * @returns {string}
+ * @description Tries to convert a given value to its string representation
+ * @todo check TZ
+ */
+function convDTValueToString(value, dts_id, tz) {
+  let { isSucceed, value: dtValue } = tryDTValue(value);
+  let dt_val = isSucceed ? dtValue.getTime() : new Date(0);
   let result = '';
-  let dt_val = (
-    isDateObject(value)
-    ? value
-    : (new Date(readAsNumberEx(value, 0)))
-  ).getTime();
-  if (Number.isNaN(dt_val)) dt_val = new Date(0);
   let dtstype = valueToIndex(dts_id);
   if (!chkDTSysID(dtstype)) dtstype = 0;
   switch (getDTSysName(dtstype)) {
@@ -156,14 +205,14 @@ function convDTValueToString(value, dts_id, tz){
       //console.log('convDTValueToString => result:['+result+']');
       break;
     }
-    default: {
-      break;
-    }
+    default: {}
   };
   return result;
 };
 
-// === module main block (class definitions) ===
+/***
+ * (* class definitions *)
+ */
 
 // === module exports block ===
 

package/lib/file-helper.js

@@ -0,0 +1,278 @@
+// [v0.1.030-20241029]
+
+// === module init block ===
+
+const fs = require('fs');
+const fse = require('fs').promises;
+
+const {
+  isPlainObject,
+} = require('@ygracs/bsfoc-lib-js');
+
+// === module extra block (helper functions) ===
+
+/**
+ * @typedef {Object} fsoDescr
+ * @property {boolean} isERR - flag
+ * @property {number|undefined} errCode - error code
+ * @property {string} errEvent - event ID
+ * @property {string} errMsg - event message
+ * @property {string} source - path to file
+ * @property {any} content - file content
+ * @description A fs ops description.
+ */
+
+/**
+ * @typedef {Object} VCOR_evalerrfs
+ * @property {boolean} isSucceed - ops flag
+ * @property {fsoDescr} descr - description
+ * @description A result of an error check ops.
+ */
+
+/**
+ * @function checkFsError
+ * @param {fsoDescr} descr
+ * @param {Error} err
+ * @returns {VCOR_evalerrfs}
+ * @inner
+ * @description Checks an error code of a fs ops and sets descr info if succeed
+ */
+function checkFsError(descr, err) {
+  let isSucceed = false;
+  if (isPlainObject(err) && isPlainObject(descr)) {
+    switch (err.code) {
+      case 'ENOENT':
+      case 'EISDIR':
+      case 'ENOTDIR':
+      case 'EPERM': {
+        descr.errCode = err.errno;
+        descr.errEvent = err.code;
+        descr.errMsg = `ERR_FILE_${err.code}`;
+        isSucceed = true;
+        break;
+      }
+      default: {}
+    };
+    if (isSucceed) descr.isERR = true;
+  };
+  return { isSucceed, descr };
+};
+
+// === module main block ===
+
+/***
+ * (* constant definitions *)
+ */
+
+/***
+ * (* function definitions *)
+ */
+
+/**
+ * @function loadFileSync
+ * @param {string} src - a path to some file
+ * @returns {fsoDescr}
+ * @inner
+ * @description Loads file by a given path
+ */
+function loadFileSync(src) {
+  /** @type {fsoDescr} */
+  const data = {
+    isERR: false,
+    errCode: 0,
+    errEvent: '',
+    errMsg: '',
+    source: '',
+    content: '',
+  };
+  if (typeof src !== 'string') {
+    if (src !== undefined) {
+      data.isERR = true;
+      data.errEvent = 'ERR_INVARG';
+      data.errMsg = 'The "source" argument must be a string';
+    };
+  } else {
+    const srcPath = src.trim();
+    if (srcPath !== '') {
+      data.source = srcPath;
+      try {
+        data.content = fs.readFileSync(srcPath, 'utf8');
+      } catch (err) {
+        const { isSucceed } = checkFsError(data, err);
+        if (!isSucceed) {
+          // // TODO: [?] consider check others
+          //console.log(`TEST_ERR-MSG:loadFileSync: ${err}`);
+          //throw err;
+        };
+      };
+    };
+  };
+  return data;
+};
+
+/**
+ * @function loadFile
+ * @param {string} src - a path to some file
+ * @returns {Promise<fsoDescr, Error>}
+ * @async
+ * @inner
+ * @description Loads file by a given path
+ */
+function loadFile(src) {
+  /**/// main part that return promise as a result
+  return new Promise((resolve, reject) => {
+    /** @type {fsoDescr} */
+    const data = {
+      isERR: false,
+      errCode: 0,
+      errEvent: '',
+      errMsg: '',
+      source: '',
+      content: '',
+    };
+    if (typeof src !== 'string') {
+      if (src !== undefined) {
+        data.isERR = true;
+        data.errEvent = 'ERR_INVARG';
+        data.errMsg = 'The "source" argument must be a string';
+      };
+      resolve(data);
+    } else {
+      const srcPath = src.trim();
+      if (srcPath === '') resolve(data);
+      data.source = srcPath;
+      fse.readFile(srcPath, 'utf8').then(result => {
+        data.content = result;
+        resolve(data);
+      }).catch(err => {
+        let { isSucceed } = checkFsError(data, err);
+        if (isSucceed) {
+          data.content = '';
+          resolve(data);
+        } else {
+          //console.log('CHECK: loadFile() => Error => '+err);
+          //console.log('CHECK: loadFile() => Error => '+err.code);
+          reject(err);
+        };
+      });
+    };
+  });
+};
+
+/**
+ * @function saveToFileSync
+ * @param {string} src - a path to some file
+ * @param {string} content - some file content
+ * @param {any} [opt] - <reserved>
+ * @returns {fsoDescr}
+ * @inner
+ * @description Saves a content to a file
+ */
+function saveToFileSync(src, content = '', opt) {
+  /** @type {fsoDescr} */
+  const data = {
+    isERR: false,
+    errCode: 0,
+    errEvent: '',
+    errMsg: '',
+    source: '',
+    content: '',
+  };
+  if (typeof src !== 'string') {
+    data.isERR = true;
+    data.errEvent = src === undefined ? 'ERR_NOSRC' : 'ERR_INVARG';
+    data.errMsg = 'The "source" argument must be a string';
+  } else if (typeof content === 'string') {
+    const srcPath = src.trim();
+    if (srcPath === '') {
+      data.isERR = true;
+      data.errEvent = 'ERR_NOSRC';
+      data.errMsg = 'No "source" path given';
+    } else {
+      data.source = srcPath;
+      try {
+        fs.writeFileSync(srcPath, content, 'utf8');
+      } catch (err) {
+        const { isSucceed } = checkFsError(data, err);
+        if (!isSucceed) {
+          // // TODO: [?] consider check others
+          //console.log(`TEST_ERR-MSG:saveToFileSync: ${err}`);
+          //throw err;
+        };
+      };
+    };
+  } else {
+    data.isERR = true;
+    data.errEvent = 'ERR_INVARG';
+    data.errMsg = 'The "content" argument must be a string';
+  };
+  return data;
+};
+
+/**
+ * @function saveToFile
+ * @param {string} src - a path to some file
+ * @param {string} content - some file content
+ * @param {any} [opt] - <reserved>
+ * @returns {Promise<fsoDescr, Error>}
+ * @async
+ * @inner
+ * @description Saves a content to a file
+ */
+function saveToFile(src, content = '', opt) {
+  /**/// main part that return promise as a result
+  return new Promise((resolve, reject) => {
+    /** @type {fsoDescr} */
+    const data = {
+      isERR: false,
+      errCode: 0,
+      errEvent: '',
+      errMsg: '',
+      source: '',
+      content: '',
+    };
+    if (typeof src !== 'string') {
+      data.isERR = true;
+      data.errEvent = src === undefined ? 'ERR_NOSRC' : 'ERR_INVARG';
+      data.errMsg = 'The "source" argument must be a string';
+      resolve(data);
+    }  else if (typeof content === 'string') {
+      const srcPath = src.trim();
+      if (srcPath === '') {
+        data.isERR = true;
+        data.errEvent = 'ERR_NOSRC';
+        data.errMsg = 'No "source" path given';
+        resolve(data);
+      } else {
+        data.source = srcPath;
+        fse.writeFile(srcPath, content, 'utf8').then(result => {
+          resolve(data);
+        }).catch(err => {
+          const { isSucceed } = checkFsError(data, err);
+          if (isSucceed) resolve(data);
+          // // TODO: [?] consider check others
+          //console.log('CHECK: TXEpgContentProvider.saveToFile() => Error => '+err);
+          //console.log('CHECK: TXEpgContentProvider.saveToFile() => Error => '+err.code);
+          reject(err);
+        });
+      };
+    } else {
+      data.isERR = true;
+      data.errEvent = 'ERR_INVARG';
+      data.errMsg = 'The "content" argument must be a string';
+      resolve(data);
+    };
+  });
+};
+
+/***
+ * (* class definitions *)
+ */
+
+// === module exports block ===
+
+module.exports.checkFsError = checkFsError;
+module.exports.loadFile = loadFile;
+module.exports.loadFileSync = loadFileSync;
+module.exports.saveToFile = saveToFile;
+module.exports.saveToFileSync = saveToFileSync;