@putkoff/abstract-utilities 0.1.242 → 0.1.244

package/dist/functions/type_utils/src/ensure_utils.js

@@ -0,0 +1,33 @@
+export function ensure_list(obj) {
+    const objArray = Array.isArray(obj) ? obj : [obj];
+    return objArray;
+}
+// coerce any single value into a number (0 if it can't)
+export function ensure_number(x) {
+    const n = Number(x);
+    return isNaN(n) ? 0 : n;
+}
+export function ensure_array(input) {
+    if (typeof input === 'string') {
+        return [input];
+    }
+    if (Array.isArray(input)) {
+        return input.map(item => ensure_string(item));
+    }
+    return [];
+}
+export function ensure_string(obj) {
+    return String(obj);
+}
+export const assureList = ensure_list;
+export const assureString = ensure_string;
+export const assureNumber = ensure_number;
+export const assureArray = ensure_array;
+export const assure_list = ensure_list;
+export const assure_string = ensure_string;
+export const assure_number = ensure_number;
+export const assure_array = ensure_array;
+export const ensureList = ensure_list;
+export const ensureString = ensure_string;
+export const ensureNumber = ensure_number;
+export const ensureArray = ensure_array;

package/dist/functions/type_utils/src/index.js

@@ -0,0 +1,5 @@
+export * from './clean_utils';
+export * from './ensure_utils';
+export * from './json_utils';
+export * from './type_utils';
+export * from './mime_utils';

package/dist/functions/type_utils/src/json_utils.js

@@ -0,0 +1,22 @@
+import { ensure_array } from './ensure_utils.js';
+// Constrain T so 'in obj' is allowed
+export function get_key_value(obj, key) {
+    // we cast to any for the indexing, since TS can’t infer arbitrary string keys
+    if (key in obj && obj[key] != null) {
+        return obj[key];
+    }
+    return null;
+}
+export function get(obj, keys, defaultValue = null) {
+    const keyArray = ensure_array(keys);
+    if (!obj || keyArray.length === 0) {
+        return defaultValue;
+    }
+    for (const key of keyArray) {
+        const val = get_key_value(obj, key);
+        if (val != null) {
+            return val;
+        }
+    }
+    return defaultValue;
+}

package/dist/functions/type_utils/src/mime_utils.js

