redate-cli 0.2.2 → 0.3.0

package/package.json

@@ -1,12 +1,16 @@
 {
   "name": "redate-cli",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "A CLI tool for renaming images based on EXIF data.",
   "type": "module",
-  "main": "src/redate.js",
+  "main": "./src/core.js",
   "bin": {
     "redate": "./src/redate.js"
   },
+  "exports": {
+    ".": "./src/core.js",
+    "./config": "./src/config.js"
+  },
   "scripts": {
     "redate": "node ./src/redate.js"
   },

package/src/core.js

@@ -0,0 +1,127 @@
+import fs from "fs";
+import path from "path";
+import exifr from "exifr";
+import { getConfig, TOKENS } from "./config.js";
+
+const fileHandlers = {
+    rename: (src, dest) => {
+        fs.renameSync(src, dest);
+    },
+
+    copy: (src, dest) => {
+        fs.copyFileSync(src, dest);
+    },
+
+    copy_in_folder: (src, dest) => {
+        const dir = path.dirname(src);
+        const targetDir = path.join(dir, "redate");
+        if (!fs.existsSync(targetDir)) {
+            fs.mkdirSync(targetDir);
+        }
+        fs.copyFileSync(src, path.join(targetDir, path.basename(dest)));
+    }
+};
+
+export async function redate(paths) {
+    const config = getConfig();
+
+    for (const p of paths) {
+        if (!fs.existsSync(p)) {
+            console.error(`Path does not exist: ${p}`);
+            continue;
+        }
+
+        const stats = fs.statSync(p);
+
+        if (stats.isFile()) {
+            await processFile(p, config);
+        } else if (stats.isDirectory()) {
+            await processFiles(p, config);
+        }
+    }
+}
+
+
+export async function processFiles(folderPath, config) {
+    if (!config || config == null) {
+        config = getConfig();
+    }
+    const files = fs.readdirSync(folderPath);
+    for (const file of files) {
+        const filePath = path.join(folderPath, file);
+
+        if (!fs.statSync(filePath).isFile()) continue;
+
+        await processFile(filePath, config);
+    }
+}
+
+export async function processFile(filePath, config) {
+    if (!config || config == null) {
+        config = getConfig();
+    }
+
+    const date = await getDateFromFile(filePath);
+    if (!date) return;
+
+    const originalName = path.basename(filePath);
+    const newFileName = formatFileName(date, originalName, config);
+
+    applyFileHandling(filePath, newFileName, config);
+
+    console.log(`Processed: ${newFileName}`);
+}
+function applyFileHandling(srcPath, newFileName, config) {
+    const dir = path.dirname(srcPath);
+    const dest = path.join(dir, newFileName);
+
+    const handler = fileHandlers[config.fileHandling];
+
+    if (!handler) {
+        throw new Error(`Unknown fileHandling: ${config.fileHandling}`);
+    }
+
+    handler(srcPath, dest);
+}
+
+
+export function formatFileName(date, originalName, config) {
+    let formatted = config.format;
+
+    const sortedTokens = Object.keys(TOKENS).sort((a, b) => b.length - a.length);
+
+    for (const key of sortedTokens) {
+        formatted = formatted.replaceAll(key, TOKENS[key].value(date));
+    }
+
+    const ext = path.extname(originalName);
+    return `${formatted}${ext}`;
+}
+
+
+export async function getDateFromFile(filePath) {
+    const exif = await exifr.parse(filePath, { reviveValues: true });
+
+
+    const date =
+        exif?.DateTimeOriginal ||
+        exif?.CreateDate ||
+        exif?.ModifyDate;
+
+    if (!date) {
+        console.error(`No EXIF date found for file: ${filePath}`);
+        return null;
+    };
+
+    const offset = exif.OffsetTimeOriginal;
+
+    if (!offset) return date;
+
+    const sign = offset[0] === '-' ? -1 : 1;
+    const [h, m] = offset.slice(1).split(':').map(Number);
+    const offsetMs = sign * (h * 60 + m) * 60_000;
+
+    return new Date(date.getTime() + offsetMs);
+}
+
+export default redate;

package/src/redate.js

@@ -1,41 +1,23 @@
 #!/usr/bin/env node
 import { Command } from "commander";
-import fs from "fs";
-import path from "path";
-import exifr from 'exifr';
 import https from "https";
 import { execSync } from "child_process";
 import readline from "readline";
 import { getConfig, setConfig, TOKENS, DEFAULT_CONFIG } from "./config.js";
-
+import redate from "./core.js";
 
 const program = new Command();
 
 program
     .name("redate")
     .description("Rename images based on EXIF dates")
-    .version("0.2.2");
+    .version("0.3.0");
 
 program
     .command("process <paths...>")
     .description("Process file(s) or folder(s)")
     .action(async (paths) => {
-        for (const p of paths) {
-            if (!fs.existsSync(p)) {
-                console.error(`Path does not exist: ${p}`);
-                continue;
-            }
-
-            const stats = fs.statSync(p);
-
-            if (stats.isFile()) {
-                await processFile(p);
-            } else if (stats.isDirectory()) {
-                await processFiles(p);
-            } else {
-                console.error(`Unsupported path type: ${p}`);
-            }
-        }
+        await redate(paths);
     });
 
 const configCommand = program
@@ -99,7 +81,7 @@ program
             }
 
             console.log("Updating...");
