diginext-utils 2.0.0 → 2.0.2

package/dist/array.js

@@ -0,0 +1,210 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+// src/math.ts
+var randInt = (low, high) => {
+  return low + Math.floor(Math.random() * (high - low + 1));
+};
+
+// src/array.ts
+var sumArray = (array, key) => {
+  if (!array) {
+    console.warn("ARRAY NOT EXITED !");
+    return 0;
+  }
+  if (key)
+    return array.reduce((c, v) => c + v[key], 0);
+  else
+    return array.reduce((c, v) => c + v, 0);
+};
+var averageArray = (array, key) => {
+  if (!array) {
+    console.warn("ARRAY NOT EXITED !");
+    return 0;
+  }
+  return sumArray(array, key) / array.length || 0;
+};
+var minArray = (array, key) => {
+  if (!array) {
+    console.warn("ARRAY NOT EXITED !");
+    return 0;
+  }
+  if (array.length > 0) {
+    if (key)
+      return array.reduce((c, v) => c < v[key] ? c : v[key]);
+    else
+      return array.reduce((c, v) => c < v ? c : v);
+  }
+  return 0;
+};
+var maxArray = (array, key) => {
+  if (!array) {
+    console.warn("ARRAY NOT EXITED !");
+    return 0;
+  }
+  if (array.length > 0) {
+    if (key)
+      return array.reduce((c, v) => c > v[key] ? c : v[key]);
+    else
+      return array.reduce((c, v) => c > v ? c : v);
+  }
+  return 0;
+};
+var sortElementByString = (array, key) => {
+  if (!Array.isArray(array))
+    return [];
+  if (key)
+    return array.sort((x, y) => {
+      var a = x[key].toUpperCase(), b = y[key].toUpperCase();
+      return a == b ? 0 : a > b ? 1 : -1;
+    });
+  console.log("NO KEY");
+};
+var sortElementByNumber = (array, key) => {
+  if (!Array.isArray(array))
+    return [];
+  if (key)
+    return array.sort((a, b) => {
+      return a[key] - b[key];
+    });
+  console.log("NO KEY");
+};
+var firstElement = (array) => {
+  if (array) {
+    if (array.length || array.length > 0)
+      return array[0];
+  }
+  return null;
+};
+var lastElement = (array) => {
+  if (array) {
+    if (array.length || array.length > 0)
+      return array[array.length - 1];
+  }
+  return null;
+};
+var randomIndex = (array) => {
+  if (array)
+    return randInt(0, array.length - 1);
+  return -1;
+};
+var randomElement = (array) => {
+  if (array)
+    return array[randomIndex(array)];
+  return null;
+};
+var mergeAndMakeUniqueElement = (list1, list2, key) => {
+  if (!list1 || !list2)
+    return;
+  if (key) {
+    return list1.concat(list2).filter((item, index, self) => {
+      return self.findIndex((x) => x[key] == item[key]) === index;
+    });
+  } else {
+    return list1.concat(list2).filter((x, index, self) => {
+      return self.indexOf(x) === index;
+    });
+  }
+};
+var allMatchInArray = (target, toMatch) => {
+  if (!target || !toMatch)
+    return false;
+  const found = toMatch.every((item) => {
+    return target.includes(item);
+  });
+  return found;
+};
+var removeItem = (item, array) => {
+  const index = array.indexOf(item);
+  if (index == -1) {
+    console.warn("[ArrayExtra.removeItem] Item not found.");
+    return array;
+  }
+  array.splice(index, 1);
+  return array;
+};
+var removeItemByKey = (key, value, array) => {
+  const foundIndex = array.findIndex((item) => {
+    return item[key] == value;
+  });
+  if (foundIndex < 0) {
+    console.warn("[ArrayExtra.removeItemByKey] Item not found.", key, value);
+    return array;
+  }
+  array.splice(foundIndex, 1);
+  return array;
+};
+var getRandom = (array, n) => {
+  var result = new Array(n), len = array.length, taken = new Array(len);
+  if (n > len)
+    throw new RangeError("getRandom: more elements taken than available");
+  while (n--) {
+    var x = Math.floor(Math.random() * len);
+    result[n] = array[x in taken ? taken[x] : x];
+    taken[x] = --len in taken ? taken[len] : len;
+  }
+  return result;
+};
+var getHalfRandom = (array, n) => {
+  var n = Math.ceil(array.length / 2);
+  return getRandom(array, n);
+};
+var shuffle = (array) => {
+  var i = array.length, j, temp;
+  if (array.length < 1)
+    return array;
+  while (--i) {
+    j = Math.floor(Math.random() * (i + 1));
+    temp = array[i];
+    array[i] = array[j];
+    array[j] = temp;
+  }
+  return array;
+};
+var moveIndex = (array, oldIndex, newIndex) => {
+  if (newIndex >= array.length) {
+    var k = newIndex - array.length + 1;
+    while (k--) {
+      array.push(void 0);
+    }
+  }
+  array.splice(newIndex, 0, array.splice(oldIndex, 1)[0]);
+  return array;
+};
+var moveArray = (array, oldIndex, newIndex) => {
+  while (oldIndex < 0) {
+    oldIndex += array.length;
+  }
+  while (newIndex < 0) {
+    newIndex += array.length;
+  }
+  if (newIndex >= array.length) {
+    var k = newIndex - array.length;
+    while (k-- + 1) {
+      array.push(999);
+    }
+  }
+  array.splice(newIndex, 0, array.splice(oldIndex, 1)[0]);
+  return array;
+};
+
+exports.allMatchInArray = allMatchInArray;
+exports.averageArray = averageArray;
+exports.firstElement = firstElement;
+exports.getHalfRandom = getHalfRandom;
+exports.getRandom = getRandom;
+exports.lastElement = lastElement;
+exports.maxArray = maxArray;
+exports.mergeAndMakeUniqueElement = mergeAndMakeUniqueElement;
+exports.minArray = minArray;
+exports.moveArray = moveArray;
+exports.moveIndex = moveIndex;
+exports.randomElement = randomElement;
+exports.randomIndex = randomIndex;
+exports.removeItem = removeItem;
+exports.removeItemByKey = removeItemByKey;
+exports.shuffle = shuffle;
+exports.sortElementByNumber = sortElementByNumber;
+exports.sortElementByString = sortElementByString;
+exports.sumArray = sumArray;

