animepic-utils 0.0.1

package/contributing.md

@@ -0,0 +1,177 @@
+# Typescript Style Guide
+
+If you want to contribute to my repository, I ask that you follow my code styling. If something doesn't appear in this guide then I have no specific preference 
+for it (but this may get updated in the future as needed).
+
+**1. Naming Scheme** \
+Variables and functions use `camelCase`. Classes and interfaces use `PascalCase`. 
+
+```ts
+// x Bad
+class aClass {}
+const Method = () => {}
+let Hi = 1
+// ✓ Good
+class AClass {}
+const method = () => {}
+let hi = 1
+```
+
+**2. Braces** \
+Always put the function brace on the same line.
+
+```ts
+// x Bad
+const a = () =>
+{
+}
+// ✓ Good
+const a = () => {
+}
+```
+
+**3. No Semicolons** \
+Do not use semicolons, unless when needed to avoid a syntax error. They are ugly.
+
+```ts
+// x Bad
+let a = 5;
+// ✓ Good
+let a = 5
+```
+
+**4. Double quote strings** \
+Use double quotes for string literals, not single quotes. 
+
+```ts
+// x Bad
+let a = 'hello'
+// ✓ Good
+let a = "hello"
+```
+
+**5. No spaces on imports** \
+No spaces when importing classes.
+
+```ts
+// x Bad
+import { Test } from "test"
+// ✓ Good
+import {Test} from "test"
+```
+
+**6. Use arrow functions** \
+Always use arrow functions to avoid having to bind this.
+
+```ts
+// x Bad
+async function func(str: string) {}
+// ✓ Good
+const func = async (str: string) => {}
+```
+
+**7. No var** \
+Do not use var when declaring variables.
+
+```ts
+// x Bad
+var a = 1
+// ✓ Good
+let a = 1
+const b = 2
+```
+
+**8. No double equals** \
+Do not use the double equals/not equals.
+
+```ts
+// x Bad
+if (a == 1)
+if (a != 1)
+// ✓ Good
+if (a === 1)
+if (a !== 1)
+```
+
+**9. Do not fill with comments** \
+Do not fill the code with excessive comments. A documentation comment for the function is fine. If you have 
+to comment every other line, you are making bad code.
+
+```ts
+// x Bad
+// set a to 1
+let a = 1
+// ✓ Good
+/**
+* Gets a user from the api
+*/
+public getUser = async () => {}
+```
+
+**10. Use implicit return types** \
+Let typescript infer the return type whenever possible. This helps when refactoring, since changes to the function will always update to the correct return type.
+
+```ts
+// x Bad
+public func = async (str: string): Promise<string> => {}
+// ✓ Good
+public func = async (str: string) => {}
+```
+
+**11. Interface vs type** \
+Interface should be used for large object-like types. Type is used for simpler union types or when generics are needed.
+
+```ts
+// Interface
+interface User {
+  name: string
+  birthday: string
+}
+// Type
+type Theme = "light" | "dark"
+```
+
+**12. Minimize any usage** \
+Typed code minimizes bugs. Therefore you should reduce the usage of any type as much as possible, although sometimes it is 
+unavoidable.
+
+```ts
+// x Bad
+let x = [] as any
+// ✓ Good
+let x = [] as string[]
+```
+
+**13. Use async/await** \
+Use async/await. Avoid nested callbacks hell. You can convert a callback to async/await like this:
+
+```ts
+await new Promise<void>((resolve) => {
+  callback((result) => {
+    resolve()
+  })
+}
+```
+
+**14. Use array methods for simple logic** \
+Prefer array methods like map and filter for simple logic over a for loop. For complex logic, you may 
+use a for loop instead.
+
+```ts
+// x Bad
+for (let i = 0; i < a.length; i++) {
+  a[i] += 5
+}
+// ✓ Good
+a = a.map(x => x + 5)
+```
+
+**15. Use index signature over record type** \
+Prefer index signature over Record.
+
+```ts
+// x Bad
+let x = {} as Record<string, number>
+// ✓ Good
+let x = {} as {[key: string]: number}
+```

package/dist/image-utils.d.ts

@@ -0,0 +1,71 @@
+import sharp from "sharp";
+import { Waifu2xOptions } from "waifu2x";
+type Formats = "jpg" | "png" | "webp" | "avif" | "jxl";
+type FormatOptionMap = {
+    jpg: sharp.JpegOptions;
+    png: sharp.PngOptions;
+    webp: sharp.WebpOptions;
+    avif: sharp.AvifOptions;
+    jxl: sharp.JxlOptions;
+};
+export default class ImageUtils {
+    /**
+     * Fixes incorrect image extensions. It must be correct to preview on mac.
+     */
+    static fixFileExtensions: (folder: string) => Promise<void>;
+    /**
+     * Copies images to the destination (unchanged)
+     */
+    static copyImages: (sourceFolder: string, destFolder: string) => void;
+    /**
+     * Moves images to the destination
+     */
+    static moveImages: (sourceFolder: string, destFolder: string) => void;
+    /**
+     * Resizes image down to a maximum width/height.
+     */
+    static resizeImage: (filepath: string, maxSize?: number | {
+        maxWidth: number;
+        maxHeight: number;
+    }) => Promise<string>;
+    /**
+     * Transparent image check.
+     */
+    static isTransparent: (filepath: string) => Promise<boolean>;
+    /**
+     * Converts image to the specified format. Default is jpg for non-transparent and webp for transparent.
+     */
+    static convertImage: <T extends Formats>(filepath: string, format?: T, formatOptions?: FormatOptionMap[T], transparentFormat?: T, transparentFormatOptions?: FormatOptionMap[T]) => Promise<string>;
+    /**
+     * Upscale image. Optionally copies unprocessed files (due to an error) to a folder.
+     */
+    static upscaleImage: <T extends Formats>(src: string, destFolder: string, options?: Waifu2xOptions, unprocessedFolder?: boolean) => Promise<string>;
+    /**
+     * Processes an image folder with a custom chain of operations.
+     */
+    static processImages: <T extends Formats>(folder: string, ...operations: Array<(file: string) => Promise<string>>) => Promise<void>;
+    /**
+     * Shorthand process images with only a resize.
+     */
+    static resizeImages: (folder: string, maxSize?: number | {
+        maxWidth: number;
+        maxHeight: number;
+    }) => Promise<void>;
+    /**
+     * Shorthand process images with only a conversion.
+     */
+    static convertImages: <T extends Formats>(folder: string, format?: T, formatOptions?: FormatOptionMap[T], transparentFormat?: T, transparentFormatOptions?: FormatOptionMap[T]) => Promise<void>;
+    /**
+     * Shorthand process images with only a upscale.
+     */
+    static upscaleImages: <T extends Formats>(sourceFolder: string, destFolder: string, options?: Waifu2xOptions, unprocessedFolder?: boolean) => Promise<void>;
+    /**
+     * Splits up a folder into more manageable chunks.
+     */
+    static splitFolder: (folder: string, maxAmount?: number) => void;
+    /**
+     * Processes an image folder to be suitable to upload to moepictures.
+     */
+    static moepicsProcess: (folder: string) => Promise<void>;
+}
+export {};