-            execSync("npm install -g redate", { stdio: "inherit" });
+            execSync("npm install -g redate-cli", { stdio: "inherit" });
 
             console.log("Update completed.");
         } catch (err) {
@@ -108,109 +90,6 @@ program
     });
 program.parse(process.argv);
 
-
-
-const fileHandlers = {
-    rename: (src, dest) => {
-        fs.renameSync(src, dest);
-    },
-
-    copy: (src, dest) => {
-        fs.copyFileSync(src, dest);
-    },
-
-    copy_in_folder: (src, dest) => {
-        const dir = path.dirname(src);
-        const targetDir = path.join(dir, "redate");
-        if (!fs.existsSync(targetDir)) {
-            fs.mkdirSync(targetDir);
-        }
-        fs.copyFileSync(src, path.join(targetDir, path.basename(dest)));
-    }
-};
-
-
-async function processFiles(folderPath) {
-    const files = fs.readdirSync(folderPath);
-    const config = getConfig();
-    for (const file of files) {
-        const filePath = path.join(folderPath, file);
-
-        if (!fs.statSync(filePath).isFile()) continue;
-
-        processFile(filePath, config);
-    }
-}
-
-
-
-async function processFile(filePath, config) {
-    if (!config || config == null) {
-        config = getConfig();
-    }
-
-    const date = await getDateFromFile(filePath);
-    if (!date) return;
-
-    const originalName = path.basename(filePath);
-    const newFileName = formatFileName(date, originalName, config);
-
-    applyFileHandling(filePath, newFileName, config);
-
-    console.log(`Processed: ${newFileName}`);
-}
-function applyFileHandling(srcPath, newFileName, config) {
-    const dir = path.dirname(srcPath);
-    const dest = path.join(dir, newFileName);
-
-    const handler = fileHandlers[config.fileHandling];
-
-    if (!handler) {
-        throw new Error(`Unknown fileHandling: ${config.fileHandling}`);
-    }
-
-    handler(srcPath, dest);
-}
-
-
-export function formatFileName(date, originalName, config) {
-    let formatted = config.format;
-
-    const sortedTokens = Object.keys(TOKENS).sort((a, b) => b.length - a.length);
-
-    for (const key of sortedTokens) {
-        formatted = formatted.replaceAll(key, TOKENS[key].value(date));
-    }
-
-    const ext = path.extname(originalName);
-    return `${formatted}${ext}`;
-}
-async function getDateFromFile(filePath) {
-    const exif = await exifr.parse(filePath, { reviveValues: true });
-
-
-    const date =
-        exif?.DateTimeOriginal ||
-        exif?.CreateDate ||
-        exif?.ModifyDate;
-
-    if (!date) {
-        console.error(`No EXIF date found for file: ${filePath}`);
-        return null;
-    };
-
-    const offset = exif.OffsetTimeOriginal;
-
-    if (!offset) return date;
-
-    const sign = offset[0] === '-' ? -1 : 1;
-    const [h, m] = offset.slice(1).split(':').map(Number);
-    const offsetMs = sign * (h * 60 + m) * 60_000;
-
-    return new Date(date.getTime() + offsetMs);
-}
-
-
 function getLatestVersionFromNpm(packageName) {
     return new Promise((resolve, reject) => {
         https