package/dist/array.mjs

@@ -0,0 +1,3 @@
+export { allMatchInArray, averageArray, firstElement, getHalfRandom, getRandom, lastElement, maxArray, mergeAndMakeUniqueElement, minArray, moveArray, moveIndex, randomElement, randomIndex, removeItem, removeItemByKey, shuffle, sortElementByNumber, sortElementByString, sumArray } from './chunk-Q5R25OIS.mjs';
+import './chunk-VFKAZAWF.mjs';
+import './chunk-AKU6F3WT.mjs';

package/dist/backend/file/createDir.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Create new directory
+ */
+declare function createDir(path: string): boolean;
+
+export { createDir as default };

package/dist/backend/file/createDir.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw new Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/backend/file/createDir.ts
+var fs = __require("fs");
+function createDir(path) {
+  if (fs.existsSync(path)) {
+    console.log("directory already exited !");
+    return true;
+  }
+  fs.mkdirSync(path, { recursive: true });
+}
+
+module.exports = createDir;

package/dist/backend/file/createDir.mjs

@@ -0,0 +1,13 @@
+import { __require } from '../../chunk-AKU6F3WT.mjs';
+
+// src/backend/file/createDir.ts
+var fs = __require("fs");
+function createDir(path) {
+  if (fs.existsSync(path)) {
+    console.log("directory already exited !");
+    return true;
+  }
+  fs.mkdirSync(path, { recursive: true });
+}
+
+export { createDir as default };

package/dist/backend/file/fileMove.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Move file to another location.
+ */
+declare function fileMove(oldPath: string, newPath: string, callback: any): void;
+
+export { fileMove as default };

package/dist/backend/file/fileMove.js

@@ -0,0 +1,37 @@
+'use strict';
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw new Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/backend/file/fileMove.ts
+var fs = __require("fs");
+function fileMove(oldPath, newPath, callback) {
+  fs.rename(oldPath, newPath, function(err) {
+    if (err) {
+      if (err.code === "EXDEV") {
+        copy();
+      } else {
+        callback(err);
+      }
+      return;
+    }
+    callback();
+  });
+  function copy() {
+    var readStream = fs.createReadStream(oldPath);
+    var writeStream = fs.createWriteStream(newPath);
+    readStream.on("error", callback);
+    writeStream.on("error", callback);
+    readStream.on("close", function() {
+      fs.unlink(oldPath, callback);
+    });
+    readStream.pipe(writeStream);
+  }
+}
+
+module.exports = fileMove;

package/dist/backend/file/fileMove.mjs

@@ -0,0 +1,29 @@
+import { __require } from '../../chunk-AKU6F3WT.mjs';
+
+// src/backend/file/fileMove.ts
+var fs = __require("fs");
+function fileMove(oldPath, newPath, callback) {
+  fs.rename(oldPath, newPath, function(err) {
+    if (err) {
+      if (err.code === "EXDEV") {
+        copy();
+      } else {
+        callback(err);
+      }
+      return;
+    }
+    callback();
+  });
+  function copy() {
+    var readStream = fs.createReadStream(oldPath);
+    var writeStream = fs.createWriteStream(newPath);
+    readStream.on("error", callback);
+    writeStream.on("error", callback);
+    readStream.on("close", function() {
+      fs.unlink(oldPath, callback);
+    });
+    readStream.pipe(writeStream);
+  }
+}
+
+export { fileMove as default };