package/dist/image-utils.js

@@ -0,0 +1,238 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const sharp_1 = __importDefault(require("sharp"));
+const waifu2x_1 = __importDefault(require("waifu2x"));
+class ImageUtils {
+    /**
+     * Fixes incorrect image extensions. It must be correct to preview on mac.
+     */
+    static fixFileExtensions = async (folder) => {
+        const files = fs_1.default.readdirSync(folder).filter((f) => f !== ".DS_Store");
+        for (const file of files) {
+            let filepath = path_1.default.join(folder, file);
+            if (fs_1.default.lstatSync(filepath).isDirectory())
+                continue;
+            const buffer = fs_1.default.readFileSync(filepath);
+            const meta = await (0, sharp_1.default)(buffer, { limitInputPixels: false }).metadata();
+            let ext = meta.format.replace("jpeg", "jpg");
+            let newFile = `${path_1.default.basename(file, path_1.default.extname(file))}.${ext}`;
+            let newFilePath = path_1.default.join(folder, newFile);
+            fs_1.default.renameSync(filepath, newFilePath);
+        }
+    };
+    /**
+     * Copies images to the destination (unchanged)
+     */
+    static copyImages = (sourceFolder, destFolder) => {
+        const files = fs_1.default.readdirSync(sourceFolder).filter((f) => f !== ".DS_Store");
+        for (const file of files) {
+            let src = path_1.default.join(sourceFolder, file);
+            if (fs_1.default.lstatSync(src).isDirectory())
+                continue;
+            let dest = path_1.default.join(destFolder, file);
+            fs_1.default.copyFileSync(src, dest);
+        }
+    };
+    /**
+     * Moves images to the destination
+     */
+    static moveImages = (sourceFolder, destFolder) => {
+        const files = fs_1.default.readdirSync(sourceFolder).filter((f) => f !== ".DS_Store");
+        for (const file of files) {
+            let src = path_1.default.join(sourceFolder, file);
+            if (fs_1.default.lstatSync(src).isDirectory())
+                continue;
+            let dest = path_1.default.join(destFolder, file);
+            fs_1.default.renameSync(src, dest);
+        }
+    };
+    /**
+     * Resizes image down to a maximum width/height.
+     */
+    static resizeImage = async (filepath, maxSize = 2000) => {
+        let maxWidth = typeof maxSize === "number" ? maxSize : maxSize.maxWidth;
+        let maxHeight = typeof maxSize === "number" ? maxSize : maxSize.maxHeight;
+        let buffer = new Uint8Array(fs_1.default.readFileSync(filepath));
+        const dim = await (0, sharp_1.default)(buffer).metadata();
+        if (dim.width > maxWidth || dim.height > maxHeight) {
+            buffer = await (0, sharp_1.default)(buffer)
+                .resize(maxWidth, maxHeight, { fit: "inside" })
+                .toBuffer().then((b) => new Uint8Array(b));
+            fs_1.default.writeFileSync(filepath, buffer);
+        }
+        return filepath;
+    };
+    /**
+     * Transparent image check.
+     */
+    static isTransparent = async (filepath) => {
+        const image = (0, sharp_1.default)(filepath);
+        const metadata = await image.metadata();
+        if (!metadata.hasAlpha)
+            return false;
+        const { data, info } = await image.ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+        for (let i = 3; i < data.length; i += info.channels) {
+            if (data[i] === 0)
+                return true;
+        }
+        return false;
+    };
+    /**
+     * Converts image to the specified format. Default is jpg for non-transparent and webp for transparent.
+     */
+    static convertImage = async (filepath, format, formatOptions, transparentFormat, transparentFormatOptions) => {
+        let buffer = fs_1.default.readFileSync(filepath);
+        let newBuffer = null;
+        let targetFormat = format;
+        let targetOptions = formatOptions;
+        if (await this.isTransparent(filepath)) {
+            if (transparentFormat) {
+                targetFormat = transparentFormat;
+                targetOptions = transparentFormatOptions;
+            }
+            else if (!format) {
+                targetFormat = "webp";
+                targetOptions = undefined;
+            }
+        }
+        if (!targetFormat)
+            targetFormat = "jpg";
+        switch (targetFormat) {
+            case "jpg":
+                newBuffer = await (0, sharp_1.default)(buffer).jpeg(targetOptions ?? { quality: 95, optimiseScans: true }).toBuffer();
+                break;
+            case "png":
+                newBuffer = await (0, sharp_1.default)(buffer).png(targetOptions ?? { compressionLevel: 7 }).toBuffer();
+                break;
+            case "webp":
+                newBuffer = await (0, sharp_1.default)(buffer).webp(targetOptions ?? { quality: 90 }).toBuffer();
+                break;
+            case "avif":
+                newBuffer = await (0, sharp_1.default)(buffer).avif(targetOptions ?? { quality: 80, effort: 2 }).toBuffer();
+                break;
+            case "jxl":
+                newBuffer = await (0, sharp_1.default)(buffer).jxl(targetOptions ?? { quality: 90, effort: 4 }).toBuffer();
+                break;
+            default:
+                newBuffer = buffer;
+        }
+        let newFile = `${path_1.default.basename(filepath, path_1.default.extname(filepath))}.${targetFormat}`;
+        const newFilePath = path_1.default.join(path_1.default.dirname(filepath), newFile);
+        fs_1.default.writeFileSync(filepath, newBuffer);
+        fs_1.default.renameSync(filepath, newFilePath);
+        return newFilePath;
+    };
+    /**
+     * Upscale image. Optionally copies unprocessed files (due to an error) to a folder.
+     */
+    static upscaleImage = async (src, destFolder, options, unprocessedFolder = true) => {
+        let dest = path_1.default.join(destFolder, path_1.default.basename(src));
+        let target = src;
+        let isWebp = path_1.default.extname(src) === ".webp";
+        let isAvif = path_1.default.extname(src) === ".avif";
+        let isJxl = path_1.default.extname(src) === ".jxl";
+        if (isWebp || isAvif || isJxl) {
+            fs_1.default.copyFileSync(src, dest);
+            target = await this.convertImage(dest, "png");
+        }
+        let result = await waifu2x_1.default.upscaleImage(target, destFolder, options ?? { rename: "", upscaler: "real-cugan", scale: 4 });
+        if (isWebp) {
+            await this.convertImage(result, "webp");
+        }
+        else if (isAvif) {
+            await this.convertImage(result, "avif");
+        }
+        else if (isJxl) {
+            await this.convertImage(result, "jxl");
+        }
+        if (!fs_1.default.existsSync(dest) && unprocessedFolder) {
+            let unprocfolder = path_1.default.join(path_1.default.dirname(destFolder), "unprocessed");
+            if (!fs_1.default.existsSync(unprocfolder))
+                fs_1.default.mkdirSync(unprocfolder);
+            fs_1.default.copyFileSync(src, path_1.default.join(unprocfolder, path_1.default.basename(src)));
+        }
+        return dest;
+    };
+    /**
+     * Processes an image folder with a custom chain of operations.
+     */
+    static processImages = async (folder, ...operations) => {
+        const files = fs_1.default.readdirSync(folder).filter((f) => f !== ".DS_Store");
+        let i = 1;
+        for (const file of files) {
+            console.log(`${i}/${files.length}  -> ${file}`);
+            let src = path_1.default.join(folder, file);
+            if (fs_1.default.lstatSync(src).isDirectory())
+                continue;
+            for (const operation of operations) {
+                src = await operation(src);
+            }
+            i++;
+        }
+    };
+    /**
+     * Shorthand process images with only a resize.
+     */
+    static resizeImages = (folder, maxSize = 2000) => {
+        return this.processImages(folder, async (file) => this.resizeImage(file, maxSize));
+    };
+    /**
+     * Shorthand process images with only a conversion.
+     */
+    static convertImages = (folder, format = "jpg", formatOptions, transparentFormat = "webp", transparentFormatOptions) => {
+        return this.processImages(folder, async (file) => this.convertImage(file, format, formatOptions, transparentFormat, transparentFormatOptions));
+    };
+    /**
+     * Shorthand process images with only a upscale.
+     */
+    static upscaleImages = (sourceFolder, destFolder, options, unprocessedFolder = true) => {
+        return this.processImages(sourceFolder, async (file) => this.upscaleImage(file, destFolder, options, unprocessedFolder));
+    };
+    /**
+     * Splits up a folder into more manageable chunks.
+     */
+    static splitFolder = (folder, maxAmount = 300) => {
+        const files = fs_1.default.readdirSync(folder).filter((f) => f !== ".DS_Store")
+            .sort(new Intl.Collator(undefined, { numeric: true, sensitivity: "base" }).compare);
+        const chunks = Math.ceil(files.length / maxAmount);
+        for (let i = 0; i < chunks; i++) {
+            const chunkFiles = files.slice(i * maxAmount, (i + 1) * maxAmount);
+            const chunkFolder = path_1.default.join(folder, `${i + 1}`);
+            if (!fs_1.default.existsSync(chunkFolder))
+                fs_1.default.mkdirSync(chunkFolder);
+            for (const file of chunkFiles) {
+                const src = path_1.default.join(folder, file);
+                const dest = path_1.default.join(chunkFolder, file);
+                fs_1.default.renameSync(src, dest);
+            }
+        }
+    };
+    /**
+     * Processes an image folder to be suitable to upload to moepictures.
+     */
+    static moepicsProcess = async (folder) => {
+        const original = path_1.default.join(folder, "original");
+        const compressed = path_1.default.join(folder, "compressed");
+        const upscaled = path_1.default.join(folder, "upscaled");
+        if (!fs_1.default.existsSync(original))
+            fs_1.default.mkdirSync(original);
+        if (!fs_1.default.existsSync(compressed))
+            fs_1.default.mkdirSync(compressed);
+        if (!fs_1.default.existsSync(upscaled))
+            fs_1.default.mkdirSync(upscaled);
+        this.moveImages(folder, original);
+        this.copyImages(original, compressed);
+        console.log("Compressing images...");
+        await this.processImages(compressed, async (file) => this.resizeImage(file), async (file) => this.convertImage(file));
+        console.log("Upscaling images...");
+        await this.processImages(compressed, async (file) => this.upscaleImage(file, upscaled), async (file) => this.convertImage(file, "avif"));
+        this.splitFolder(compressed);
+        this.splitFolder(upscaled);
+    };
+}
+exports.default = ImageUtils;

