@filen/utils 0.0.1

package/dist/cn.js

@@ -0,0 +1,5 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+export function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}

package/dist/index.js

@@ -0,0 +1,7 @@
+export * from "./cn";
+export * from "./run";
+export * from "./semaphore";
+export * from "./serialize";
+export * from "./types";
+export * from "./misc";
+export * from "./time";

package/dist/misc.js

@@ -0,0 +1,311 @@
+import { validate as validateUUID } from "uuid";
+export function parseNumbersFromString(string) {
+    if (!string) {
+        return 0;
+    }
+    const len = string.length;
+    if (len < 10) {
+        let result = 0;
+        let hasDigit = false;
+        for (let i = 0; i < len; i++) {
+            const code = string.charCodeAt(i);
+            if (code >= 48 && code <= 57) {
+                result = result * 10 + (code - 48);
+                hasDigit = true;
+            }
+        }
+        return hasDigit ? result : 0;
+    }
+    let result = 0;
+    let digitCount = 0;
+    const maxDigits = 16;
+    for (let i = 0; i < len && digitCount < maxDigits; i++) {
+        const code = string.charCodeAt(i);
+        if (code >= 48 && code <= 57) {
+            result = result * 10 + (code - 48);
+            digitCount++;
+        }
+    }
+    return result;
+}
+export function convertTimestampToMs(timestamp) {
+    if (timestamp < 10000000000) {
+        return timestamp * 1000;
+    }
+    return timestamp;
+}
+export function isValidHexColor(value, length = 6) {
+    if (value.length !== (length >= 6 ? 7 : 4) && value.length !== 7) {
+        return false;
+    }
+    if (value.charCodeAt(0) !== 35) {
+        return false;
+    }
+    const len = value.length;
+    for (let i = 1; i < len; i++) {
+        const code = value.charCodeAt(i);
+        if (!((code >= 48 && code <= 57) || (code >= 65 && code <= 70) || (code >= 97 && code <= 102))) {
+            return false;
+        }
+    }
+    return true;
+}
+export function chunkArray(array, chunkSize) {
+    const chunks = [];
+    for (let i = 0; i < array.length; i += chunkSize) {
+        chunks.push(array.slice(i, i + chunkSize));
+    }
+    return chunks;
+}
+export function sanitizeFileName(filename, replacement = "_") {
+    let sanitizedFilename = filename.normalize("NFC");
+    sanitizedFilename = sanitizedFilename.replace(/[\u200B-\u200D\uFEFF\u00AD\u0000-\u001F\u007F-\u009F]/g, "");
+    sanitizedFilename = sanitizedFilename.replace(/[^\x00-\x7F]/g, replacement);
+    const illegalCharsWindows = /[<>:"/\\|?*]/g;
+    const illegalCharsUnix = /\//g;
+    const reservedNamesWindows = new Set([
+        "CON",
+        "PRN",
+        "AUX",
+        "NUL",
+        "COM1",
+        "COM2",
+        "COM3",
+        "COM4",
+        "COM5",
+        "COM6",
+        "COM7",
+        "COM8",
+        "COM9",
+        "LPT1",
+        "LPT2",
+        "LPT3",
+        "LPT4",
+        "LPT5",
+        "LPT6",
+        "LPT7",
+        "LPT8",
+        "LPT9"
+    ]);
+    sanitizedFilename = sanitizedFilename.replace(illegalCharsWindows, replacement);
+    sanitizedFilename = sanitizedFilename.replace(illegalCharsUnix, replacement);
+    sanitizedFilename = sanitizedFilename.replace(/[. ]+$/, "");
+    sanitizedFilename = sanitizedFilename.replace(/\s+/g, replacement);
+    if (reservedNamesWindows.has(sanitizedFilename.toUpperCase())) {
+        sanitizedFilename += replacement;
+    }
+    const maxByteLength = 255;
+    let byteLength = new TextEncoder().encode(sanitizedFilename).length;
+    while (byteLength > maxByteLength && sanitizedFilename.length > 0) {
+        sanitizedFilename = sanitizedFilename.slice(0, -1);
+        byteLength = new TextEncoder().encode(sanitizedFilename).length;
+    }
+    if (!sanitizedFilename) {
+        return "file";
+    }
+    return sanitizedFilename;
+}
+export function findClosestIndexString(sourceString, targetString, givenIndex) {
+    const extractedSubstring = sourceString.slice(0, givenIndex + 1);
+    const lastIndexWithinExtracted = extractedSubstring.lastIndexOf(targetString);
+    if (lastIndexWithinExtracted !== -1) {
+        return lastIndexWithinExtracted;
+    }
+    for (let offset = 1; offset <= givenIndex; offset++) {
+        const substringBefore = sourceString.slice(givenIndex - offset, givenIndex + 1);
+        const lastIndexBefore = substringBefore.lastIndexOf(targetString);
+        if (lastIndexBefore !== -1) {
+            return givenIndex - offset + lastIndexBefore;
+        }
+    }
+    return -1;
+}
+export const URL_REGEX = /https?:\/\/(?:www\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z0-9()]{1,64}\b(?:[-a-zA-Z0-9()@:%_+.~#?&//=]*)/gi;
+export function extractLinksFromString(text) {
+    if (!text) {
+        return [];
+    }
+    const matches = text.matchAll(URL_REGEX);
+    const results = [];
+    for (const match of matches) {
+        if (match[0]) {
+            results.push(match[0]);
+        }
+    }
+    return results;
+}
+export function parseYouTubeVideoId(url) {
+    const regExp = /(?:\?v=|\/embed\/|\/watch\?v=|\/\w+\/\w+\/|youtu.be\/)([\w-]{11})/;
+    const match = url.match(regExp);
+    if (match && match.length === 2 && match[1]) {
+        return match[1];
+    }
+    return null;
+}
+export function parseFilenPublicLink(url) {
+    if (!url || url.length === 0) {
+        return null;
+    }
+    const filenRegex = /https?:\/\/(?:app|drive)\.filen\.io\/#\/([df])\/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})(?:%23|#)([A-Za-z0-9]{32,})/;
+    const match = filenRegex.exec(url);
+    if (!match || match.length < 4 || !match[1] || !match[2] || !match[3]) {
+        return null;
+    }
+    const pathType = match[1];
+    const uuid = match[2];
+    let key = match[3];
+    if (/^[0-9A-Fa-f]{64}$/.test(key)) {
+        try {
+            key = Buffer.from(key, "hex").toString("utf8");
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    if (Buffer.from(key).length !== 32 || !validateUUID(uuid) || (pathType !== "d" && pathType !== "f")) {
+        return null;
+    }
+    return {
+        uuid,
+        key,
+        type: pathType === "d" ? "file" : "directory"
+    };
+}
+export function parseXStatusId(url) {
+    const ex = url.split("/");
+    const part = ex[ex.length - 1];
+    if (!part) {
+        return "";
+    }
+    return part.trim();
+}
+export function ratePasswordStrength(password) {
+    const hasUppercase = /[A-Z]/.test(password);
+    const hasLowercase = /[a-z]/.test(password);
+    const hasSpecialChars = /[!@#$%^&*(),.?":{}|<>]/.test(password);
+    const length = password.length;
+    let strength = "weak";
+    if (length >= 10 && hasUppercase && hasLowercase && hasSpecialChars) {
+        if (length >= 16) {
+            strength = "best";
+        }
+        else {
+            strength = "strong";
+        }
+    }
+    else if (length >= 10 && ((hasUppercase && hasLowercase) || (hasUppercase && hasSpecialChars) || (hasLowercase && hasSpecialChars))) {
+        strength = "normal";
+    }
+    return {
+        strength,
+        uppercase: hasUppercase,
+        lowercase: hasLowercase,
+        specialChars: hasSpecialChars,
+        length: length >= 10
+    };
+}
+export function sortParams(params) {
+    const keys = Object.keys(params).sort();
+    const len = keys.length;
+    const result = {};
+    for (let i = 0; i < len; i++) {
+        const key = keys[i];
+        result[key] = params[key];
+    }
+    return result;
+}
+export function jsonBigIntReplacer(_, value) {
+    if (typeof value === "bigint") {
+        return `$bigint:${value.toString()}n`;
+    }
+    return value;
+}
+export function jsonBigIntReviver(_, value) {
+    if (typeof value === "string" && value.startsWith("$bigint:") && value.endsWith("n")) {
+        return BigInt(value.substring(8, -1));
+    }
+    return value;
+}
+export function createExecutableTimeout(callback, delay) {
+    let timeoutId = setTimeout(callback, delay);
+    return {
+        id: timeoutId,
+        execute: () => {
+            if (timeoutId !== null) {
+                clearTimeout(timeoutId);
+                timeoutId = null;
+            }
+            callback();
+        },
+        cancel: () => {
+            if (timeoutId !== null) {
+                clearTimeout(timeoutId);
+                timeoutId = null;
+            }
+        }
+    };
+}
+export function fastLocaleCompare(a, b) {
+    if (a === b) {
+        return 0;
+    }
+    const lenA = a.length;
+    const lenB = b.length;
+    let idxA = 0;
+    let idxB = 0;
+    let caseDiff = 0;
+    while (idxA < lenA && idxB < lenB) {
+        const charA = a.charCodeAt(idxA);
+        const charB = b.charCodeAt(idxB);
+        const isDigitA = charA >= 48 && charA <= 57;
+        const isDigitB = charB >= 48 && charB <= 57;
+        if (isDigitA && isDigitB) {
+            let numA = 0;
+            let numB = 0;
+            while (idxA < lenA) {
+                const c = a.charCodeAt(idxA);
+                if (c < 48 || c > 57) {
+                    break;
+                }
+                numA = numA * 10 + (c - 48);
+                idxA++;
+            }
+            while (idxB < lenB) {
+                const c = b.charCodeAt(idxB);
+                if (c < 48 || c > 57) {
+                    break;
+                }
+                numB = numB * 10 + (c - 48);
+                idxB++;
+            }
+            if (numA !== numB) {
+                return numA < numB ? -1 : 1;
+            }
+        }
+        else if (isDigitA) {
+            return -1;
+        }
+        else if (isDigitB) {
+            return 1;
+        }
+        else {
+            const lowerA = charA >= 65 && charA <= 90 ? charA + 32 : charA;
+            const lowerB = charB >= 65 && charB <= 90 ? charB + 32 : charB;
+            if (lowerA !== lowerB) {
+                return lowerA < lowerB ? -1 : 1;
+            }
+            if (caseDiff === 0 && charA !== charB) {
+                caseDiff = charA > charB ? -1 : 1;
+            }
+            idxA++;
+            idxB++;
+        }
+    }
+    if (idxA < lenA) {
+        return 1;
+    }
+    if (idxB < lenB) {
+        return -1;
+    }
+    return caseDiff;
+}

package/dist/run.js

@@ -0,0 +1,294 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export function run(fn, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        const deferredFunctions = [];
+        const defer = deferFn => {
+            deferredFunctions.push(deferFn);
+        };
+        try {
+            const result = yield fn(defer);
+            return {
+                success: true,
+                data: result,
+                error: null
+            };
+        }
+        catch (e) {
+            const error = e instanceof Error ? e : new Error("Unknown error");
+            (_a = options === null || options === void 0 ? void 0 : options.onError) === null || _a === void 0 ? void 0 : _a.call(options, error);
+            if (options === null || options === void 0 ? void 0 : options.throw) {
+                throw error;
+            }
+            return {
+                success: false,
+                data: null,
+                error: error
+            };
+        }
+        finally {
+            for (let i = deferredFunctions.length - 1; i >= 0; i--) {
+                try {
+                    yield ((_b = deferredFunctions[i]) === null || _b === void 0 ? void 0 : _b.call(deferredFunctions));
+                }
+                catch (e) {
+                    (_c = options === null || options === void 0 ? void 0 : options.onError) === null || _c === void 0 ? void 0 : _c.call(options, e instanceof Error ? e : new Error("Unknown error"));
+                }
+            }
+        }
+    });
+}
+export class AbortError extends Error {
+    constructor(message = "Operation aborted") {
+        super(message);
+        this.name = "AbortError";
+    }
+}
+export function abortSignalReason(signal) {
+    try {
+        if (signal.reason instanceof Error) {
+            return signal.reason.message;
+        }
+        else if (typeof signal.reason === "string") {
+            return signal.reason;
+        }
+        else if (signal.reason !== undefined) {
+            return String(signal.reason);
+        }
+        return undefined;
+    }
+    catch (_a) {
+        return undefined;
+    }
+}
+export function runAbortable(fn, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const deferredFunctions = [];
+        const controller = (_a = options === null || options === void 0 ? void 0 : options.controller) !== null && _a !== void 0 ? _a : new AbortController();
+        const signal = (_d = (_b = options === null || options === void 0 ? void 0 : options.signal) !== null && _b !== void 0 ? _b : (_c = options === null || options === void 0 ? void 0 : options.controller) === null || _c === void 0 ? void 0 : _c.signal) !== null && _d !== void 0 ? _d : controller.signal;
+        const defer = deferFn => {
+            deferredFunctions.push(deferFn);
+        };
+        const abortable = (abortableFn, opts) => __awaiter(this, void 0, void 0, function* () {
+            if (signal.aborted) {
+                throw new AbortError(abortSignalReason(signal));
+            }
+            return yield new Promise((resolve, reject) => {
+                ;
+                (() => __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    const signal = (_a = opts === null || opts === void 0 ? void 0 : opts.signal) !== null && _a !== void 0 ? _a : controller.signal;
+                    const abortHandler = () => {
+                        reject(new AbortError(abortSignalReason(signal)));
+                    };
+                    signal.addEventListener("abort", abortHandler);
+                    try {
+                        if (signal.aborted) {
+                            reject(new AbortError(abortSignalReason(signal)));
+                            return;
+                        }
+                        const result = yield abortableFn();
+                        if (signal.aborted) {
+                            reject(new AbortError(abortSignalReason(signal)));
+                            return;
+                        }
+                        resolve(result);
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                    finally {
+                        signal.removeEventListener("abort", abortHandler);
+                    }
+                }))();
+            });
+        });
+        try {
+            if (signal.aborted) {
+                throw new AbortError(abortSignalReason(signal));
+            }
+            const result = yield fn({
+                abortable,
+                defer,
+                signal,
+                controller
+            });
+            if (signal.aborted) {
+                throw new AbortError(abortSignalReason(signal));
+            }
+            return {
+                success: true,
+                data: result,
+                error: null
+            };
+        }
+        catch (e) {
+            const error = e instanceof Error ? e : new Error("Unknown error");
+            (_e = options === null || options === void 0 ? void 0 : options.onError) === null || _e === void 0 ? void 0 : _e.call(options, error);
+            if (options === null || options === void 0 ? void 0 : options.throw) {
+                throw error;
+            }
+            return {
+                success: false,
+                data: null,
+                error: error
+            };
+        }
+        finally {
+            for (let i = deferredFunctions.length - 1; i >= 0; i--) {
+                try {
+                    yield ((_f = deferredFunctions[i]) === null || _f === void 0 ? void 0 : _f.call(deferredFunctions));
+                }
+                catch (e) {
+                    (_g = options === null || options === void 0 ? void 0 : options.onError) === null || _g === void 0 ? void 0 : _g.call(options, e instanceof Error ? e : new Error("Unknown error"));
+                }
+            }
+        }
+    });
+}
+export function runEffect(fn, options) {
+    var _a;
+    const deferredFunctions = [];
+    const defer = deferFn => {
+        deferredFunctions.push(deferFn);
+    };
+    const cleanup = () => {
+        var _a, _b;
+        for (let i = deferredFunctions.length - 1; i >= 0; i--) {
+            try {
+                (_a = deferredFunctions[i]) === null || _a === void 0 ? void 0 : _a.call(deferredFunctions);
+            }
+            catch (e) {
+                (_b = options === null || options === void 0 ? void 0 : options.onError) === null || _b === void 0 ? void 0 : _b.call(options, e instanceof Error ? e : new Error("Unknown error"));
+            }
+        }
+    };
+    try {
+        const result = fn(defer);
+        return {
+            success: true,
+            data: result,
+            error: null,
+            cleanup
+        };
+    }
+    catch (e) {
+        const error = e instanceof Error ? e : new Error("Unknown error");
+        (_a = options === null || options === void 0 ? void 0 : options.onError) === null || _a === void 0 ? void 0 : _a.call(options, error);
+        if (options === null || options === void 0 ? void 0 : options.throw) {
+            throw error;
+        }
+        return {
+            success: false,
+            data: null,
+            error: error,
+            cleanup
+        };
+    }
+    finally {
+        if (options === null || options === void 0 ? void 0 : options.automaticCleanup) {
+            cleanup();
+        }
+    }
+}
+export function runRetry(fn, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d;
+        const maxAttempts = (_a = options === null || options === void 0 ? void 0 : options.maxAttempts) !== null && _a !== void 0 ? _a : 3;
+        const delayMs = (_b = options === null || options === void 0 ? void 0 : options.delayMs) !== null && _b !== void 0 ? _b : 1000;
+        const backoff = (_c = options === null || options === void 0 ? void 0 : options.backoff) !== null && _c !== void 0 ? _c : "exponential";
+        let lastError = null;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            const result = yield run(defer => fn(defer, attempt), Object.assign(Object.assign({}, options), { throw: false }));
+            if (result.success) {
+                return result;
+            }
+            lastError = result.error;
+            if (attempt < maxAttempts) {
+                const shouldRetry = typeof (options === null || options === void 0 ? void 0 : options.shouldRetry) === "boolean"
+                    ? options.shouldRetry
+                    : options && typeof options.shouldRetry === "function"
+                        ? options.shouldRetry(result.error, attempt)
+                        : true;
+                if (!shouldRetry) {
+                    break;
+                }
+                (_d = options === null || options === void 0 ? void 0 : options.onRetry) === null || _d === void 0 ? void 0 : _d.call(options, result.error, attempt);
+                const delay = backoff === "exponential" ? delayMs * Math.pow(2, attempt - 1) : delayMs * attempt;
+                yield new Promise(resolve => setTimeout(resolve, delay));
+            }
+        }
+        return {
+            success: false,
+            data: null,
+            error: lastError
+        };
+    });
+}
+export class TimeoutError extends Error {
+    constructor(message = "Operation timed out") {
+        super(message);
+        this.name = "TimeoutError";
+    }
+}
+export function runTimeout(fn, timeoutMs, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const controller = new AbortController();
+        try {
+            const result = yield Promise.race([
+                run(fn, options),
+                new Promise((_, reject) => {
+                    const timeoutId = setTimeout(() => {
+                        controller.abort();
+                        reject(new TimeoutError(`Operation timed out after ${timeoutMs}ms`));
+                    }, timeoutMs);
+                    controller.signal.addEventListener("abort", () => clearTimeout(timeoutId));
+                })
+            ]);
+            return result;
+        }
+        catch (e) {
+            const error = e instanceof Error ? e : new Error("Unknown error");
+            (_a = options === null || options === void 0 ? void 0 : options.onError) === null || _a === void 0 ? void 0 : _a.call(options, error);
+            if (options === null || options === void 0 ? void 0 : options.throw) {
+                throw error;
+            }
+            return {
+                success: false,
+                data: null,
+                error: error
+            };
+        }
+    });
+}
+export function runDebounced(fn, delayMs, options) {
+    let timeoutId = null;
+    let pendingPromise = null;
+    return (...args) => {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+        if (!pendingPromise) {
+            pendingPromise = new Promise(resolve => {
+                timeoutId = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                    const result = yield run(defer => fn(defer, ...args), options);
+                    resolve(result);
+                    pendingPromise = null;
+                    timeoutId = null;
+                }), delayMs);
+            });
+        }
+        return pendingPromise;
+    };
+}
+export default run;