package/dist/backend/file/findFilesByExt.d.ts

@@ -0,0 +1,6 @@
+/**
+ *
+ */
+declare const forEachFileByExt: (base: string, ext: string, cb: (path: string) => {}) => void;
+
+export { forEachFileByExt as default };

package/dist/backend/file/findFilesByExt.js

@@ -0,0 +1,48 @@
+'use strict';
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw new Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/backend/file/findFilesByExt.ts
+var path = __require("path");
+var fs = __require("fs");
+var forEachFileByExt = (base, ext, cb) => {
+  var walk = function(directoryName) {
+    try {
+      fs.readdir(directoryName, function(e, files) {
+        if (e) {
+          console.log("Error: ", e);
+          return;
+        }
+        files.forEach(function(file) {
+          var fullPath = path.join(directoryName, file);
+          fs.stat(fullPath, function(e2, f) {
+            if (e2) {
+              console.log("Error: ", e2);
+              return;
+            }
+            if (f.isDirectory()) {
+              walk(fullPath);
+            } else {
+              if (fullPath.toLowerCase().indexOf(ext.toLowerCase()) > -1) {
+                if (cb)
+                  cb(fullPath);
+              }
+            }
+          });
+        });
+      });
+    } catch (error) {
+      console.log("error", error);
+    }
+  };
+  walk(base);
+};
+var findFilesByExt_default = forEachFileByExt;
+
+module.exports = findFilesByExt_default;

package/dist/backend/file/findFilesByExt.mjs

@@ -0,0 +1,40 @@
+import { __require } from '../../chunk-AKU6F3WT.mjs';
+
+// src/backend/file/findFilesByExt.ts
+var path = __require("path");
+var fs = __require("fs");
+var forEachFileByExt = (base, ext, cb) => {
+  var walk = function(directoryName) {
+    try {
+      fs.readdir(directoryName, function(e, files) {
+        if (e) {
+          console.log("Error: ", e);
+          return;
+        }
+        files.forEach(function(file) {
+          var fullPath = path.join(directoryName, file);
+          fs.stat(fullPath, function(e2, f) {
+            if (e2) {
+              console.log("Error: ", e2);
+              return;
+            }
+            if (f.isDirectory()) {
+              walk(fullPath);
+            } else {
+              if (fullPath.toLowerCase().indexOf(ext.toLowerCase()) > -1) {
+                if (cb)
+                  cb(fullPath);
+              }
+            }
+          });
+        });
+      });
+    } catch (error) {
+      console.log("error", error);
+    }
+  };
+  walk(base);
+};
+var findFilesByExt_default = forEachFileByExt;
+
+export { findFilesByExt_default as default };

package/dist/chunk-5AL36RZR.mjs

@@ -0,0 +1,47 @@
+// src/object.ts
+var isNull = (object) => {
+  if (typeof object == "undefined")
+    return true;
+  if (object == "")
+    return true;
+  if (Array.isArray(object))
+    return object.length == 0;
+  if (JSON.stringify(object) == "{}")
+    return true;
+  return object == null;
+};
+var toBool = (object) => {
+  if (isNull(object))
+    return false;
+  object = object.toString();
+  return object === "true" || object == "1";
+};
+var toInt = (object) => {
+  if (isNull(object))
+    return 0;
+  object = object.toString();
+  return parseInt(object, 10);
+};
+var toFloat = (object) => {
+  if (isNull(object))
+    return 0;
+  object = object.toString();
+  return parseFloat(object);
+};
+var toArray = (obj) => {
+  if (isNull(obj))
+    return [];
+  if (!Array.isArray(obj)) {
+    obj = [obj];
+  }
+  return obj;
+};
+var objectToArray = (obj) => {
+  const array = [];
+  for (const key in obj) {
+    array.push(obj[key]);
+  }
+  return array;
+};
+
+export { isNull, objectToArray, toArray, toBool, toFloat, toInt };

package/dist/chunk-7IYY7BKN.mjs

