@putkoff/abstract-utilities 1.0.102 → 1.0.113

package/dist/types/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/types/functions/safe_utils/src/safe_storage.js

@@ -0,0 +1,50 @@
+import { safeGlobalProp } from './safe_globals';
+/**
+ * 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 {
+        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;
+        return store[method](...args);
+    }
+    catch (_a) {
+        return undefined;
+    }
+}

package/dist/types/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/types/functions/size_utils/index.d.ts

@@ -1 +1 @@
-export * from './src';
+export * from './src/index.js';

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

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

package/dist/types/functions/size_utils/src/index.d.ts

@@ -1 +1 @@
-export * from './sizeUtils';
+export * from './sizeUtils.js';

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

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

package/dist/types/functions/size_utils/src/sizeUtils.js

@@ -0,0 +1,44 @@
+// Function to compare MB
+export function exceedsMbLimit(limitMb, payloadMb) {
+    return payloadMb > limitMb;
+}
+export function safeJsonSizeInMb(value) {
+    const seen = new WeakSet();
+    const json = JSON.stringify(value, (_, v) => {
+        if (typeof v === "bigint")
+            return v.toString();
+        if (typeof v === "object" && v !== null) {
+            if (seen.has(v))
+                return "[Circular]";
+            seen.add(v);
+        }
+        return v;
+    });
+    return Buffer.byteLength(json, "utf8") / (1024 * 1024);
+}
+export function dataSizeInMb(data) {
+    const size = typeof data === "string"
+        ? Buffer.byteLength(data, "utf8")
+        : Buffer.byteLength(JSON.stringify(data), "utf8");
+    return size / (1024 * 1024);
+}
+export function getJsonSizeInMb(json) {
+    return Buffer.byteLength(JSON.stringify(json), "utf8") / (1024 * 1024);
+}
+// Function to calculate data size in KB
+export function dataSize(data) {
+    let size = 0;
+    if (typeof data === 'string') {
+        size = Buffer.byteLength(data, 'utf8');
+    }
+    else if (Buffer.isBuffer(data)) {
+        size = data.length;
+    }
+    else if (typeof data === 'object') {
+        size = Buffer.byteLength(JSON.stringify(data), 'utf8');
+    }
+    else {
+        size = Buffer.byteLength(String(data), 'utf8');
+    }
+    return size / 1000; // Convert to kilobytes
+}

package/dist/types/functions/string_utils/index.d.ts

@@ -1 +1 @@
-export * from './src';
+export * from './src/index.js';

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

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

package/dist/types/functions/string_utils/src/index.d.ts

@@ -1,2 +1,2 @@
-export * from './string_utils';
-export * from './quote_utils';
+export * from './string_utils.js';
+export * from './quote_utils.js';

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

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

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

@@ -0,0 +1,17 @@
+/**
+ * Checks if a value is enclosed in quotes.
+ */
+export function ends_in_quotes(value) {
+    if (typeof value === 'string') {
+        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+            return true;
+        }
+    }
+    return false;
+}
+export function stripQuotes(value) {
+    if (ends_in_quotes(value)) {
+        return value.slice(1, -1); // Remove the first and last characters
+    }
+    return value; // Return the input unchanged for all other cases
+}

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

@@ -0,0 +1,186 @@
+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.d.ts

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

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

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

package/dist/types/functions/type_utils/index.d.ts

@@ -1 +1 @@
-export * from './src';
+export * from './src/index.js';

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

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

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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,84 @@
+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.d.ts

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

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

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

package/dist/types/functions/type_utils/src/index.d.ts

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

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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,93 @@
+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;
+}