package/dist/semaphore.js

@@ -0,0 +1,52 @@
+export class Semaphore {
+    constructor(max = 1) {
+        this.counter = 0;
+        this.waiting = [];
+        this.maxCount = max;
+    }
+    acquire() {
+        if (this.counter < this.maxCount) {
+            this.counter++;
+            return Promise.resolve();
+        }
+        return new Promise((resolve, reject) => {
+            this.waiting.push({
+                resolve,
+                reject
+            });
+        });
+    }
+    release() {
+        if (this.counter <= 0) {
+            return;
+        }
+        this.counter--;
+        this.processQueue();
+    }
+    count() {
+        return this.counter;
+    }
+    setMax(newMax) {
+        this.maxCount = newMax;
+        this.processQueue();
+    }
+    purge() {
+        const unresolved = this.waiting.length;
+        for (const waiter of this.waiting) {
+            waiter.reject("Task has been purged");
+        }
+        this.counter = 0;
+        this.waiting = [];
+        return unresolved;
+    }
+    processQueue() {
+        if (this.waiting.length > 0 && this.counter < this.maxCount) {
+            this.counter++;
+            const waiter = this.waiting.shift();
+            if (waiter) {
+                waiter.resolve();
+            }
+        }
+    }
+}
+export default Semaphore;