package/dist/imageutils.d.ts

@@ -0,0 +1,71 @@
+import sharp from "sharp";
+import { Waifu2xOptions } from "waifu2x";
+type Formats = "jpg" | "png" | "webp" | "avif" | "jxl";
+type FormatOptionMap = {
+    jpg: sharp.JpegOptions;
+    png: sharp.PngOptions;
+    webp: sharp.WebpOptions;
+    avif: sharp.AvifOptions;
+    jxl: sharp.JxlOptions;
+};
+export default class ImageUtils {
+    /**
+     * Fixes incorrect image extensions. It must be correct to preview on mac.
+     */
+    static fixFileExtensions: (folder: string) => Promise<void>;
+    /**
+     * Copies images to the destination (unchanged)
+     */
+    static copyImages: (sourceFolder: string, destFolder: string) => void;
+    /**
+     * Moves images to the destination
+     */
+    static moveImages: (sourceFolder: string, destFolder: string) => void;
+    /**
+     * Resizes image down to a maximum width/height.
+     */
+    static resizeImage: (filepath: string, maxSize?: number | {
+        maxWidth: number;
+        maxHeight: number;
+    }) => Promise<string>;
+    /**
+     * Transparent image check.
+     */
+    static isTransparent: (filepath: string) => Promise<boolean>;
+    /**
+     * Converts image to the specified format. Default is jpg for non-transparent and webp for transparent.
+     */
+    static convertImage: <T extends Formats>(filepath: string, format?: T, formatOptions?: FormatOptionMap[T], transparentFormat?: T, transparentFormatOptions?: FormatOptionMap[T]) => Promise<string>;
+    /**
+     * Upscale image. Optionally copies unprocessed files (due to an error) to a folder.
+     */
+    static upscaleImage: <T extends Formats>(src: string, destFolder: string, options?: Waifu2xOptions, unprocessedFolder?: boolean) => Promise<string>;
+    /**
+     * Processes an image folder with a custom chain of operations.
+     */
+    static processImages: <T extends Formats>(folder: string, ...operations: Array<(file: string) => Promise<string>>) => Promise<void>;
+    /**
+     * Shorthand process images with only a resize.
+     */
+    static resizeImages: (folder: string, maxSize?: number | {
+        maxWidth: number;
+        maxHeight: number;
+    }) => Promise<void>;
+    /**
+     * Shorthand process images with only a conversion.
+     */
+    static convertImages: <T extends Formats>(folder: string, format?: T, formatOptions?: FormatOptionMap[T], transparentFormat?: T, transparentFormatOptions?: FormatOptionMap[T]) => Promise<void>;
+    /**
+     * Shorthand process images with only a upscale.
+     */
+    static upscaleImages: <T extends Formats>(sourceFolder: string, destFolder: string, options?: Waifu2xOptions, unprocessedFolder?: boolean) => Promise<void>;
+    /**
+     * Splits up a folder into more manageable chunks.
+     */
+    static splitFolder: (folder: string, maxAmount?: number) => void;
+    /**
+     * Processes an image folder to be suitable to upload to moepictures.
+     */
+    static moepicsProcess: (folder: string) => Promise<void>;
+}
+export {};

