@putkoff/abstract-utilities 0.1.242 → 0.1.244

package/dist/functions/path_utils/src/path_utils.js

@@ -0,0 +1,112 @@
+// path_utils.browser.ts
+import * as path from 'path-browserify';
+import { eatOuter, eatInner, ensure_list } from './../imports.js';
+export function get_dirname(filePath) {
+    if (!filePath)
+        return '';
+    return path.dirname(filePath);
+}
+export function get_basename(filePath) {
+    if (!filePath)
+        return '';
+    return path.basename(filePath);
+}
+export function get_filename(file_path) {
+    const ext = path.extname(file_path);
+    return path.basename(file_path, ext);
+}
+export function get_extname(filePath) {
+    if (!filePath)
+        return '';
+    return path.extname(filePath);
+}
+export function get_splitext(filePath) {
+    if (!filePath)
+        return { filename: '', extname: '' };
+    const ext = path.extname(filePath);
+    // Get the basename without the extension
+    const filename = path.basename(filePath, ext);
+    return { filename, ext };
+}
+/**
+ * Join multiple path segments, normalizing leading/trailing slashes.
+ *
+ * Usage:
+ *   make_path('/foo','bar','baz')
+ *   make_path(['/foo','bar','baz'])
+ */
+export function make_path(...paths) {
+    // If someone passed a single array, unwrap it:
+    const pathArray = (paths.length === 1 && Array.isArray(paths[0])
+        ? paths[0]
+        : paths);
+    let real_path = '';
+    for (let i = 0; i < pathArray.length; i++) {
+        let segment = pathArray[i];
+        if (i === 0) {
+            real_path = segment;
+        }
+        else {
+            // remove any leading slash on this segment
+            segment = segment.replace(/^\/+/, '');
+            // remove any trailing slash on the accumulator
+            real_path = real_path.replace(/\/+$/, '');
+            real_path = `${real_path}/${segment}`;
+        }
+    }
+    return real_path;
+}
+export function makePath(...paths) {
+    var _a;
+    const pathArray = ensure_list(paths);
+    let real_path = '';
+    for (let i = 0; i < pathArray.length; i++) {
+        let seg = String((_a = pathArray[i]) !== null && _a !== void 0 ? _a : '');
+        if (i === 0) {
+            real_path = seg;
+        }
+        else {
+            seg = eatInner(seg, ['/']);
+            real_path = eatOuter(real_path, ['/']);
+            real_path = `${real_path}/${seg}`;
+        }
+    }
+    return real_path || '';
+}
+export function sanitizeFilename(filename) {
+    return filename
+        .toLowerCase()
+        .replace(/\s+|-/g, '-') // Replace spaces and hyphens with single hyphen
+        .replace(/_/g, '-') // Replace underscores with hyphens
+        .replace(/[^a-z0-9-.]/g, '') // Remove all non-alphanumeric chars except hyphen and dot
+        .replace(/-+/g, '-') // Collapse multiple hyphens into one
+        .replace(/^-|-$/, ''); // Remove leading/trailing hyphens
+}
+export function get_relative_path(directory, fullPath) {
+    return path.relative(directory, fullPath);
+}
+// Safer resolver that strips .. at the front only, but prefer server-side checks.
+export function get_safe_path(p) {
+    return path.normalize(p).replace(/^(\.\.[/\\])+/, '');
+}
+export function make_sanitized_path(...paths) {
+    let real_path = '';
+    for (let i = 0; i < paths.length; i++) {
+        const sanitized = sanitizeFilename(eatInner(paths[i], ['/']));
+        if (i === 0) {
+            real_path = sanitized;
+        }
+        else if (sanitized) { // Only append if there's a non-empty segment
+            real_path = `${real_path}/${sanitized}`;
+        }
+    }
+    return real_path || '';
+}
+/** FIXED: your regexes were strings. This correctly joins without duplicate slashes. */
+export function normalizeUrl(base, p) {
+    if (!p)
+        return base.replace(/\/+$/g, '');
+    const cleanBase = base.replace(/\/+$/g, '');
+    const cleanPath = p.replace(/^\/+/g, '');
+    return `${cleanBase}/${cleanPath}`.replace(/([^:])\/{2,}/g, '$1/'); // keep protocol //
+}

