tiny-essentials 1.12.1 → 1.12.2

package/dist/v1/TinyUploadClicker.js

@@ -1,7 +1,7 @@
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
-/***/ 41:
+/***/ 133:
 /***/ (() => {
 
 /* (ignored) */
@@ -1924,6 +1924,13 @@ var hexSliceLookupTable = (function () {
 })()
 
 
+/***/ }),
+
+/***/ 370:
+/***/ (() => {
+
+/* (ignored) */
+
 /***/ }),
 
 /***/ 526:
@@ -3683,10 +3690,10 @@ const getHtmlElPadding = (el) => {
 };
 
 // EXTERNAL MODULE: fs (ignored)
-var fs_ignored_ = __webpack_require__(41);
+var fs_ignored_ = __webpack_require__(133);
 // EXTERNAL MODULE: ./node_modules/path-browserify/index.js
 var path_browserify = __webpack_require__(975);
-;// ./src/v1/basics/fileManager.mjs
+;// ./src/v1/fileManager/normalFuncs.mjs
 
 
 
@@ -3702,8 +3709,8 @@ var path_browserify = __webpack_require__(975);
  * @returns {any}
  */
 function readJsonFile(filePath) {
-  if (!fs.existsSync(filePath)) throw new Error(`File not found: ${filePath}`);
-  const content = fs.readFileSync(filePath, 'utf-8');
+  if (!existsSync(filePath)) throw new Error(`File not found: ${filePath}`);
+  const content = readFileSync(filePath, 'utf-8');
   return JSON.parse(content);
 }
 