package/dist/imageutils.js

@@ -0,0 +1,234 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const sharp_1 = __importDefault(require("sharp"));
+const waifu2x_1 = __importDefault(require("waifu2x"));
+class ImageUtils {
+    /**
+     * Fixes incorrect image extensions. It must be correct to preview on mac.
+     */
+    static fixFileExtensions = async (folder) => {
+        const files = fs_1.default.readdirSync(folder).filter((f) => f !== ".DS_Store");
+        for (const file of files) {
+            let filepath = path_1.default.join(folder, file);
+            if (fs_1.default.lstatSync(filepath).isDirectory())
+                continue;
+            const buffer = fs_1.default.readFileSync(filepath);
+            const meta = await (0, sharp_1.default)(buffer, { limitInputPixels: false }).metadata();
+            let ext = meta.format.replace("jpeg", "jpg");
+            let newFile = `${path_1.default.basename(file, path_1.default.extname(file))}.${ext}`;
+            let newFilePath = path_1.default.join(folder, newFile);
+            fs_1.default.renameSync(filepath, newFilePath);
+        }
+    };
+    /**
+     * Copies images to the destination (unchanged)
+     */
+    static copyImages = (sourceFolder, destFolder) => {
+        const files = fs_1.default.readdirSync(sourceFolder).filter((f) => f !== ".DS_Store");
+        for (const file of files) {
+            let src = path_1.default.join(sourceFolder, file);
+            if (fs_1.default.lstatSync(src).isDirectory())
+                continue;
+            let dest = path_1.default.join(destFolder, file);
+            fs_1.default.copyFileSync(src, dest);
+        }
+    };
+    /**
+     * Moves images to the destination
+     */
+    static moveImages = (sourceFolder, destFolder) => {
+        const files = fs_1.default.readdirSync(sourceFolder).filter((f) => f !== ".DS_Store");
+        for (const file of files) {
+            let src = path_1.default.join(sourceFolder, file);
+            if (fs_1.default.lstatSync(src).isDirectory())
+                continue;
+            let dest = path_1.default.join(destFolder, file);
+            fs_1.default.renameSync(src, dest);
+        }
+    };
+    /**
+     * Resizes image down to a maximum width/height.
+     */
+    static resizeImage = async (filepath, maxSize = 2000) => {
+        let maxWidth = typeof maxSize === "number" ? maxSize : maxSize.maxWidth;
+        let maxHeight = typeof maxSize === "number" ? maxSize : maxSize.maxHeight;
+        let buffer = new Uint8Array(fs_1.default.readFileSync(filepath));
+        const dim = await (0, sharp_1.default)(buffer).metadata();
+        if (dim.width > maxWidth || dim.height > maxHeight) {
+            buffer = await (0, sharp_1.default)(buffer)
+                .resize(maxWidth, maxHeight, { fit: "inside" })
+                .toBuffer().then((b) => new Uint8Array(b));
+            fs_1.default.writeFileSync(filepath, buffer);
+        }
+        return filepath;
+    };
+    /**
+     * Transparent image check.
+     */
+    static isTransparent = async (filepath) => {
+        const image = (0, sharp_1.default)(filepath);
+        const metadata = await image.metadata();
+        if (!metadata.hasAlpha)
+            return false;
+        const { data, info } = await image.ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+        for (let i = 3; i < data.length; i += info.channels) {
+            if (data[i] === 0)
+                return true;
+        }
+        return false;
+    };
+    /**
+     * Converts image to the specified format. Default is jpg for non-transparent and webp for transparent.
+     */
+    static convertImage = async (filepath, format, formatOptions, transparentFormat, transparentFormatOptions) => {
+        let buffer = fs_1.default.readFileSync(filepath);
+        let newBuffer = null;
+        let targetFormat = format;
+        let targetOptions = formatOptions;
+        if (await this.isTransparent(filepath)) {
+            if (transparentFormat) {
+                targetFormat = transparentFormat;
+                targetOptions = transparentFormatOptions;
+            }
+            else if (!format) {
+                targetFormat = "webp";
+                targetOptions = undefined;
+            }
+        }
+        if (!targetFormat)
+            targetFormat = "jpg";
+        switch (targetFormat) {
+            case "jpg":
+                newBuffer = await (0, sharp_1.default)(buffer).jpeg(targetOptions ?? { quality: 95, optimiseScans: true }).toBuffer();
+                break;
+            case "png":
+                newBuffer = await (0, sharp_1.default)(buffer).png(targetOptions ?? { compressionLevel: 7 }).toBuffer();
+                break;
+            case "webp":
+                newBuffer = await (0, sharp_1.default)(buffer).webp(targetOptions ?? { quality: 90 }).toBuffer();
+                break;
+            case "avif":
+                newBuffer = await (0, sharp_1.default)(buffer).avif(targetOptions ?? { quality: 80, effort: 2 }).toBuffer();
+                break;
+            case "jxl":
+                newBuffer = await (0, sharp_1.default)(buffer).jxl(targetOptions ?? { quality: 90, effort: 4 }).toBuffer();
+                break;
+            default:
+                newBuffer = buffer;
+        }
+        let newFile = `${path_1.default.basename(filepath, path_1.default.extname(filepath))}.${targetFormat}`;
+        const newFilePath = path_1.default.join(path_1.default.dirname(filepath), newFile);
+        fs_1.default.writeFileSync(filepath, newBuffer);
+        fs_1.default.renameSync(filepath, newFilePath);
+        return newFilePath;
+    };
+    /**
+     * Upscale image. Optionally copies unprocessed files (due to an error) to a folder.
+     */
+    static upscaleImage = async (src, destFolder, options, unprocessedFolder = true) => {
+        let dest = path_1.default.join(destFolder, path_1.default.basename(src));
+        let target = src;
+        let isWebp = path_1.default.extname(src) === ".webp";
+        let isAvif = path_1.default.extname(src) === ".avif";
+        if (isWebp || isAvif) {
+            fs_1.default.copyFileSync(src, dest);
+            target = await this.convertImage(dest, "png");
+        }
+        let result = await waifu2x_1.default.upscaleImage(target, destFolder, options ?? { rename: "", upscaler: "real-cugan", scale: 4 });
+        if (isWebp) {
+            await this.convertImage(result, "webp");
+        }
+        else if (isAvif) {
+            await this.convertImage(result, "avif");
+        }
+        if (!fs_1.default.existsSync(dest) && unprocessedFolder) {
+            let unprocfolder = path_1.default.join(path_1.default.dirname(destFolder), "unprocessed");
+            if (!fs_1.default.existsSync(unprocfolder))
+                fs_1.default.mkdirSync(unprocfolder);
+            fs_1.default.copyFileSync(src, path_1.default.join(unprocfolder, path_1.default.basename(src)));
+        }
+        return dest;
+    };
+    /**
+     * Processes an image folder with a custom chain of operations.
+     */
+    static processImages = async (folder, ...operations) => {
+        const files = fs_1.default.readdirSync(folder).filter((f) => f !== ".DS_Store");
+        let i = 1;
+        for (const file of files) {
+            console.log(`${i}/${files.length}  -> ${file}`);
+            let src = path_1.default.join(folder, file);
+            if (fs_1.default.lstatSync(src).isDirectory())
+                continue;
+            for (const operation of operations) {
+                src = await operation(src);
+            }
+            i++;
+        }
+    };
+    /**
+     * Shorthand process images with only a resize.
+     */
+    static resizeImages = (folder, maxSize = 2000) => {
+        return this.processImages(folder, async (file) => this.resizeImage(file, maxSize));
+    };
+    /**
+     * Shorthand process images with only a conversion.
+     */
+    static convertImages = (folder, format = "jpg", formatOptions, transparentFormat = "webp", transparentFormatOptions) => {
+        return this.processImages(folder, async (file) => this.convertImage(file, format, formatOptions, transparentFormat, transparentFormatOptions));
+    };
+    /**
+     * Shorthand process images with only a upscale.
+     */
+    static upscaleImages = (sourceFolder, destFolder, options, unprocessedFolder = true) => {
+        return this.processImages(sourceFolder, async (file) => this.upscaleImage(file, destFolder, options, unprocessedFolder));
+    };
+    /**
+     * Splits up a folder into more manageable chunks.
+     */
+    static splitFolder = (folder, maxAmount = 300) => {
+        const files = fs_1.default.readdirSync(folder).filter((f) => f !== ".DS_Store")
+            .sort(new Intl.Collator(undefined, { numeric: true, sensitivity: "base" }).compare);
+        const chunks = Math.ceil(files.length / maxAmount);
+        for (let i = 0; i < chunks; i++) {
+            const chunkFiles = files.slice(i * maxAmount, (i + 1) * maxAmount);
+            const chunkFolder = path_1.default.join(folder, `${i + 1}`);
+            if (!fs_1.default.existsSync(chunkFolder))
+                fs_1.default.mkdirSync(chunkFolder);
+            for (const file of chunkFiles) {
+                const src = path_1.default.join(folder, file);
+                const dest = path_1.default.join(chunkFolder, file);
+                fs_1.default.renameSync(src, dest);
+            }
+        }
+    };
+    /**
+     * Processes an image folder to be suitable to upload to moepictures.
+     */
+    static moepicsProcess = async (folder) => {
+        const original = path_1.default.join(folder, "original");
+        const compressed = path_1.default.join(folder, "compressed");
+        const upscaled = path_1.default.join(folder, "upscaled");
+        if (!fs_1.default.existsSync(original))
+            fs_1.default.mkdirSync(original);
+        if (!fs_1.default.existsSync(compressed))
+            fs_1.default.mkdirSync(compressed);
+        if (!fs_1.default.existsSync(upscaled))
+            fs_1.default.mkdirSync(upscaled);
+        this.moveImages(folder, original);
+        this.copyImages(original, compressed);
+        console.log("Compressing images...");
+        await this.processImages(compressed, async (file) => this.resizeImage(file), async (file) => this.convertImage(file));
+        console.log("Upscaling images...");
+        await this.processImages(compressed, async (file) => this.upscaleImage(file, upscaled), async (file) => this.convertImage(file, "avif"));
+        this.splitFolder(compressed);
+        this.splitFolder(upscaled);
+    };
+}
+exports.default = ImageUtils;