package/dist/functions/path_utils/src/path_utils.node.js

@@ -0,0 +1,3 @@
+// path_utils.node.ts
+import * as path from 'path';
+export { path };

package/dist/functions/path_utils/src/paths.js

@@ -0,0 +1,12 @@
+import { getAbsolutePath } from './../imports.js';
+import { get_dirname, make_path } from './path_utils.js';
+/**
+ * Returns the absolute path of the current file.
+ */
+export function getAbsDir() {
+    return get_dirname(getAbsolutePath());
+}
+;
+export function getAbsPath(subPath) {
+    return make_path(getAbsDir(), subPath);
+}

package/dist/functions/path_utils/src/src_dirs.js

@@ -0,0 +1,25 @@
+import { make_path, get_dirname } from './path_utils.js';
+import { getFunctionsDir } from './function_dirs.js';
+export function getSrcDir() {
+    return get_dirname(getFunctionsDir());
+}
+;
+export function geStaticDirectory() {
+    return make_path(getSrcDir(), 'static');
+}
+;
+export function getLibUtilsDirectory() {
+    return make_path(getSrcDir(), 'lib');
+}
+export function getHooksUtilsDirectory() {
+    return make_path(getSrcDir(), 'hooks');
+}
+;
+export function getFunctionsUtilsDirectory() {
+    return make_path(getSrcDir(), 'functions');
+}
+;
+export function getComponentsUtilsDirectory() {
+    return make_path(getSrcDir(), 'components');
+}
+;

package/dist/functions/read_utils/imports.js

@@ -0,0 +1 @@
+export { safeGlobalProp } from './../safe_utils';

package/dist/functions/read_utils/index.js

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

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

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

package/dist/functions/read_utils/src/read_utils.browser.js

@@ -0,0 +1,17 @@
+import { __awaiter } from "tslib";
+// No Node imports!
+import { safeGlobalProp } from './../imports.js';
+export function readJsonFile(url) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const fetchFn = safeGlobalProp('fetch') || fetch;
+            const res = yield fetchFn(url);
+            if (!res.ok)
+                return null;
+            return yield res.json();
+        }
+        catch (_a) {
+            return null;
+        }
+    });
+}

package/dist/functions/read_utils/src/utils.browser.js

@@ -0,0 +1,32 @@
+import { __awaiter } from "tslib";
+import { safeGlobalProp } from './../imports.js';
+export function readJsonFile(url) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const fetchFn = safeGlobalProp('fetch');
+        if (typeof fetchFn !== 'function')
+            return null;
+        try {
+            const res = yield fetchFn(url);
+            if (!res.ok)
+                return null;
+            return yield res.json();
+        }
+        catch (_a) {
+            return null;
+        }
+    });
+}
+export function getConfigContent() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return readJsonFile('config.json');
+    });
+}
+export function getConfigVar() {
+    return __awaiter(this, arguments, void 0, function* (key = null) {
+        const cfg = yield getConfigContent();
+        if (cfg && typeof cfg === 'object' && key in cfg) {
+            return cfg[key];
+        }
+        return undefined;
+    });
+}

package/dist/functions/read_utils/src/utils.js