package/dist/serialize.js

@@ -0,0 +1,15 @@
+export function serializeError(error) {
+    return {
+        name: error.name,
+        message: error.message,
+        stack: error.stack,
+        stringified: JSON.stringify(error)
+    };
+}
+export function deserializeError(serializedError) {
+    const error = new Error(serializedError.message);
+    error.name = serializedError.name;
+    error.stack = serializedError.stack;
+    error.message = serializedError.message;
+    return error;
+}

package/dist/time.js

@@ -0,0 +1,68 @@
+export function isTimestampSameDay(timestamp1, timestamp2) {
+    const diff = timestamp1 - timestamp2;
+    if (diff >= -86400000 && diff <= 86400000) {
+        const day1 = Math.floor(timestamp1 / 86400000);
+        const day2 = Math.floor(timestamp2 / 86400000);
+        if (day1 === day2) {
+            return true;
+        }
+    }
+    const date1 = new Date(timestamp1);
+    const date2 = new Date(timestamp2);
+    return date1.getFullYear() === date2.getFullYear() && date1.getMonth() === date2.getMonth() && date1.getDate() === date2.getDate();
+}
+export function isTimestampSameMinute(timestamp1, timestamp2) {
+    const diff = Math.abs(timestamp1 - timestamp2);
+    if (diff > 120000) {
+        return false;
+    }
+    const date1 = new Date(timestamp1);
+    const date2 = new Date(timestamp2);
+    if (date1.getFullYear() !== date2.getFullYear() ||
+        date1.getMonth() !== date2.getMonth() ||
+        date1.getDate() !== date2.getDate() ||
+        date1.getHours() !== date2.getHours()) {
+        return false;
+    }
+    const minuteDiff = Math.abs(date1.getMinutes() - date2.getMinutes());
+    return minuteDiff <= 2;
+}
+export function formatSecondsToHHMM(seconds) {
+    if (seconds < 0 || seconds !== seconds) {
+        return "00:00";
+    }
+    const hours = (seconds / 3600) | 0;
+    const minutes = ((seconds % 3600) / 60) | 0;
+    const h1 = (hours / 10) | 0;
+    const h2 = hours % 10;
+    const m1 = (minutes / 10) | 0;
+    const m2 = minutes % 10;
+    return String(h1) + h2 + ":" + m1 + m2;
+}
+export function formatSecondsToMMSS(seconds) {
+    if (seconds < 0 || seconds !== seconds) {
+        return "00:00";
+    }
+    const minutes = (seconds / 60) | 0;
+    const remainingSeconds = seconds % 60 | 0;
+    const m1 = (minutes / 10) | 0;
+    const m2 = minutes % 10;
+    const s1 = (remainingSeconds / 10) | 0;
+    const s2 = remainingSeconds % 10;
+    return String(m1) + m2 + ":" + s1 + s2;
+}
+export function getTimeRemaining(endTimestamp) {
+    const total = endTimestamp - Date.now();
+    const totalSeconds = (total / 1000) | 0;
+    const days = (totalSeconds / 86400) | 0;
+    const hours = ((totalSeconds % 86400) / 3600) | 0;
+    const minutes = ((totalSeconds % 3600) / 60) | 0;
+    const seconds = totalSeconds % 60;
+    return {
+        total,
+        days,
+        hours,
+        minutes,
+        seconds
+    };
+}