package/dist/pics.d.ts

@@ -0,0 +1 @@
+import "dotenv/config";

package/dist/pics.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("dotenv/config");
+const image_utils_1 = __importDefault(require("./image-utils"));
+const start = async () => {
+    await image_utils_1.default.splitFolder(process.env.FOLDER);
+};
+start();

package/image-utils.ts

@@ -0,0 +1,271 @@
+import fs from "fs"
+import path from "path"
+import sharp from "sharp"
+import waifu2x, {Waifu2xOptions} from "waifu2x"
+
+type Formats = "jpg" | "png" | "webp" | "avif" | "jxl"
+
+type FormatOptionMap = {
+  jpg: sharp.JpegOptions
+  png: sharp.PngOptions
+  webp: sharp.WebpOptions
+  avif: sharp.AvifOptions
+  jxl: sharp.JxlOptions
+}
+
+export default class ImageUtils {
+    /**
+     * Fixes incorrect image extensions. It must be correct to preview on mac.
+     */
+    public static fixFileExtensions = async (folder: string) => {
+        const files = fs.readdirSync(folder).filter((f) => f !== ".DS_Store")
+        for (const file of files) {
+            let filepath = path.join(folder, file)
+            if (fs.lstatSync(filepath).isDirectory()) continue
+            const buffer = fs.readFileSync(filepath)
+            const meta = await sharp(buffer, {limitInputPixels: false}).metadata()
+            let ext = meta.format.replace("jpeg", "jpg")
+            let newFile = `${path.basename(file, path.extname(file))}.${ext}`
+            let newFilePath = path.join(folder, newFile)
+            fs.renameSync(filepath, newFilePath)
+        }
+    }
+
+    /**
+     * Copies images to the destination (unchanged)
+     */
+    public static copyImages = (sourceFolder: string, destFolder: string) => {
+        const files = fs.readdirSync(sourceFolder).filter((f) => f !== ".DS_Store")
+        for (const file of files) {
+            let src = path.join(sourceFolder, file)
+            if (fs.lstatSync(src).isDirectory()) continue
+            let dest = path.join(destFolder, file)
+            fs.copyFileSync(src, dest)
+        }
+    }
+
+    /**
+     * Moves images to the destination
+     */
+    public static moveImages = (sourceFolder: string, destFolder: string) => {
+        const files = fs.readdirSync(sourceFolder).filter((f) => f !== ".DS_Store")
+        for (const file of files) {
+            let src = path.join(sourceFolder, file)
+            if (fs.lstatSync(src).isDirectory()) continue
+            let dest = path.join(destFolder, file)
+            fs.renameSync(src, dest)
+        }
+    }
+
+    /**
+     * Resizes image down to a maximum width/height.
+     */
+    public static resizeImage = async (filepath: string, maxSize: number | {maxWidth: number, maxHeight: number} = 2000) => {
+        let maxWidth = typeof maxSize === "number" ? maxSize : maxSize.maxWidth
+        let maxHeight = typeof maxSize === "number" ? maxSize : maxSize.maxHeight
+        let buffer = new Uint8Array(fs.readFileSync(filepath))
+        const dim = await sharp(buffer).metadata()
+        if (dim.width > maxWidth || dim.height > maxHeight) {
+            buffer = await sharp(buffer)
+            .resize(maxWidth, maxHeight, {fit: "inside"})
+            .toBuffer().then((b) => new Uint8Array(b))
+            fs.writeFileSync(filepath, buffer)
+        }
+        return filepath
+    }
+
+    /**
+     * Transparent image check.
+     */
+    public static isTransparent = async (filepath: string) => {
+        const image = sharp(filepath)
+        const metadata = await image.metadata()
+        if (!metadata.hasAlpha) return false
+
+        const {data, info} = await image.ensureAlpha().raw().toBuffer({resolveWithObject: true})
+
+        for (let i = 3; i < data.length; i += info.channels) {
+            if (data[i] === 0) return true
+        }
+
+        return false
+    }
+
+    /**
+     * Converts image to the specified format. Default is jpg for non-transparent and webp for transparent.
+     */
+    public static convertImage = async <T extends Formats>(filepath: string, format?: T, formatOptions?: FormatOptionMap[T],
+        transparentFormat?: T, transparentFormatOptions?: FormatOptionMap[T]) => {
+        let buffer = fs.readFileSync(filepath)
+        let newBuffer = null as unknown as Buffer
+
+        let targetFormat = format
+        let targetOptions = formatOptions
+        if (await this.isTransparent(filepath)) {
+            if (transparentFormat) {
+                targetFormat = transparentFormat
+                targetOptions = transparentFormatOptions
+            } else if (!format) {
+                targetFormat = "webp" as T
+                targetOptions = undefined
+            }
+        }
+        if (!targetFormat) targetFormat = "jpg" as T
+
+        switch(targetFormat) {
+            case "jpg":
+                newBuffer = await sharp(buffer).jpeg(targetOptions ?? {quality: 95, optimiseScans: true}).toBuffer()
+                break
+            case "png":
+                newBuffer = await sharp(buffer).png(targetOptions ?? {compressionLevel: 7}).toBuffer()
+                break
+            case "webp":
+                newBuffer = await sharp(buffer).webp(targetOptions ?? {quality: 90}).toBuffer()
+                break
+            case "avif":
+                newBuffer = await sharp(buffer).avif(targetOptions ?? {quality: 80, effort: 2}).toBuffer()
+                break
+            case "jxl":
+                newBuffer = await sharp(buffer).jxl(targetOptions ?? {quality: 90, effort: 4}).toBuffer()
+                break
+            default:
+                newBuffer = buffer
+        }
+
+        let newFile = `${path.basename(filepath, path.extname(filepath))}.${targetFormat}`
+        const newFilePath = path.join(path.dirname(filepath), newFile)
+        fs.writeFileSync(filepath, newBuffer)
+        fs.renameSync(filepath, newFilePath)
+        return newFilePath
+    }
+
+    /**
+     * Upscale image. Optionally copies unprocessed files (due to an error) to a folder.
+     */
+    public static upscaleImage = async <T extends Formats>(src: string, destFolder: string, 
+        options?: Waifu2xOptions, unprocessedFolder: boolean = true) => {
+        let dest = path.join(destFolder, path.basename(src))
+
+        let target = src
+        let isWebp = path.extname(src) === ".webp"
+        let isAvif = path.extname(src) === ".avif"
+        let isJxl = path.extname(src) === ".jxl"
+        if (isWebp || isAvif || isJxl) {
+            fs.copyFileSync(src, dest)
+            target = await this.convertImage(dest, "png")
+        }
+
+        let result = await waifu2x.upscaleImage(target, destFolder, options ?? {rename: "", upscaler: "real-cugan", scale: 4})
+        if (isWebp) {
+            await this.convertImage(result, "webp")
+        } else if (isAvif) {
+            await this.convertImage(result, "avif")
+        } else if (isJxl) {
+            await this.convertImage(result, "jxl")
+        }
+
+        if (!fs.existsSync(dest) && unprocessedFolder) {
+            let unprocfolder = path.join(path.dirname(destFolder), "unprocessed")
+            if (!fs.existsSync(unprocfolder)) fs.mkdirSync(unprocfolder)
+            fs.copyFileSync(src, path.join(unprocfolder, path.basename(src)))
+        }
+        return dest
+    }
+
+    /**
+     * Processes an image folder with a custom chain of operations.
+     */
+    public static processImages = async <T extends Formats>(folder: string, 
+        ...operations: Array<(file: string) => Promise<string>>) => {
+        const files = fs.readdirSync(folder).filter((f) => f !== ".DS_Store")
+        let i = 1
+        for (const file of files) {
+            console.log(`${i}/${files.length}  -> ${file}`)
+            let src = path.join(folder, file)
+            if (fs.lstatSync(src).isDirectory()) continue
+            for (const operation of operations) {
+                src = await operation(src)
+            }
+            i++
+        }
+    }
+
+    /**
+     * Shorthand process images with only a resize.
+     */
+    public static resizeImages = (folder: string, maxSize: number | {maxWidth: number, maxHeight: number} = 2000) => {
+        return this.processImages(folder, 
+            async (file) => this.resizeImage(file, maxSize)
+        )
+    }
+
+    /**
+     * Shorthand process images with only a conversion. 
+     */
+    public static convertImages = <T extends Formats>(folder: string, format = "jpg" as T, formatOptions?: FormatOptionMap[T], 
+        transparentFormat = "webp" as T, transparentFormatOptions?: FormatOptionMap[T]) => {
+        return this.processImages(folder, 
+            async (file) => this.convertImage(file, format, formatOptions, transparentFormat, transparentFormatOptions)
+        )
+    }
+
+    /**
+     * Shorthand process images with only a upscale. 
+     */
+    public static upscaleImages = <T extends Formats>(sourceFolder: string, destFolder: string, 
+        options?: Waifu2xOptions, unprocessedFolder: boolean = true) => {
+        return this.processImages(sourceFolder, 
+            async (file) => this.upscaleImage(file, destFolder, options, unprocessedFolder)
+        )
+    }
+
+    /**
+     * Splits up a folder into more manageable chunks.
+     */
+    public static splitFolder = (folder: string, maxAmount: number = 300) => {
+        const files = fs.readdirSync(folder).filter((f) => f !== ".DS_Store")
+        .sort(new Intl.Collator(undefined, {numeric: true, sensitivity: "base"}).compare)
+
+        const chunks = Math.ceil(files.length / maxAmount)
+        
+        for (let i = 0; i < chunks; i++) {
+            const chunkFiles = files.slice(i * maxAmount, (i + 1) * maxAmount)
+            const chunkFolder = path.join(folder, `${i + 1}`)
+            if (!fs.existsSync(chunkFolder)) fs.mkdirSync(chunkFolder)
+
+            for (const file of chunkFiles) {
+                const src = path.join(folder, file)
+                const dest = path.join(chunkFolder, file)
+                fs.renameSync(src, dest)
+            }
+        }
+    }
+
+    /**
+     * Processes an image folder to be suitable to upload to moepictures.
+     */
+    public static moepicsProcess = async (folder: string) => {
+        const original = path.join(folder, "original")
+        const compressed = path.join(folder, "compressed")
+        const upscaled = path.join(folder, "upscaled")
+        if (!fs.existsSync(original)) fs.mkdirSync(original)
+        if (!fs.existsSync(compressed)) fs.mkdirSync(compressed)
+        if (!fs.existsSync(upscaled)) fs.mkdirSync(upscaled)
+
+        this.moveImages(folder, original)
+        this.copyImages(original, compressed)
+        console.log("Compressing images...")
+        await this.processImages(compressed, 
+            async (file) => this.resizeImage(file),
+            async (file) => this.convertImage(file)
+        )
+        console.log("Upscaling images...")
+        await this.processImages(compressed, 
+            async (file) => this.upscaleImage(file, upscaled),
+            async (file) => this.convertImage(file, "avif")
+        )
+
+        this.splitFolder(compressed)
+        this.splitFolder(upscaled)
+    }
+}

