@putkoff/abstract-utilities 1.0.113 → 1.0.125

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

@@ -1,186 +0,0 @@
-import { assureString, ensure_list } from './../../type_utils';
-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);
-}
-/**
- * Sanitize a string by removing null bytes and trimming whitespace.
- */
-export function sanitizeString(input) {
-    if (!input)
-        return input;
-    return input.replace(/\u0000/g, "").trim(); // Remove null bytes and whitespace
-}
-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);
-    const objs = string.replace('-', '_').split('_');
-    for (const obj of objs) {
-        const 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;
-}
-export function tryEatPrefix(str, length, ...objs) {
-    str = String(str);
-    objs = ensure_list(objs);
-    const prefix = str.slice(0, length);
-    if (length < 0) {
-        const start = str.length + length;
-        const actualPrefix = str.slice(start);
-        return objs.includes(actualPrefix) ? [str.slice(0, start), true] : [str, false];
-    }
-    if (objs.includes(prefix)) {
-        return [str.slice(length), true];
-    }
-    return [str, false];
-}
-/** Python-equivalent eatInner */
-export function eatInner(str, listObjects) {
-    str = String(str);
-    const chars = Array.isArray(listObjects) ? listObjects : [listObjects];
-    // Keep removing from left while leftmost char is in the set
-    while (str.length > 0 && chars.includes(str[0])) {
-        str = str.slice(1);
-    }
-    return str;
-}
-/** Python-equivalent eatOuter */
-export function eatOuter(str, listObjects) {
-    str = String(str);
-    const chars = Array.isArray(listObjects) ? listObjects : [listObjects];
-    if (!str || chars.length === 0)
-        return str;
-    for (let i = 0; i < str.length; i++) {
-        if (!str)
-            return str;
-        const last = str[str.length - 1];
-        if (!chars.includes(last)) {
-            return str;
-        }
-        str = str.slice(0, -1);
-    }
-    return str;
-}
-/** Python-equivalent eatAll */
-export function eatAll(str, listObjects) {
-    str = String(str);
-    const chars = Array.isArray(listObjects) ? listObjects : [listObjects];
-    str = eatInner(str, chars);
-    str = eatOuter(str, chars);
-    return str;
-}
-// Plug in the actual version from your project
-function get_alpha_ints(opts) {
-    // REPLACE WITH YOUR REAL IMPLEMENTATION
-    return [];
-}
-/** Python-equivalent eatElse */
-export function eatElse(stringObj, chars, ints = true, alpha = true, lower = true, capitalize = true, string = true, listObj = true) {
-    stringObj = String(stringObj);
-    const alphaInts = get_alpha_ints({
-        ints,
-        alpha,
-        lower,
-        capitalize,
-        string,
-        listObj,
-    });
-    const ls = ensure_list(chars || []).concat(alphaInts);
-    while (true) {
-        if (!stringObj)
-            return stringObj;
-        const startOk = !ls.includes(stringObj[0]);
-        const endOk = !ls.includes(stringObj[stringObj.length - 1]);
-        const shouldEat = startOk || endOk;
-        if (!shouldEat)
-            return stringObj;
-        if (stringObj && startOk) {
-            stringObj = stringObj.length === 1 ? "" : stringObj.slice(1);
-        }
-        if (stringObj && endOk) {
-            stringObj = stringObj.length === 1 ? "" : stringObj.slice(0, -1);
-        }
-    }
-}
-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;
-}
-export function eatall(str, listObjects) {
-    return eatAll(str, listObjects);
-}
-export function eatinner(str, listObjects) {
-    return eatInner(str, listObjects);
-}
-export function eatouter(str, listObjects) {
-    return eatOuter(str, listObjects);
-}

package/dist/types/functions/type_utils/imports.js

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

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

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

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

@@ -1,38 +0,0 @@
-import { ensure_string, ensure_array } from './ensure_utils';
-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;
-    }
-}

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

@@ -1,84 +0,0 @@
-import { parse_nested_list, split_outside_brackets } from './list_utils';
-export function ensure_list(obj) {
-    if (obj == null)
-        return [];
-    if (Array.isArray(obj)) {
-        return obj.flatMap(item => ensure_list(item));
-    }
-    const s = String(obj).trim();
-    if (s.startsWith("[") && s.endsWith("]")) {
-        return parse_nested_list(s);
-    }
-    return split_outside_brackets(s).map(x => x.trim());
-}
-// 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_string(obj) {
-    return String(obj);
-}
-export function ensurelist(obj) {
-    return ensure_list(obj);
-}
-export function assureList(obj) {
-    return ensure_list(obj);
-}
-export function assure_list(obj) {
-    return ensure_list(obj);
-}
-export function ensureList(obj) {
-    return ensure_list(obj);
-}
-export function assurelist(obj) {
-    return ensure_list(obj);
-}
-export function ensurenumber(x) {
-    return ensure_number(x);
-}
-export function assureNumber(x) {
-    return ensure_number(x);
-}
-export function ensureNumber(x) {
-    return ensure_number(x);
-}
-export function assurenumber(x) {
-    return ensure_number(x);
-}
-export function assure_number(x) {
-    return ensure_number(x);
-}
-export function ensurestring(obj) {
-    return ensure_string(obj);
-}
-export function ensureString(obj) {
-    return ensure_string(obj);
-}
-export function assureString(obj) {
-    return ensure_string(obj);
-}
-export function assurestring(obj) {
-    return ensure_string(obj);
-}
-export function assure_string(obj) {
-    return ensure_string(obj);
-}
-export function assurearray(obj) {
-    return ensure_list(obj);
-}
-export function ensurearray(obj) {
-    return ensure_list(obj);
-}
-export function ensure_array(obj) {
-    return ensure_list(obj);
-}
-export function ensureArray(obj) {
-    return ensure_list(obj);
-}
-export function assure_array(obj) {
-    return ensure_list(obj);
-}
-export function assureArray(obj) {
-    return ensure_list(obj);
-}

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

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

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

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

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