@@ -0,0 +1,70 @@
+import { __awaiter } from "tslib";
+import { safeGlobalProp } from './../imports.js';
+// src/functions/read_utils/src/read_utils.ts
+/**
+ * Reads a JSON file, either via Node’s fs (if available)
+ * or via window.fetch in the browser. Never throws — returns
+ * the parsed object or null on any error.
+ */
+export function readJsonFile(relativeOrAbsolutePath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (typeof window === 'undefined') {
+            try {
+                const { readFile } = yield import('fs/promises');
+                const { isAbsolute, resolve } = yield import('path');
+                const filePath = isAbsolute(relativeOrAbsolutePath)
+                    ? relativeOrAbsolutePath
+                    : resolve(import.meta.url ? new URL('.', import.meta.url).pathname : '', relativeOrAbsolutePath);
+                const text = yield readFile(filePath, 'utf8');
+                return JSON.parse(text);
+            }
+            catch (_a) {
+                return null;
+            }
+        }
+        // Browser fallback
+        const fetchFn = safeGlobalProp('fetch');
+        if (typeof fetchFn !== 'function')
+            return null;
+        let url = relativeOrAbsolutePath;
+        const baseURI = safeGlobalProp('document', 'baseURI');
+        if (baseURI) {
+            try {
+                url = new URL(relativeOrAbsolutePath, baseURI).href;
+            }
+            catch (_b) { }
+        }
+        try {
+            const res = yield fetchFn(url);
+            if (!res.ok)
+                return null;
+            return yield res.json();
+        }
+        catch (_c) {
+            return null;
+        }
+    });
+}
+export function getConfigContent() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            // `readJsonFile` should throw if the file isn’t there or isn’t valid JSON
+            const cfg = yield readJsonFile('./config.json');
+            return cfg;
+        }
+        catch (_a) {
+            // swallow errors & return null so callers can detect “no config”
+            return null;
+        }
+    });
+}
+// 2) Pull a single key out of that object
+export function getConfigVar() {
+    return __awaiter(this, arguments, void 0, function* (key = null) {
+        const cfg = yield getConfigContent();
+        if (cfg && typeof cfg === 'object' && key in cfg) {
+            return cfg[key];
+        }
+        return undefined;
+    });
+}

package/dist/functions/rndm_utils/imports.js

@@ -0,0 +1 @@
+"use strict";

package/dist/functions/rndm_utils/index.js

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

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

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

package/dist/functions/rndm_utils/src/utils.js

@@ -0,0 +1,13 @@
+// src/functions/rndm_utils/utils.ts
+export function alertit(obj = null) {
+    let msg;
+    try {
+        msg = JSON.stringify(obj);
+    }
+    catch (_a) {
+        // If JSON.stringify fails (circular refs, etc.), fall back to a simple string
+        msg = String(obj);
+    }
+    alert(msg);
+}
+export const alertIt = alertit;

package/dist/functions/safe_utils/imports.js

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

package/dist/functions/safe_utils/index.js

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

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

@@ -0,0 +1,4 @@
+export * from './safe_document';
+export * from './safe_storage';
+export * from './safe_globals';
+export * from './safe_window';

package/dist/functions/safe_utils/src/safe_document.js

@@ -0,0 +1,12 @@
+export function getSafeDocument() {
+    return typeof document !== 'undefined' ? document : undefined;
+}
+export function getDocumentProp(...keys) {
+    let obj = getSafeDocument();
+    for (const k of keys) {
+        if (obj == null || typeof obj !== 'object')
+            return undefined;
+        obj = obj[k];
+    }
+    return obj;
+}

package/dist/functions/safe_utils/src/safe_globals.js

@@ -0,0 +1,14 @@
+/**
+ * Safely walk `globalThis` (or window/document) by a chain of property names.
+ * Returns `undefined` if any step is missing.
+ */
+export function safeGlobalProp(...path) {
+    let obj = globalThis;
+    for (const key of path) {
+        if (obj == null || typeof obj !== "object" || !(key in obj)) {
+            return undefined;
+        }
+        obj = obj[key];
+    }
+    return obj;
+}

package/dist/functions/safe_utils/src/safe_storage.js

@@ -0,0 +1,52 @@
+import { safeGlobalProp } from './safe_globals.js';
+/**
+ * Returns `window` if running in a browser, otherwise `undefined`.
+ */
+export function getSafeLocalStorage() {
+    if (typeof window === 'undefined')
+        return undefined;
+    try {
+        return window.localStorage;
+    }
+    catch (_a) {
+        return undefined; // e.g. Safari private-mode block
+    }
+}
+/**
+ * Call a Storage method by name, silencing any errors or missing storage.
+ *
+ * @param method  One of the keys of the Storage interface: "getItem", "setItem", etc.
+ * @param args    The arguments you’d normally pass to that method.
+ * @returns       The method’s return value, or undefined if storage/method isn’t available.
+ */
+export function callStorage(method, ...args) {
+    const storage = getSafeLocalStorage();
+    if (!storage)
+        return undefined;
+    const fn = storage[method];
+    if (typeof fn !== 'function')
+        return undefined;
+    try {
+        // @ts-ignore – TS can’t infer that this is callable
+        return fn.apply(storage, args);
+    }
+    catch (_a) {
+        return undefined;
+    }
+}
+/**
+ * Safely call storage methods (`localStorage` or `sessionStorage`) without blowing up.
+ * Returns `undefined` on any error.
+ */
+export function safeStorage(storageName, method, ...args) {
+    try {
+        const store = safeGlobalProp(storageName);
+        if (!store || typeof store[method] !== "function")
+            return undefined;
+        // @ts-ignore
+        return store[method](...args);
+    }
+    catch (_a) {
+        return undefined;
+    }
+}