package/dist/types/cn.d.ts

@@ -0,0 +1,2 @@
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;

package/dist/types/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./cn";
+export * from "./run";
+export * from "./semaphore";
+export * from "./serialize";
+export * from "./types";
+export * from "./misc";
+export * from "./time";

package/dist/types/misc.d.ts

@@ -0,0 +1,31 @@
+export declare function parseNumbersFromString(string: string): number;
+export declare function convertTimestampToMs(timestamp: number): number;
+export declare function isValidHexColor(value: string, length?: number): boolean;
+export declare function chunkArray<T>(array: T[], chunkSize: number): T[][];
+export declare function sanitizeFileName(filename: string, replacement?: string): string;
+export declare function findClosestIndexString(sourceString: string, targetString: string, givenIndex: number): number;
+export declare const URL_REGEX: RegExp;
+export declare function extractLinksFromString(text: string): string[];
+export declare function parseYouTubeVideoId(url: string): string | null;
+export declare function parseFilenPublicLink(url: string): {
+    uuid: string;
+    key: string;
+    type: "file" | "directory";
+} | null;
+export declare function parseXStatusId(url: string): string;
+export declare function ratePasswordStrength(password: string): {
+    strength: "weak" | "normal" | "strong" | "best";
+    uppercase: boolean;
+    lowercase: boolean;
+    specialChars: boolean;
+    length: boolean;
+};
+export declare function sortParams<T extends Record<string, unknown>>(params: T): T;
+export declare function jsonBigIntReplacer(_: string, value: unknown): unknown;
+export declare function jsonBigIntReviver(_: string, value: unknown): unknown;
+export declare function createExecutableTimeout(callback: () => void, delay?: number): {
+    id: NodeJS.Timeout;
+    execute: () => void;
+    cancel: () => void;
+};
+export declare function fastLocaleCompare(a: string, b: string): number;