@@ -0,0 +1,311 @@
+import { __awaiter } from "tslib";
+// mediaTypes.ts
+import * as fs from "node:fs";
+import * as fsp from "node:fs/promises";
+import * as path from "node:path";
+/** ---- Data: large but explicit, mirrors your Python mapping ---- */
+export const MIME_TYPES = {
+    image: {
+        ".jpg": "image/jpeg",
+        ".jpeg": "image/jpeg",
+        ".png": "image/png",
+        ".gif": "image/gif",
+        ".bmp": "image/bmp",
+        ".tiff": "image/tiff",
+        ".webp": "image/webp",
+        ".svg": "image/svg+xml",
+        ".ico": "image/vnd.microsoft.icon",
+        ".heic": "image/heic",
+        ".psd": "image/vnd.adobe.photoshop",
+        ".raw": "image/x-raw",
+    },
+    video: {
+        ".mp4": "video/mp4",
+        ".webm": "video/webm",
+        ".ogg": "video/ogg",
+        ".mov": "video/quicktime",
+        ".avi": "video/x-msvideo",
+        ".mkv": "video/x-matroska",
+        ".flv": "video/x-flv",
+        ".wmv": "video/x-ms-wmv",
+        ".3gp": "video/3gpp",
+        ".ts": "video/mp2t",
+        ".mpeg": "video/mpeg",
+        ".mpg": "video/mpg",
+    },
+    audio: {
+        ".mp3": "audio/mpeg",
+        ".wav": "audio/wav",
+        ".flac": "audio/flac",
+        ".aac": "audio/aac",
+        ".ogg": "audio/ogg",
+        ".m4a": "audio/mp4",
+        ".opus": "audio/opus",
+    },
+    document: {
+        ".pdf": "application/pdf",
+        ".doc": "application/msword",
+        ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        ".odt": "application/vnd.oasis.opendocument.text",
+        ".txt": "text/plain",
+        ".rtf": "application/rtf",
+        ".md": "text/markdown",
+        ".markdown": "text/markdown",
+        ".tex": "application/x-tex",
+        ".log": "text/plain",
+        ".json": "application/json",
+        ".xml": "application/xml",
+        ".yaml": "application/x-yaml",
+        ".yml": "application/x-yaml",
+        ".ini": "text/plain",
+        ".cfg": "text/plain",
+        ".toml": "application/toml",
+        ".csv": "text/csv",
+        ".tsv": "text/tab-separated-values",
+    },
+    presentation: {
+        ".ppt": "application/vnd.ms-powerpoint",
+        ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+        ".odp": "application/vnd.oasis.opendocument.presentation",
+    },
+    spreadsheet: {
+        ".xls": "application/vnd.ms-excel",
+        ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        ".ods": "application/vnd.oasis.opendocument.spreadsheet",
+        ".csv": "text/csv",
+        ".tsv": "text/tab-separated-values",
+    },
+    code: {
+        ".py": "text/x-python",
+        ".java": "text/x-java-source",
+        ".c": "text/x-c",
+        ".cpp": "text/x-c++",
+        ".h": "text/x-c",
+        ".hpp": "text/x-c++",
+        ".js": "application/javascript",
+        ".cjs": "application/javascript",
+        ".mjs": "application/javascript",
+        ".jsx": "application/javascript",
+        ".ts": "application/typescript",
+        ".tsx": "application/typescript",
+        ".rb": "text/x-ruby",
+        ".php": "application/x-php",
+        ".go": "text/x-go",
+        ".rs": "text/rust",
+        ".swift": "text/x-swift",
+        ".kt": "text/x-kotlin",
+        ".sh": "application/x-shellscript",
+        ".bash": "application/x-shellscript",
+        ".ps1": "application/x-powershell",
+        ".sql": "application/sql",
+        ".yml": "application/x-yaml",
+        ".coffee": "text/coffeescript",
+        ".lua": "text/x-lua",
+    },
+    archive: {
+        ".zip": "application/zip",
+        ".tar": "application/x-tar",
+        ".gz": "application/gzip",
+        ".tgz": "application/gzip",
+        ".bz2": "application/x-bzip2",
+        ".xz": "application/x-xz",
+        ".rar": "application/vnd.rar",
+        ".7z": "application/x-7z-compressed",
+        ".iso": "application/x-iso9660-image",
+        ".dmg": "application/x-apple-diskimage",
+        ".jar": "application/java-archive",
+        ".war": "application/java-archive",
+        ".whl": "application/python-wheel",
+        ".egg": "application/python-egg",
+    },
+    font: {
+        ".ttf": "font/ttf",
+        ".otf": "font/otf",
+        ".woff": "font/woff",
+        ".woff2": "font/woff2",
+        ".eot": "application/vnd.ms-fontobject",
+    },
+    executable: {
+        ".exe": "application/vnd.microsoft.portable-executable",
+        ".dll": "application/vnd.microsoft.portable-executable",
+        ".bin": "application/octet-stream",
+        ".deb": "application/vnd.debian.binary-package",
+        ".rpm": "application/x-rpm",
+    },
+};
+/** Mirror of MEDIA_TYPES in Python: category -> Set of extensions */
+export const MEDIA_TYPES = Object.fromEntries(Object.entries(MIME_TYPES).map(([cat, mapping]) => [
+    cat,
+    new Set(Object.keys(mapping)),
+]));
+/** ---- Helpers ---- */
+function toCategorySet(categories) {
+    const allCats = new Set(Object.keys(MIME_TYPES));
+    if (!categories) {
+        // all categories
+        return new Set(allCats);
+    }
+    const out = new Set();
+    for (const c of categories) {
+        const key = String(c);
+        if (allCats.has(key))
+            out.add(key);
+    }
+    return out.size ? out : new Set(allCats);
+}
+function normalizeCategories(categories, opts) {
+    var _a;
+    const selected = (_a = categories !== null && categories !== void 0 ? categories : opts === null || opts === void 0 ? void 0 : opts.media_types) !== null && _a !== void 0 ? _a : null;
+    return toCategorySet(selected);
+}
+function extOf(input) {
+    // Behaves like pathlib.Path(...).suffix.lower(): last extension only; lowercased.
+    let ext = path.extname(input || "");
+    if (!ext && input && input.startsWith(".")) {
+        // user passed ".jpg" directly
+        ext = input;
+    }
+    return (ext || "").toLowerCase();
+}
+function unionExts(categories) {
+    const out = new Set();
+    for (const c of categories) {
+        const set = MEDIA_TYPES[c];
+        for (const e of set)
+            out.add(e);
+    }
+    return out;
+}
+/** ---- API (Python parity) ---- */
+/**
+ * Return a sub-map of MEDIA_TYPES for the given categories.
+ * If categories is falsy, returns all categories.
+ */
+export function getMediaMap(categories, opts) {
+    const cats = normalizeCategories(categories, opts);
+    const result = {};
+    for (const c of cats)
+        result[c] = new Set(MEDIA_TYPES[c]);
+    return result;
+}
+/**
+ * Return a flat, sorted list of all extensions for the given categories.
+ */
+export function getMediaExts(categories, opts) {
+    const cats = normalizeCategories(categories, opts);
+    return Array.from(unionExts(cats)).sort();
+}
+/**
+ * Given a file path or extension, return its media category (e.g. "image") or null.
+ * Mirrors Python's confirm_type.
+ */
+export function confirmType(pathOrExt, categories, opts) {
+    const cats = normalizeCategories(categories, opts);
+    const ext = extOf(pathOrExt);
+    // Preserve object insertion order like Python dict iteration
+    for (const [category, exts] of Object.entries(MEDIA_TYPES)) {
+        if (!cats.has(category))
+            continue;
+        if (ext && exts.has(ext))
+            return category;
+    }
+    return null;
+}
+/**
+ * True if the given file path or extension belongs to one of the categories.
+ */
+export function isMediaType(pathOrExt, categories, opts) {
+    return confirmType(pathOrExt, categories, opts) !== null;
+}
+/**
+ * Look up the MIME type by extension; fall back to 'application/octet-stream'.
+ */
+export function getMimeType(pathOrExt) {
+    const ext = extOf(pathOrExt);
+    for (const mapping of Object.values(MIME_TYPES)) {
+        if (ext && mapping[ext]) {
+            return mapping[ext];
+        }
+    }
+    return "application/octet-stream";
+}
+/**
+ * Recursively collect files under `directory` whose extension is in `categories`.
+ * Synchronous version.
+ */
+export function getAllFileTypesSync(directory, categories, opts) {
+    const base = directory;
+    let stat;
+    try {
+        stat = fs.statSync(base);
+    }
+    catch (_a) {
+        return [];
+    }
+    if (!stat.isDirectory())
+        return [];
+    const cats = normalizeCategories(categories, opts);
+    const wanted = unionExts(cats);
+    const results = [];
+    function walkSync(dir) {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const ent of entries) {
+            const full = path.join(dir, ent.name);
+            if (ent.isDirectory()) {
+                walkSync(full);
+            }
+            else if (ent.isFile()) {
+                const ext = path.extname(ent.name).toLowerCase();
+                if (wanted.has(ext))
+                    results.push(full);
+            }
+        }
+    }
+    walkSync(base);
+    return results;
+}
+/**
+ * Recursively collect files under `directory` whose extension is in `categories`.
+ * Async/Promise version.
+ */
+export function getAllFileTypes(directory, categories, opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let stat;
+        try {
+            stat = yield fsp.stat(directory);
+        }
+        catch (_a) {
+            return [];
+        }
+        if (!stat.isDirectory())
+            return [];
+        const cats = normalizeCategories(categories, opts);
+        const wanted = unionExts(cats);
+        const results = [];
+        function walkAsync(dir) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const entries = yield fsp.readdir(dir, { withFileTypes: true });
+                for (const ent of entries) {
+                    const full = path.join(dir, ent.name);
+                    if (ent.isDirectory()) {
+                        yield walkAsync(full);
+                    }
+                    else if (ent.isFile()) {
+                        const ext = path.extname(ent.name).toLowerCase();
+                        if (wanted.has(ext))
+                            results.push(full);
+                    }
+                }
+            });
+        }
+        yield walkAsync(directory);
+        return results;
+    });
+}
+/** Optional convenience re-exports that mirror your Python names */
+export const get_all_file_types = getAllFileTypes;
+export const get_media_map = getMediaMap;
+export const get_media_exts = getMediaExts;
+export const confirm_type = confirmType;
+export const is_media_type = isMediaType;
+export const get_mime_type = getMimeType;