package/dist/functions/safe_utils/src/safe_window.js

@@ -0,0 +1,42 @@
+/**
+ * Returns the global window object if it exists, otherwise undefined.
+ */
+export function getSafeWindow() {
+    return typeof window !== 'undefined' ? window : undefined;
+}
+/**
+ * Safely call a method on window by name.
+ *
+ * @param method  The Window method to call (e.g. "alert", "open", etc.).
+ * @param args    Arguments to pass to that method.
+ * @returns       The method’s return value, or undefined if
+ *                 window/method isn’t available or throws.
+ */
+export function callWindowMethod(method, ...args) {
+    const w = getSafeWindow();
+    if (!w)
+        return undefined;
+    const fn = w[method];
+    if (typeof fn !== 'function')
+        return undefined;
+    try {
+        // cast to any so TS doesn’t complain about apply/invoke
+        return fn(...args);
+    }
+    catch (_a) {
+        return undefined;
+    }
+}
+/** implementation */
+export function getWindowProp(...keys) {
+    let obj = getSafeWindow();
+    for (const k of keys) {
+        if (obj == null || typeof obj !== 'object')
+            return undefined;
+        obj = obj[k];
+    }
+    return obj;
+}
+export function getWindowHost() {
+    return getWindowProp('location', 'host');
+}

package/dist/functions/string_utils/index.js

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

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

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

package/dist/functions/string_utils/src/string_utils.js