package/dist/types/run.d.ts

@@ -0,0 +1,54 @@
+export type Success<T> = {
+    success: true;
+    data: T;
+    error: null;
+};
+export type Failure<E = Error> = {
+    success: false;
+    data: null;
+    error: E;
+};
+export type Result<T, E = Error> = Success<T> | Failure<E>;
+export type GenericFnResult = number | boolean | string | object | null | undefined | symbol | bigint | void | Promise<number | boolean | string | object | null | undefined | symbol | bigint | void> | Array<number | boolean | string | object | null | undefined | symbol | bigint | void>;
+export type DeferFn = (fn: () => GenericFnResult) => void;
+export type DeferredFunction = () => GenericFnResult;
+export type DeferredFunctions = Array<DeferredFunction>;
+export type Options = {
+    throw?: boolean;
+    onError?: (err: Error) => void;
+};
+export declare function run<TResult, E = Error>(fn: (deferFn: DeferFn) => Promise<TResult> | TResult, options?: Options): Promise<Result<TResult, E>>;
+export type AbortableFn = (abortableFn: () => GenericFnResult, opts?: {
+    signal?: AbortSignal;
+}) => GenericFnResult;
+export declare class AbortError extends Error {
+    constructor(message?: string);
+}
+export declare function abortSignalReason(signal: AbortSignal): string | undefined;
+export declare function runAbortable<TResult, E = Error>(fn: ({ abortable, defer, signal, controller }: {
+    abortable: AbortableFn;
+    defer: DeferFn;
+    signal: AbortSignal;
+    controller: AbortController;
+}) => Promise<TResult> | TResult, options?: Options & {
+    controller?: AbortController;
+    signal?: AbortSignal;
+}): Promise<Result<TResult, E>>;
+export declare function runEffect<TResult, E = Error>(fn: (deferFn: DeferFn) => TResult, options?: Options & {
+    automaticCleanup?: boolean;
+}): Result<TResult, E> & {
+    cleanup: () => void;
+};
+export declare function runRetry<TResult, E = Error>(fn: (deferFn: DeferFn, attempt: number) => Promise<TResult> | TResult, options?: Options & {
+    maxAttempts?: number;
+    delayMs?: number;
+    backoff?: "linear" | "exponential";
+    shouldRetry?: ((err: E, attempt: number) => boolean) | boolean;
+    onRetry?: (err: E, attempt: number) => void;
+}): Promise<Result<TResult, E>>;
+export declare class TimeoutError extends Error {
+    constructor(message?: string);
+}
+export declare function runTimeout<TResult, E = Error>(fn: (deferFn: DeferFn) => Promise<TResult> | TResult, timeoutMs: number, options?: Options): Promise<Result<TResult, E>>;
+export declare function runDebounced<TResult, TArgs extends unknown[]>(fn: (defer: DeferFn, ...args: TArgs) => Promise<TResult> | TResult, delayMs: number, options?: Options): (...args: TArgs) => Promise<Result<TResult, Error>>;
+export default run;