package/dist/functions/type_utils/src/type_utils.js

@@ -0,0 +1,39 @@
+import { ensure_string } from './ensure_utils.js';
+export function isType(obj, type) {
+    if (typeof obj === type) {
+        return true;
+    }
+    return false;
+}
+export function isStrInString(obj, string) {
+    const obj_str = ensure_string(obj).toLowerCase;
+    string = ensure_string(string).toLowerCase;
+    if (string.includes(obj_str)) {
+        return true;
+    }
+    return false;
+}
+export function getChar(i, string) {
+    if (string.length >= i) {
+        return ensure_string(string)[i];
+    }
+}
+export function getAlphaNum(obj) {
+    const is_num = isNum(obj);
+    const alphas = getAlphas();
+    if (is_num) {
+        return getChar(obj, alphas);
+    }
+    if (isStrInString(obj, alphas)) {
+        return getChar(obj, alphas);
+    }
+}
+export function getNums() {
+    return '0123456789';
+}
+export function isNum(obj) {
+    return !Number.isNaN(Number(obj));
+}
+export function getAlphas() {
+    return 'abcdefghijklmnopqrstuvwxyz';
+}

package/dist/functions/ui_utils/imports.js

@@ -0,0 +1,5 @@
+//src/components/UI/UI.tsx
+import React from 'react';
+export const { useState, useEffect, useCallback } = React;
+export { fetchIt } from './../fetch_utils';
+export { currentUsername, isTokenExpired, getToken } from './../auth_utils';