@@ -0,0 +1,153 @@
+import { assureString } from './../../type_utils/index.js';
+export function getSubstring(obj, maxLength = null, minLength = null) {
+    const objLength = obj.length;
+    const effectiveMaxLength = maxLength !== null && maxLength !== void 0 ? maxLength : objLength; // Use nullish coalescing for clarity
+    const effectiveMinLength = minLength !== null && minLength !== void 0 ? minLength : 0;
+    // Ensure bounds are valid
+    const clampedMaxLength = Math.min(Math.max(effectiveMaxLength, 0), objLength);
+    const clampedMinLength = Math.min(Math.max(effectiveMinLength, 0), objLength);
+    // If minLength exceeds maxLength, return empty string or adjust logic as needed
+    if (clampedMinLength >= clampedMaxLength) {
+        return '';
+    }
+    return obj.substring(clampedMinLength, clampedMaxLength);
+}
+export function truncateString(obj, maxLength = 20) {
+    const objLength = obj.length;
+    if (objLength > maxLength && maxLength) {
+        obj = getSubstring(obj, maxLength) + '...';
+    }
+    return obj;
+}
+export function capitalize_str(string) {
+    string = assureString(string);
+    const string_len = string.length;
+    let init_char = string.toUpperCase();
+    if (string_len > 0) {
+        init_char = string[0].toUpperCase();
+    }
+    let rest_chars = '';
+    if (string_len > 1) {
+        rest_chars = string.slice(1).toLowerCase();
+    }
+    const fin_chars = `${init_char}${rest_chars}`;
+    return fin_chars;
+}
+export function capitalize(string) {
+    let nu_string = '';
+    string = assureString(string);
+    let objs = string.replace('-', '_').split('_');
+    for (const obj of objs) {
+        let str_obj = capitalize_str(obj);
+        nu_string = `${nu_string} ${str_obj}`;
+    }
+    return eatAll(nu_string, [' ']);
+}
+// string_utils/src/string_utils.ts
+export function stripPrefixes(str, bases = []) {
+    /* NEW: coerce whatever arrives into a string */
+    str = String(str);
+    const prefixes = (Array.isArray(bases) ? bases : [bases])
+        .filter(Boolean)
+        .sort((a, b) => b.length - a.length); // longest first
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const prefix of prefixes) {
+            if (str.startsWith(prefix)) {
+                str = str.slice(prefix.length);
+                changed = true;
+                break; // restart from longest prefix
+            }
+        }
+    }
+    return str;
+}
+/**
+ * Removes characters from the beginning of the string
+ * if they are found in the list of characters.
+ *
+ * @param str - The input string.
+ * @param listObjects - A string or an array of characters to remove.
+ * @returns The modified string.
+ */
+export function eatInner(str, listObjects) {
+    if (!Array.isArray(listObjects)) {
+        listObjects = [listObjects];
+    }
+    // Ensure str is a string
+    str = String(str);
+    // Remove characters from the beginning while they are in listObjects
+    while (str.length > 0 && listObjects.includes(str[0])) {
+        str = str.slice(1);
+    }
+    return str;
+}
+/**
+ * Removes characters from the end of the string
+ * if they are found in the list of characters.
+ *
+ * @param str - The input string.
+ * @param listObjects - A string or an array of characters to remove.
+ * @returns The modified string.
+ */
+export function eatOuter(str, listObjects) {
+    if (!Array.isArray(listObjects)) {
+        listObjects = [listObjects];
+    }
+    // Ensure str is a string
+    str = String(str);
+    // Remove characters from the end while they are in listObjects
+    while (str.length > 0 && listObjects.includes(str[str.length - 1])) {
+        str = str.slice(0, -1);
+    }
+    return str;
+}
+/**
+ * Removes characters from both the beginning and the end of the string
+ * if they are found in the list of characters.
+ *
+ * @param str - The input string.
+ * @param listObjects - A string or an array of characters to remove.
+ * @returns The modified string.
+ */
+export function eatAll(str, listObjects) {
+    return eatOuter(eatInner(str, listObjects), listObjects);
+}
+export function eatEnd(obj, endings = ['/']) {
+    let result = obj;
+    let modified = true;
+    while (modified) {
+        modified = false;
+        for (const ending of endings) {
+            if (result.endsWith(ending)) {
+                result = result.slice(0, -ending.length);
+                modified = true;
+                break;
+            }
+        }
+    }
+    return result;
+}
+export function tryParse(obj) {
+    try {
+        obj = JSON.stringify(obj);
+    }
+    catch (err) {
+        try {
+            obj = JSON.parse(obj);
+        }
+        catch (err) {
+        }
+    }
+    return obj;
+}
+export function create_list_string(array_obj) {
+    let string = '';
+    for (const obj in array_obj) {
+        const array_value = array_obj[obj];
+        const parsed_value = tryParse(array_value);
+        string += `${obj} == ${parsed_value}\n`;
+    }
+    return string;
+}

package/dist/functions/type_utils/imports.js

@@ -0,0 +1 @@
+"use strict";

package/dist/functions/type_utils/index.js

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

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

@@ -0,0 +1,38 @@
+import { ensure_string, ensure_array } from './ensure_utils.js';
+export function cleanText(input) {
+    // Replace delimiters with spaces and split
+    const str = ensure_string(input);
+    const words = str.replace(/[_.-]/g, ' '); // Replace _, -, . with space
+    return words;
+}
+export function cleanArray(obj) {
+    obj = ensure_array(obj);
+    return Array.from(new Set(obj));
+}
+export function getCleanArray(obj) {
+    obj = obj.split(/\s+/) // Split on any whitespace
+        .filter((item) => typeof item === 'string' && item !== '');
+    // Get basename
+    // Remove duplicates using Set
+    const uniqueWords = cleanArray(obj);
+    return uniqueWords;
+}
+// Cache a formatter instance for slightly better performance
+const US_DECIMAL_FORMATTER = new Intl.NumberFormat('en-US', {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2,
+});
+export function formatNumber(value) {
+    try {
+        // coerce to number
+        const num = Number(value);
+        // if it's NaN or infinite, bail out
+        if (!isFinite(num))
+            return value;
+        return US_DECIMAL_FORMATTER.format(num);
+    }
+    catch (_a) {
+        // if anything goes wrong, return the original
+        return value;
+    }
+}