@@ -0,0 +1,136 @@
+import { requestCamera_default } from './chunk-JKYSZLBF.mjs';
+
+// src/device/camera.ts
+function getWebcam({
+  container,
+  facingMode = "environment",
+  audio = false
+}) {
+  if (typeof window == "undefined")
+    return;
+  container = container || document.body;
+  return new Promise(async (resolve, reject) => {
+    const video = document.createElement("video");
+    video.style.position = "absolute";
+    video.style.top = "0";
+    video.style.left = "0";
+    video.style.width = "100%";
+    video.style.height = "100%";
+    container.append(video);
+    let inputCameras = [];
+    let currentCamera;
+    const requestedMediaConstraints = {
+      video: {
+        facingMode: { exact: facingMode }
+      },
+      audio
+    };
+    console.log("[Camera.js] Requesting:", requestedMediaConstraints);
+    const res = await requestCamera_default({ audio });
+    if (!res) {
+      setTimeout(function() {
+        handleError({ name: "Error", message: "NotSupported" });
+      }, 50);
+    }
+    navigator.mediaDevices.enumerateDevices().then(parseDevices).catch(handleError);
+    function parseDevices(devices) {
+      inputCameras = [];
+      let backCameras = [];
+      devices.forEach(function(device) {
+        if (device.kind == "videoinput" && typeof device.deviceId != "undefined" && device.deviceId != "") {
+          inputCameras.push(device);
+        }
+      });
+      console.log("[Camera.js] inputCameras:", inputCameras);
+      if (inputCameras.length > 0) {
+        let cams = "";
+        let backCamera;
+        inputCameras.map((cam, index) => {
+          cams += `[${cam.deviceId}] ${cam.kind} | ${cam.label}
+`;
+          let label = cam.label.toLowerCase();
+          if (label.indexOf("back") > -1 || label.indexOf("facetime") > -1) {
+            backCamera = cam;
+            backCameras.push(backCamera);
+          }
+        });
+        if (backCameras.length > 1) {
+          backCamera = backCameras[backCameras.length - 1];
+        }
+        console.log(`[Camera.js] All input sources:`, cams);
+        console.log(`[Camera.js] This device has ${backCameras.length} back camera${backCameras.length > 1 ? "s" : ""}.`);
+        console.log("[Camera.js] backCameras:", JSON.stringify(backCameras));
+        currentCamera = backCamera;
+        getStreamOfCameraId(backCamera.deviceId).then(onStreamReceived).catch((e) => {
+          if (backCameras.length > 1) {
+            backCamera = backCameras[backCameras.length - 2];
+            getStreamOfCameraId(backCamera.deviceId).then(onStreamReceived).catch(handleError);
+          } else if (backCameras.length > 2) {
+            backCamera = backCameras[backCameras.length - 3];
+            getStreamOfCameraId(backCamera.deviceId).then(onStreamReceived).catch(handleError);
+          } else {
+            handleError(e);
+          }
+        });
+      } else {
+        navigator.mediaDevices.getUserMedia(requestedMediaConstraints).then(onStreamReceived).catch(handleError);
+      }
+    }
+    function onStreamReceived(stream2) {
+      if (inputCameras.length == 0) {
+        console.log("[Camera.js] Not found any back cameras, request again?");
+        navigator.mediaDevices.enumerateDevices().then(parseDevices).catch(handleError);
+        return;
+      }
+      playWebcamVideo(stream2);
+    }
+    function playWebcamVideo(_stream) {
+      if ("srcObject" in video) {
+        video.srcObject = _stream;
+      } else {
+        video.src = window.URL.createObjectURL(_stream);
+      }
+      video.setAttribute("playsinline", "true");
+      video.setAttribute("muted", "true");
+      video.setAttribute("autoplay", "true");
+      video.muted = true;
+      video.autoplay = true;
+      video.style.objectFit = "cover";
+      video.play();
+      video.addEventListener("canplay", function(e) {
+      });
+      video.addEventListener("canplaythrough", function(e) {
+      });
+      video.addEventListener("error", (e) => console.log("[Camera.js] <video> error:", e));
+      video.addEventListener("stalled", function(e) {
+        console.log("[Camera.js] <video> stalled:", e);
+        reject();
+      });
+      video.addEventListener("loadedmetadata", function(e) {
+        if (currentCamera.label.toLowerCase().indexOf("facetime") > -1) {
+          video.style.transform = "scaleX(-1)";
+          video.style.webkitTransform = "scaleX(-1)";
+        }
+        video.play();
+        resolve(video);
+      });
+    }
+    function getStreamOfCameraId(id) {
+      const constraints = {
+        video: { deviceId: { exact: id } },
+        audio: false
+      };
+      return new Promise((resolve2, reject2) => {
+        navigator.mediaDevices.getUserMedia(constraints).then(resolve2).catch(reject2);
+      });
+    }
+    function handleError(err) {
+      console.error(err);
+      const errMsg = "[Camera.js] " + err.name + ": " + err.message;
+      console.error(errMsg);
+      reject();
+    }
+  });
+}
+
+export { getWebcam };