package/dist/functions/ui_utils/index.js

@@ -0,0 +1 @@
+export * from './src';

package/dist/functions/ui_utils/src/button.js

@@ -0,0 +1,22 @@
+import { __rest } from "tslib";
+import { jsx as _jsx } from "react/jsx-runtime";
+export function Button(_a) {
+    var { children, color = 'gray', variant = 'default', className = '' } = _a, rest = __rest(_a, ["children", "color", "variant", "className"]);
+    const base = 'rounded px-3 py-1 text-sm font-medium focus:outline-none focus:ring-2 focus:ring-offset-2 transition-colors duration-150';
+    const variantStyles = {
+        default: '',
+        icon: 'p-1 bg-transparent hover:bg-gray-100',
+        primary: 'text-white',
+        secondary: '',
+    };
+    const palette = {
+        gray: variant === 'primary'
+            ? 'bg-gray-600 hover:bg-gray-700 focus:ring-gray-500'
+            : 'bg-gray-200 hover:bg-gray-300 focus:ring-gray-400',
+        green: 'bg-green-600 text-white hover:bg-green-700 focus:ring-green-500',
+        blue: variant === 'primary'
+            ? 'bg-blue-600 hover:bg-blue-700 focus:ring-blue-500'
+            : 'bg-blue-200 hover:bg-blue-300 focus:ring-blue-400',
+    };
+    return (_jsx("button", Object.assign({ className: `${base} ${variantStyles[variant]} ${palette[color]} ${className}` }, rest, { children: children })));
+}

package/dist/functions/ui_utils/src/checkbox.js

@@ -0,0 +1,6 @@
+import { __rest } from "tslib";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export function Checkbox(_a) {
+    var { label } = _a, rest = __rest(_a, ["label"]);
+    return (_jsxs("label", { className: 'flex items-center gap-2 mb-4', children: [_jsx("input", Object.assign({ type: 'checkbox' }, rest)), _jsx("span", { children: label })] }));
+}

package/dist/functions/ui_utils/src/index.js

@@ -0,0 +1,4 @@
+export * from './button';
+export * from './checkbox';
+export * from './input';
+export * from './spinner';

package/dist/functions/ui_utils/src/input.js

@@ -0,0 +1,6 @@
+import { __rest } from "tslib";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export function Input(_a) {
+    var { label, trailing } = _a, rest = __rest(_a, ["label", "trailing"]);
+    return (_jsxs("label", { className: 'mb-4 block', children: [_jsx("span", { className: 'block text-sm font-medium mb-1', children: label }), _jsxs("div", { className: 'flex gap-2', children: [_jsx("input", Object.assign({ className: 'flex-1 rounded border px-2 py-1 disabled:bg-gray-100' }, rest)), trailing] })] }));
+}

package/dist/functions/ui_utils/src/spinner.js

@@ -0,0 +1,4 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+export function Spinner() {
+    return (_jsx("p", { className: 'animate-pulse', children: "Loading\u2026" }));
+}

package/dist/functions/url_utils/index.js

@@ -0,0 +1 @@
+export * from './uri_utils';

package/dist/functions/url_utils/uri_utils.js