@@ -1,93 +0,0 @@
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-import { ensure_array } from './ensure_utils';
-// 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;
-}
-// Create the accountInfo table if it doesn't already exist
-export function findKeyValue(obj, keyToFind) {
-    if (keyToFind in obj)
-        return obj[keyToFind];
-    for (const key in obj) {
-        if (typeof obj[key] === 'object' && obj[key] !== null) {
-            const result = findKeyValue(obj[key], keyToFind);
-            if (result !== undefined)
-                return result;
-        }
-    }
-    return undefined;
-}
-export function omitKeys(obj, ...keys) {
-    const newObj = Object.assign({}, obj);
-    keys.forEach(key => {
-        delete newObj[key];
-    });
-    return newObj;
-}
-/**
-* Extracts necessary properties from the insertValue to prevent circular references.
-*
-* @param insertValue - The original RPC result.
-* @returns A new object with only the required properties.
-*/
-export function extractInsertData(insertValue) {
-    // Example: Suppose you only need certain fields from the transaction
-    // Modify this function based on your actual data structure
-    if (insertValue && typeof insertValue === 'object') {
-        const { transaction } = insertValue, rest = __rest(insertValue, ["transaction"]); // Exclude 'transaction' property
-        return rest;
-    }
-    return insertValue;
-}
-// Recursive function to load nested JSON
-export function loadInnerJson(data) {
-    if (typeof data === 'string') {
-        try {
-            const parsed = JSON.parse(data);
-            return loadInnerJson(parsed);
-        }
-        catch (e) {
-            return data;
-        }
-    }
-    else if (Array.isArray(data)) {
-        return data.map(item => loadInnerJson(item));
-    }
-    else if (typeof data === 'object' && data !== null) {
-        const result = {};
-        for (const key in data) {
-            if (data.hasOwnProperty(key)) {
-                result[key] = loadInnerJson(data[key]);
-            }
-        }
-        return result;
-    }
-    return data;
-}

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

@@ -1,83 +0,0 @@
-export function smart_split(s) {
-    const out = [];
-    let depth = 0;
-    let buf = "";
-    for (let i = 0; i < s.length; i++) {
-        const c = s[i];
-        if (c === "[") {
-            depth++;
-            buf += c;
-            continue;
-        }
-        if (c === "]") {
-            depth--;
-            buf += c;
-            continue;
-        }
-        // Split ONLY when depth === 0
-        if (c === "," && depth === 0) {
-            out.push(buf);
-            buf = "";
-            continue;
-        }
-        buf += c;
-    }
-    if (buf.length > 0)
-        out.push(buf);
-    return out;
-}
-export function split_outside_brackets(s) {
-    let depth = 0;
-    let start = 0;
-    const out = [];
-    for (let i = 0; i < s.length; i++) {
-        const c = s[i];
-        if (c === "[")
-            depth++;
-        else if (c === "]")
-            depth--;
-        // split only when NOT inside brackets
-        if (c === "," && depth === 0) {
-            out.push(s.slice(start, i));
-            start = i + 1;
-        }
-    }
-    out.push(s.slice(start));
-    return out;
-}
-export function smart_split_preserving_lists(s) {
-    let depth = 0;
-    let start = 0;
-    const parts = [];
-    for (let i = 0; i < s.length; i++) {
-        const c = s[i];
-        if (c === "[")
-            depth++;
-        else if (c === "]")
-            depth--;
-        // Split ONLY when depth == 0 AND a comma appears
-        if (c === "," && depth === 0) {
-            parts.push(s.slice(start, i));
-            start = i + 1;
-        }
-    }
-    parts.push(s.slice(start));
-    return parts;
-}
-export function parse_nested_list(s) {
-    // strip outer brackets
-    const inner = s.slice(1, -1).trim();
-    const parts = split_outside_brackets(inner);
-    const result = [];
-    for (let p of parts) {
-        p = p.trim();
-        if (p.startsWith("[") && p.endsWith("]")) {
-            // recursively parse nested list
-            result.push(parse_nested_list(p));
-        }
-        else {
-            result.push(p);
-        }
-    }
-    return result;
-}