package/license.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Moebytes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "animepic-utils",
+  "version": "0.0.1",
+  "description": "Node.js utils for processing anime images",
+  "main": "dist/image-utils.js",
+  "types": "dist/image-utils.d.ts",
+  "scripts": {
+    "start": "tsc && node dist/pics.js",
+    "clean": "del-cli ./dist",
+    "prepublishOnly": "tsc"
+  },
+  "keywords": ["anime", "image", "utils"],
+  "author": "Moebytes",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^24.7.2",
+    "del-cli": "^7.0.0",
+    "dotenv": "^17.2.3",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "sharp": "^0.34.4",
+    "waifu2x": "^1.5.1"
+  }
+}

package/pics.ts

@@ -0,0 +1,8 @@
+import "dotenv/config"
+import imageUtils from "./image-utils"
+
+const start = async () => {
+    await imageUtils.splitFolder(process.env.FOLDER!)
+}
+
+start()

package/readme.md

@@ -0,0 +1,38 @@
+## Animepic Utils
+
+Some utilities for processing anime images. (However I guess it'll work for any images).
+
+The primary function is `processImages` that accepts a folder of images, and then a variable 
+amount of processing functions that will be applied to every image in the folder. The processing functions 
+should take the current file parameter and return the path to the output, this is then fed back as the 
+"file" argument to the next function in the chain. See below for an example of using it.
+
+```ts
+import imageUtils from "animepic-utils"
+
+await imageUtils.processImages(folder, 
+    async (file) => this.resizeImage(file),
+    async (file) => this.convertImage(file),
+    async (file) => this.upscaleImage(file, upscaledFolder)
+)
+```
+
+We already have functions for resizing, conversion, and upscaling, but you can continue to write your 
+own if you wish. Apart from image processing, there is the `fixFileExtensions` function that will correct 
+the file extensions of all the images in a folder. On macOS, the extensions have to be correct in order for 
+the file to preview in finder, so a png cannot have the jpg extension.
+
+```ts
+import imageUtils from "animepic-utils"
+
+await imageUtils.fixFileExtensions(folder)
+```
+
+Lastly, the function `moepicsProcess` will takes a folder of anime images and will generate the compressed 
+and upscaled versions that are suitable to upload to my website, https://moepictures.moe. 
+
+```ts
+import imageUtils from "animepic-utils"
+
+await imageUtils.moepicsProcess(folder)
+```

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+    "compilerOptions": {
+        "outDir": "dist",
+        "declaration": true,
+        "noImplicitAny": false,
+        "moduleResolution": "node",
+        "target": "es2023",
+        "module": "commonjs",
+        "lib": ["es2023", "dom"],
+        "allowJs": true,
+        "allowSyntheticDefaultImports": true,
+        "jsx": "react-jsx",
+        "esModuleInterop": true,
+        "strict": true,
+        "strictNullChecks": true,
+        "skipLibCheck": true,
+        "resolveJsonModule": true
+    },
+    "exclude": [
+        "node_modules",
+        "dist"
+    ]
+}