@@ -3716,32 +3723,7 @@ function readJsonFile(filePath) {
  */
 function writeJsonFile(filePath, data, spaces = 2) {
   const json = JSON.stringify(data, null, spaces);
-  fs.writeFileSync(filePath, json, 'utf-8');
-}
-
-/**
- * Reads and parses a JSON file.
- * Throws an error if the file content is not valid JSON.
- * @param {string} filePath
- * @returns {Promise<any>}
- */
-async function readJsonFileAsync(filePath) {
-  if (!fs.existsSync(filePath)) throw new Error(`File not found: ${filePath}`);
-  const content = await fs.promises.readFile(filePath, 'utf-8');
-  return JSON.parse(content);
-}
-
-/**
- * Saves an object as JSON to a file.
- * Automatically creates the directory if it does not exist.
- * @param {string} filePath
- * @param {any} data
- * @param {number} [spaces=2]
- * @returns {Promise<void>}
- */
-function writeJsonFileAsync(filePath, data, spaces = 2) {
-  const json = JSON.stringify(data, null, spaces);
-  return fs.promises.writeFile(filePath, json, 'utf-8');
+  writeFileSync(filePath, json, 'utf-8');
 }
 
 /*========================*
@@ -3752,9 +3734,9 @@ function writeJsonFileAsync(filePath, data, spaces = 2) {
  * Ensures that the directory exists, creating it recursively if needed.
  * @param {string} dirPath
  */
-function ensureDirectory(dirPath) {
-  if (!fs.existsSync(dirPath)) {
-    fs.mkdirSync(dirPath, { recursive: true });
+function normalFuncs_ensureDirectory(dirPath) {
+  if (!existsSync(dirPath)) {
+    mkdirSync(dirPath, { recursive: true });
   }
 }
 
@@ -3763,15 +3745,15 @@ function ensureDirectory(dirPath) {
  * @param {string} dirPath
  */
 function clearDirectory(dirPath) {
-  if (!fs.existsSync(dirPath)) return;
-  const files = fs.readdirSync(dirPath);
+  if (!existsSync(dirPath)) return;
+  const files = readdirSync(dirPath);
   for (const file of files) {
-    const fullPath = path.join(dirPath, file);
-    const stat = fs.lstatSync(fullPath);
-    if (stat.isDirectory()) {
-      fs.rmSync(fullPath, { recursive: true, force: true });
+    const fullPath = join(dirPath, file);
+    const statData = lstatSync(fullPath);
+    if (statData.isDirectory()) {
+      rmSync(fullPath, { recursive: true, force: true });
     } else {
-      fs.unlinkSync(fullPath);
+      unlinkSync(fullPath);
     }
   }
 }
@@ -3785,8 +3767,8 @@ function clearDirectory(dirPath) {
  * @param {string} filePath
  * @returns {boolean}
  */
-function fileExists(filePath) {
-  return fs.existsSync(filePath) && fs.lstatSync(filePath).isFile();
+function normalFuncs_fileExists(filePath) {
+  return existsSync(filePath) && lstatSync(filePath).isFile();
 }
 
 /**
@@ -3794,8 +3776,8 @@ function fileExists(filePath) {
  * @param {string} dirPath
  * @returns {boolean}
  */
-function dirExists(dirPath) {
-  return fs.existsSync(dirPath) && fs.lstatSync(dirPath).isDirectory();
+function normalFuncs_dirExists(dirPath) {
+  return existsSync(dirPath) && lstatSync(dirPath).isDirectory();
 }
 
 /**
@@ -3804,7 +3786,7 @@ function dirExists(dirPath) {
  * @returns {boolean}
  */
 function isDirEmpty(dirPath) {
-  return fs.existsSync(dirPath) && fs.readdirSync(dirPath).length === 0;
+  return readdirSync(dirPath).length === 0;
 }
 
 /*========================*
@@ -3818,8 +3800,8 @@ function isDirEmpty(dirPath) {
  * @param {number} [mode]
  */
 function ensureCopyFile(src, dest, mode) {
-  ensureDirectory(path.dirname(dest));
-  fs.copyFileSync(src, dest, mode);
+  normalFuncs_ensureDirectory(dirname(dest));
+  copyFileSync(src, dest, mode);
 }
 
 /**
@@ -3828,33 +3810,8 @@ function ensureCopyFile(src, dest, mode) {
  * @returns {boolean}
  */
 function tryDeleteFile(filePath) {
-  if (fileExists(filePath)) {
-    fs.unlinkSync(filePath);
-    return true;
-  }
-  return false;
-}
-
-/**
- * Copies a file to a destination.
- * @param {string} src
- * @param {string} dest
- * @param {number} [mode]
- * @returns {Promise<void>}
- */
-function ensureCopyFileAsync(src, dest, mode) {
-  ensureDirectory(path.dirname(dest));
-  return fs.promises.copyFile(src, dest, mode);
-}
-
-/**
- * Deletes a file (If the file exists).
- * @param {string} filePath
- * @returns {Promise<boolean>}
- */
-async function tryDeleteFileAsync(filePath) {
-  if (fileExists(filePath)) {
-    await fs.promises.unlink(filePath);
+  if (normalFuncs_fileExists(filePath)) {
+    unlinkSync(filePath);
     return true;
   }
   return false;
@@ -3868,25 +3825,12 @@ async function tryDeleteFileAsync(filePath) {
  * Writes text to a file (Ensures that the directory exists, creating it recursively if needed).
  * @param {string} filePath
  * @param {string} content
- * @param {fs.WriteFileOptions} [ops='utf-8']
+ * @param {import('fs').WriteFileOptions} [ops='utf-8']
  */
 function writeTextFile(filePath, content, ops = 'utf-8') {
-  const dir = path.dirname(filePath);
-  ensureDirectory(dir);
-  fs.writeFileSync(filePath, content, ops);
-}
-
-/**
- * Writes text to a file (Ensures that the directory exists, creating it recursively if needed).
- * @param {string} filePath
- * @param {string} content
- * @param {fs.WriteFileOptions} [ops='utf-8']
- * @returns {Promise<void>}
- */
-function writeTextFileAsync(filePath, content, ops = 'utf-8') {
-  const dir = path.dirname(filePath);
-  ensureDirectory(dir);
-  return fs.promises.writeFile(filePath, content, ops);
+  const dir = dirname(filePath);
+  normalFuncs_ensureDirectory(dir);
+  writeFileSync(filePath, content, ops);
 }
 
 /*========================*
@@ -3902,13 +3846,13 @@ function writeTextFileAsync(filePath, content, ops = 'utf-8') {
 function listFiles(dirPath, recursive = false) {
   /** @type {{ files: string[]; dirs: string[] }} */
   const results = { files: [], dirs: [] };
-  if (!dirExists(dirPath)) return results;
+  if (!normalFuncs_dirExists(dirPath)) return results;
 
-  const entries = fs.readdirSync(dirPath);
+  const entries = readdirSync(dirPath);
   for (const entry of entries) {
-    const fullPath = path.join(dirPath, entry);
-    const stat = fs.lstatSync(fullPath);
-    if (stat.isDirectory()) {
+    const fullPath = join(dirPath, entry);
+    const statData = lstatSync(fullPath);
+    if (statData.isDirectory()) {
       results.dirs.push(fullPath);
       if (recursive) {
         const results2 = listFiles(fullPath, true);
@@ -3931,13 +3875,13 @@ function listFiles(dirPath, recursive = false) {
 function listDirs(dirPath, recursive = false) {
   /** @type {string[]} */
   const results = [];
-  if (!dirExists(dirPath)) return results;
+  if (!normalFuncs_dirExists(dirPath)) return results;
 
-  const entries = fs.readdirSync(dirPath);
+  const entries = readdirSync(dirPath);
   for (const entry of entries) {
-    const fullPath = path.join(dirPath, entry);
-    const stat = fs.lstatSync(fullPath);
-    if (stat.isDirectory()) {
+    const fullPath = join(dirPath, entry);
+    const statData = lstatSync(fullPath);
+    if (statData.isDirectory()) {
       results.push(fullPath);
       if (recursive) {
         results.push(...listDirs(fullPath, true));
@@ -3957,8 +3901,8 @@ function listDirs(dirPath, recursive = false) {
  * @returns {number}
  */
 function fileSize(filePath) {
-  if (!fileExists(filePath)) return 0;
-  const stats = fs.statSync(filePath);
+  if (!normalFuncs_fileExists(filePath)) return 0;
+  const stats = statSync(filePath);
   return stats.size;
 }
 
@@ -3986,7 +3930,7 @@ function dirSize(dirPath) {
  * @param {string} [ext='bak']
  */
 function backupFile(filePath, ext = 'bak') {
-  if (!fileExists(filePath)) return;
+  if (!normalFuncs_fileExists(filePath)) return;
   const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
   const backupPath = `${filePath}.${ext}.${timestamp}`;
   ensureCopyFile(filePath, backupPath);
@@ -3998,18 +3942,17 @@ function backupFile(filePath, ext = 'bak') {
  * @param {string} [ext='bak']
  * @returns {string} Full path to the most recent backup
  */
-function getLatestBackupPath(filePath, ext = 'bak') {
-  const dir = path.dirname(filePath);
-  const baseName = path.basename(filePath);
-  const backups = fs
-    .readdirSync(dir)
+function normalFuncs_getLatestBackupPath(filePath, ext = 'bak') {
+  const dir = dirname(filePath);
+  const baseName = basename(filePath);
+  const backups = readdirSync(dir)
     .filter((name) => name.startsWith(`${baseName}.${ext}.`))
     .sort()
     .reverse();
 
   if (backups.length === 0) throw new Error(`No backups found for ${filePath}`);
 
-  return path.join(dir, backups[0]);
+  return join(dir, backups[0]);
 }
 
 /**
@@ -4018,34 +3961,10 @@ function getLatestBackupPath(filePath, ext = 'bak') {
  * @param {string} [ext='bak']
  */
 function restoreLatestBackup(filePath, ext = 'bak') {
-  const latestBackup = getLatestBackupPath(filePath, ext);
+  const latestBackup = normalFuncs_getLatestBackupPath(filePath, ext);
   ensureCopyFile(latestBackup, filePath);
 }
 
-/**
- * Restores the most recent backup of a file.
- * @param {string} filePath
- * @param {string} [ext='bak']
- * @returns {Promise<void>}
- */
-function restoreLatestBackupAsync(filePath, ext = 'bak') {
-  const latestBackup = getLatestBackupPath(filePath, ext);
-  return ensureCopyFileAsync(latestBackup, filePath);
-}
-
-/**
- * Creates a backup copy of a file with .bak timestamp suffix.
- * @param {string} filePath
- * @param {string} [ext='bak']
- * @returns {Promise<void>}
- */
-async function backupFileAsync(filePath, ext = 'bak') {
-  if (!fileExists(filePath)) return;
-  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-  const backupPath = `${filePath}.${ext}.${timestamp}`;
-  return ensureCopyFileAsync(filePath, backupPath);
-}
-
 /*========================*
  * Rename Utilities
  *========================*/
@@ -4064,7 +3983,7 @@ function renameFileBatch(dirPath, renameFn, extensions = []) {
   if (typeof dirPath !== 'string') throw new TypeError('dirPath must be a string');
   if (typeof renameFn !== 'function') throw new TypeError('renameFn must be a function');
   if (!Array.isArray(extensions)) throw new TypeError('extensions must be an array of strings');
-  if (!fs.existsSync(dirPath) || !fs.statSync(dirPath).isDirectory())
+  if (!existsSync(dirPath) || !statSync(dirPath).isDirectory())
     throw new Error(`Directory not found or invalid: ${dirPath}`);
   for (const ext of extensions) {
     if (typeof ext !== 'string' || !ext.startsWith('.'))
@@ -4075,16 +3994,16 @@ function renameFileBatch(dirPath, renameFn, extensions = []) {
   let index = 0;
 
   for (const file of files) {
-    const ext = path.extname(file);
+    const ext = extname(file);
     if (extensions.length && !extensions.includes(ext)) continue;
 
-    const originalName = path.basename(file);
+    const originalName = basename(file);
     const newName = renameFn(originalName, index++);
-    const newPath = path.join(dirPath, newName);
+    const newPath = join(dirPath, newName);
 
     if (originalName === newName) continue;
 
-    fs.renameSync(file, newPath);
+    renameSync(file, newPath);
   }
 }
 
@@ -4099,8 +4018,8 @@ function renameFileRegex(dirPath, pattern, replacement, extensions = []) {
   renameFileBatch(
     dirPath,
     (filename) => {
-      const ext = path.extname(filename);
-      const name = path.basename(filename, ext).replace(pattern, replacement);
+      const ext = extname(filename);
+      const name = basename(filename, ext).replace(pattern, replacement);
       return `${name}${ext}`;
     },
     extensions,
@@ -4117,8 +4036,8 @@ function renameFileAddPrefixSuffix(dirPath, { prefix = '', suffix = '' }, extens
   renameFileBatch(
     dirPath,
     (filename) => {
-      const ext = path.extname(filename);
-      const name = path.basename(filename, ext);
+      const ext = extname(filename);
+      const name = basename(filename, ext);
       return `${prefix}${name}${suffix}${ext}`;
     },
     extensions,
@@ -4155,9 +4074,9 @@ function renameFileNormalizeCase(
         else return text;
       };
 
-      const rawExt = path.extname(filename);
+      const rawExt = extname(filename);
       const ext = normalizeExt ? changeToMode(rawExt) : rawExt;
-      const name = changeToMode(path.basename(filename, rawExt));
+      const name = changeToMode(basename(filename, rawExt));
       return `${name}${ext}`;
     },
     extensions,
@@ -4180,6 +4099,266 @@ function renameFilePadNumbers(dirPath, totalDigits = 3, extensions = []) {
   );
 }
 
+// EXTERNAL MODULE: fs/promises (ignored)
+var promises_ignored_ = __webpack_require__(370);
+;// ./src/v1/fileManager/asyncFuncs.mjs
+
+
+
+
+
+/*========================*
+ * JSON Operations
+ *========================*/
+
+/**
+ * Reads and parses a JSON file.
+ * Throws an error if the file content is not valid JSON.
+ * @param {string} filePath
+ * @returns {Promise<any>}
+ */
+async function readJsonFileAsync(filePath) {
+  if (!existsSync(filePath)) throw new Error(`File not found: ${filePath}`);
+  const content = await readFile(filePath, 'utf-8');
+  return JSON.parse(content);
+}
+
+/**
+ * Saves an object as JSON to a file.
+ * Automatically creates the directory if it does not exist.
+ * @param {string} filePath
+ * @param {any} data
+ * @param {number} [spaces=2]
+ * @returns {Promise<void>}
+ */
+function writeJsonFileAsync(filePath, data, spaces = 2) {
+  const json = JSON.stringify(data, null, spaces);
+  return writeFile(filePath, json, 'utf-8');
+}
+
+/*========================*
+ * Directory Management
+ *========================*/
+
+/**
+ * Clears all contents inside a directory but keeps the directory.
+ * @param {string} dirPath
+ */
+async function clearDirectoryAsync(dirPath) {
+  if (!existsSync(dirPath)) return;
+  const files = await readdir(dirPath);
+
+  /** @type {Record<string, import('fs').Stats>} */
+  const dataList = {};
+  const promises = [];
+
+  for (const file of files) {
+    const fullPath = join(dirPath, file);
+    const lsResult = lstat(fullPath);
+
+    lsResult.then((statData) => {
+      dataList[fullPath] = statData;
+      return statData;
+    });
+    promises.push(lsResult);
+  }
+
+  await Promise.all(promises);
+  const promises2 = [];
+  for (const fullPath in dataList) {
+    const statData = dataList[fullPath];
+    if (statData.isDirectory()) {
+      promises2.push(rm(fullPath, { recursive: true, force: true }));
+    } else {
+      promises2.push(unlink(fullPath));
+    }
+  }
+
+  await Promise.all(promises2);
+}
+
+/*========================*
+ * File Checks
+ *========================*/
+
+/**
+ * Checks whether a directory is empty.
+ * @param {string} dirPath
+ * @returns {Promise<boolean>}
+ */
+async function isDirEmptyAsync(dirPath) {
+  const data = await readdir(dirPath);
+  return data.length === 0;
+}
+
+/*========================*
+ * File Operations
+ *========================*/
+
+/**
+ * Copies a file to a destination.
+ * @param {string} src
+ * @param {string} dest
+ * @param {number} [mode]
+ * @returns {Promise<void>}
+ */
+function ensureCopyFileAsync(src, dest, mode) {
+  ensureDirectory(dirname(dest));
+  return copyFile(src, dest, mode);
+}
+
+/**
+ * Deletes a file (If the file exists).
+ * @param {string} filePath
+ * @returns {Promise<boolean>}
+ */
+async function tryDeleteFileAsync(filePath) {
+  if (fileExists(filePath)) {
+    await unlink(filePath);
+    return true;
+  }
+  return false;
+}
+
+/*========================*
+ * Text Operations
+ *========================*/
+
+/**
+ * Writes text to a file (Ensures that the directory exists, creating it recursively if needed).
+ * @param {string} filePath
+ * @param {string} content
+ * @param {import('fs').WriteFileOptions} [ops='utf-8']
+ * @returns {Promise<void>}
+ */
+function writeTextFileAsync(filePath, content, ops = 'utf-8') {
+  const dir = dirname(filePath);
+  ensureDirectory(dir);
+  return writeFile(filePath, content, ops);
+}
+
+/*========================*
+ * Directory Listings
+ *========================*/
+
+/**
+ * Lists all files and dirs in a directory (optionally recursive).
+ * @param {string} dirPath
+ * @param {boolean} [recursive=false]
+ * @returns {Promise<{ files: string[]; dirs: string[] }>}
+ */
+async function listFilesAsync(dirPath, recursive = false) {
+  /** @type {{ files: string[]; dirs: string[] }} */
+  const results = { files: [], dirs: [] };
+  if (!dirExists(dirPath)) return results;
+
+  const entries = await readdir(dirPath);
+  for (const entry of entries) {
+    const fullPath = join(dirPath, entry);
+    const statData = await lstat(fullPath);
+    if (statData.isDirectory()) {
+      results.dirs.push(fullPath);
+      if (recursive) {
+        const results2 = await listFilesAsync(fullPath, true);
+        results.files.push(...results2.files);
+        results.dirs.push(...results2.dirs);
+      }
+    } else {
+      results.files.push(fullPath);
+    }
+  }
+  return results;
+}
+
+/**
+ * Lists all directories in a directory (optionally recursive).
+ * @param {string} dirPath
+ * @param {boolean} [recursive=false]
+ * @returns {Promise<string[]>}
+ */
+async function listDirsAsync(dirPath, recursive = false) {
+  /** @type {string[]} */
+  const results = [];
+  if (!dirExists(dirPath)) return results;
+
+  const entries = await readdir(dirPath);
+  for (const entry of entries) {
+    const fullPath = join(dirPath, entry);
+    const statData = await lstat(fullPath);
+    if (statData.isDirectory()) {
+      results.push(fullPath);
+      if (recursive) {
+        results.push(...(await listDirsAsync(fullPath, true)));
+      }
+    }
+  }
+  return results;
+}
+
+/*========================*
+ * File Info
+ *========================*/
+
+/**
+ * Returns the size of a file in bytes.
+ * @param {string} filePath
+ * @returns {Promise<number>}
+ */
+async function fileSizeAsync(filePath) {
+  if (!fileExists(filePath)) return 0;
+  const stats = await stat(filePath);
+  return stats.size;
+}
+
+/**
+ * Returns the total size of a directory in bytes.
+ * @param {string} dirPath
+ * @returns {Promise<number>}
+ */
+async function dirSizeAsync(dirPath) {
+  let total = 0;
+  const { files } = await listFilesAsync(dirPath, true);
+  const promises = [];
+  for (const file of files) {
+    const result = fileSizeAsync(file);
+    result.then((item) => {
+      total += item;
+      return item;
+    });
+    promises.push(result);
+  }
+  await Promise.all(promises);
+  return total;
+}
+
+/*========================*
+ * Backup Utilities
+ *========================*/
+
+/**
+ * Restores the most recent backup of a file.
+ * @param {string} filePath
+ * @param {string} [ext='bak']
+ * @returns {Promise<void>}
+ */
+function restoreLatestBackupAsync(filePath, ext = 'bak') {
+  const latestBackup = getLatestBackupPath(filePath, ext);
+  return ensureCopyFileAsync(latestBackup, filePath);
+}
+
+/**
+ * Creates a backup copy of a file with .bak timestamp suffix.
+ * @param {string} filePath
+ * @param {string} [ext='bak']
+ * @returns {Promise<void>}
+ */
+async function backupFileAsync(filePath, ext = 'bak') {
+  if (!fileExists(filePath)) return;
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const backupPath = `${filePath}.${ext}.${timestamp}`;
+  return ensureCopyFileAsync(filePath, backupPath);
+}
+
 ;// ./src/v1/libs/TinyDragger.mjs
 
 
@@ -5103,6 +5282,10 @@ class TinyDragger {
 
 
 
+
+
+
+