package/dist/types/semaphore.d.ts

@@ -0,0 +1,13 @@
+export declare class Semaphore {
+    private counter;
+    private waiting;
+    private maxCount;
+    constructor(max?: number);
+    acquire(): Promise<void>;
+    release(): void;
+    count(): number;
+    setMax(newMax: number): void;
+    purge(): number;
+    private processQueue;
+}
+export default Semaphore;

package/dist/types/serialize.d.ts

@@ -0,0 +1,8 @@
+export type SerializedError = {
+    name: string;
+    message: string;
+    stack?: string;
+    stringified: string;
+};
+export declare function serializeError(error: Error): SerializedError;
+export declare function deserializeError(serializedError: SerializedError): Error;

package/dist/types/time.d.ts

@@ -0,0 +1,11 @@
+export declare function isTimestampSameDay(timestamp1: number, timestamp2: number): boolean;
+export declare function isTimestampSameMinute(timestamp1: number, timestamp2: number): boolean;
+export declare function formatSecondsToHHMM(seconds: number): string;
+export declare function formatSecondsToMMSS(seconds: number): string;
+export declare function getTimeRemaining(endTimestamp: number): {
+    total: number;
+    days: number;
+    hours: number;
+    minutes: number;
+    seconds: number;
+};

package/dist/types/types.d.ts