@@ -0,0 +1,69 @@
+// urlTools.ts
+// Minimal, safe encoders/decoders + helpers to build/parse URLs
+/** Encode a single query value/key safely */
+export const encode = (v) => encodeURIComponent(String(v !== null && v !== void 0 ? v : ""));
+/** Decode a single query value/key safely (never throws) */
+export const decodeSafe = (v) => {
+    if (v == null)
+        return "";
+    try {
+        return decodeURIComponent(v);
+    }
+    catch (_a) {
+        // handles bad % sequences or already-decoded strings
+        return v;
+    }
+};
+/** Decode strings that might be double-encoded (up to 2 passes) */
+export const decodeMaybeDouble = (v) => {
+    const once = decodeSafe(v);
+    const twice = decodeSafe(once);
+    return twice.length < once.length ? twice : once;
+};
+/** Convert + to spaces (legacy www-form behavior) then decode */
+export const decodeFormComponent = (v) => decodeSafe(v.replace(/\+/g, " "));
+/** Build a URL with query params (skips null/undefined) */
+export const buildUrl = (base, params) => {
+    const u = new URL(base, typeof window !== "undefined" ? window.location.origin : "http://localhost");
+    if (params) {
+        for (const [k, val] of Object.entries(params)) {
+            if (val === null || val === undefined)
+                continue;
+            // arrays -> multiple entries
+            if (Array.isArray(val)) {
+                val.forEach(v => u.searchParams.append(k, String(v)));
+            }
+            else {
+                u.searchParams.set(k, String(val));
+            }
+        }
+    }
+    return u.toString();
+};
+/** Parse a query string into an object (first value wins; arrays if repeat=true) */
+export const parseQuery = (qs, opts) => {
+    var _a;
+    const { repeat = false, form = false } = opts || {};
+    const out = {};
+    const s = qs.startsWith("?") ? qs.slice(1) : qs;
+    if (!s)
+        return out;
+    for (const part of s.split("&")) {
+        if (!part)
+            continue;
+        const [kRaw, vRaw = ""] = part.split("=");
+        const K = form ? decodeFormComponent(kRaw) : decodeSafe(kRaw);
+        const V = form ? decodeFormComponent(vRaw) : decodeSafe(vRaw);
+        if (repeat) {
+            ((_a = out[K]) !== null && _a !== void 0 ? _a : (out[K] = [])).push(V);
+        }
+        else {
+            out[K] = V;
+        }
+    }
+    return out;
+};
+/** Quick helper: percent-encode whole strings for placement in URLs */
+export const encodeTextForUrl = (text) => encode(text);
+/** Quick helper: decode long blobs coming from share-intents/UTMs */
+export const decodeShareBlob = (blob) => decodeMaybeDouble(blob).replace(/\r\n/g, "\n");

package/dist/functions/variable_utils/imports.js

@@ -0,0 +1 @@
+export { eatAll } from './../string_utils';

package/dist/functions/variable_utils/index.js

@@ -0,0 +1 @@
+export * from './src';

package/dist/functions/variable_utils/src/index.js

@@ -0,0 +1 @@
+export * from './variable_utils';

package/dist/functions/variable_utils/src/variable_utils.js

@@ -0,0 +1,34 @@
+import { eatAll } from './../imports.js';
+/**
+ * Processes keywords by checking if keywords is a string and splitting it.
+ * Then cleans each keyword using `eatAll` with a set of characters to remove.
+ *
+ * @param keywords - The keywords as a comma-separated string or as an array.
+ * @returns An array of cleaned keywords.
+ */
+export function processKeywords(keywords) {
+    let keywordArray;
+    // If keywords is a string, split it on commas
+    if (typeof keywords === "string") {
+        keywordArray = keywords.split(",");
+    }
+    else {
+        keywordArray = keywords;
+    }
+    // Clean each keyword by removing unwanted characters
+    return keywordArray.map(keyword => eatAll(keyword, [",", "\n", "\t", " ", "#"]));
+}
+/**
+ * Constructs a keyword string where each keyword is prefixed with a hash (#).
+ *
+ * @param keywords - An array of keywords.
+ * @returns A string with each keyword prefixed by '#'.
+ */
+export function get_keyword_string(keywords) {
+    keywords = processKeywords(keywords);
+    let allString = "";
+    for (const keyword of keywords) {
+        allString += ` #${keyword}`;
+    }
+    return allString;
+}