@@ -0,0 +1,4 @@
+export type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,40 @@
+{
+	"name": "@filen/utils",
+	"version": "0.0.1",
+	"description": "A collection of utils for Filen",
+	"private": false,
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/FilenCloudDienste/filen-apps/packages/filen-utils"
+	},
+	"author": "Filen Cloud Dienste UG",
+	"main": "dist/index.js",
+	"types": "dist/types/index.d.ts",
+	"scripts": {
+		"build": "npm run build:clean && tsc --extendedDiagnostics --project tsconfig.json",
+		"build:clean": "rimraf ./dist",
+		"typecheck": "tsc --noEmit",
+		"dev": "tsx src/dev.ts",
+		"test": "vitest",
+		"test:ui": "vitest --ui",
+		"test:coverage": "vitest --coverage"
+	},
+	"keywords": [
+		"filen"
+	],
+	"engines": {
+		"node": ">=20"
+	},
+	"license": "AGPLv3",
+	"devDependencies": {
+		"rimraf": "^6.1.0",
+		"tsx": "^4.20.6",
+		"typescript": "^5.9.3",
+		"vitest": "^3.2.4"
+	},
+	"dependencies": {
+		"clsx": "^2.1.1",
+		"tailwind-merge": "^3.3.1",
+		"uuid": "^13.0.0"
+	}
+}