@putkoff/abstract-utilities 0.1.243 → 0.1.244

package/dist/functions/auth_utils/imports.js

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

package/dist/functions/auth_utils/index.js

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

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

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

package/dist/functions/auth_utils/src/token_utils.js

@@ -0,0 +1,104 @@
+import { callStorage } from './../imports.js';
+/**
+***Changes**:
+*- Updated import path for `InputProps` to `../../types/interfaces`.
+*
+*3. **Token Utilities** (`src/functions/auth/token_utils.ts`):
+*   Copy from `/var/www/abstractendeavors/my-login-app/src/functions/auth_utils/token_utils.ts`.
+*
+*/
+/** Read raw JWT from LocalStorage (or null if absent) */
+export function getToken() {
+    return callStorage('getItem', 'token');
+}
+export function isLoggedIn() {
+    const tok = getToken();
+    return !!tok && !isTokenExpired(tok !== null && tok !== void 0 ? tok : "");
+}
+export function removeToken() {
+    let is_logged = isLoggedIn();
+    if (is_logged) {
+        callStorage('removeItem', "token");
+    }
+    is_logged = isLoggedIn();
+    if (is_logged) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Add a Bearer Authorization header.
+ * A shallow copy of headers is returned so callers can keep chaining.
+ */
+export function getAuthorizationHeader(headers = {}, token = null) {
+    token = token !== null && token !== void 0 ? token : getToken();
+    headers = headers || {};
+    if (token)
+        headers["Authorization"] = `Bearer ${token}`;
+    return Object.assign({}, headers);
+}
+/** Throw + redirect if there’s no valid token; otherwise return it. */
+export function requireToken() {
+    const tok = getToken();
+    if (!tok || isTokenExpired(tok)) {
+        console.warn("→ No token or expired token, redirecting to login…");
+        removeToken();
+        window.location.href = '/';
+        throw new Error("Redirecting to login…");
+    }
+    return tok;
+}
+/** True if token is structurally bad or its exp ≤ now. */
+export function isTokenExpired(token) {
+    try {
+        const payload = decodeJwt(token);
+        return Date.now() / 1000 >= payload.exp;
+    }
+    catch (_a) {
+        return true; // treat malformed token as expired
+    }
+}
+/** Convenience wrapper: return username from the JWT (or null). */
+export function currentUsername() {
+    const token = getToken();
+    let uName = null;
+    if (token) {
+        const decodedJwt = decodeJwt(token) || {};
+        uName = (decodedJwt === null || decodedJwt === void 0 ? void 0 : decodedJwt.username) || null;
+    }
+    return uName;
+}
+export function currentUsernames() {
+    var _a;
+    const tok = getToken();
+    if (!tok)
+        return null;
+    try {
+        const parts = tok.split(".");
+        if (parts.length !== 3)
+            return null;
+        let b64 = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+        b64 = b64.padEnd(Math.ceil(b64.length / 4) * 4, "=");
+        const jsonText = atob(b64);
+        const payload = JSON.parse(jsonText);
+        return (_a = payload.username) !== null && _a !== void 0 ? _a : null;
+    }
+    catch (_b) {
+        return null;
+    }
+}
+/* ------------------------------------------------------------------ */
+/*  internals                                                         */
+/* ------------------------------------------------------------------ */
+export function decodeJwt(token) {
+    const [header, payload, signature] = token.split(".");
+    if (!header || !payload || !signature) {
+        throw new Error("Malformed JWT");
+    }
+    // Handle URL-safe Base64
+    let b64 = payload.replace(/-/g, "+").replace(/_/g, "/");
+    // Add padding if necessary
+    b64 = b64.padEnd(Math.ceil(b64.length / 4) * 4, "=");
+    const jsonText = atob(b64);
+    return JSON.parse(jsonText);
+}

package/dist/functions/config_utils/imports.js

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

package/dist/functions/config_utils/index.js

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

package/dist/functions/config_utils/src/config_utils.js

@@ -0,0 +1,16 @@
+// src/functions/config_utils/src/config_utils.ts
+import { __awaiter } from "tslib";
+import { readJsonFile } from "../imports.js";
+/**
+ * Attempt to load config.json if present, otherwise return empty object.
+ */
+export function getConfigJson() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            return (yield readJsonFile('config.json')) || {};
+        }
+        catch (_a) {
+            return {};
+        }
+    });
+}

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

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

package/dist/functions/constants_utils/index.js

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

package/dist/functions/constants_utils/src/constants.js

@@ -0,0 +1,7 @@
+export const PROTOCOL = 'https://';
+export const DOMAIN_NAME = 'abstractendeavors';
+export const BASE_URL = `${PROTOCOL}${DOMAIN_NAME}.com`;
+export const SUB_DIR = 'secure-files';
+export const PROD_PREFIX = `/${SUB_DIR}/`;
+export const API_PREFIX = `/${SUB_DIR}/api`;
+export const DEV_PREFIX = `/${SUB_DIR}-dev/`;

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

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

package/dist/functions/env_utils/imports.js

@@ -0,0 +1 @@
+export { BASE_URL, DEV_PREFIX } from './../constants_utils/index';

package/dist/functions/env_utils/index.js

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

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

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

package/dist/functions/env_utils/src/window_utils.js

@@ -0,0 +1,47 @@
+import { BASE_URL, DEV_PREFIX } from './../imports.js';
+export function get_window() {
+    try {
+        if (typeof window !== 'undefined') {
+            return window;
+        }
+    }
+    catch (err) {
+        alert(err);
+    }
+    return null;
+}
+export function get_window_location() {
+    try {
+        const Window = get_window();
+        if (!Window) {
+            return BASE_URL;
+        }
+        return Window.location;
+    }
+    catch (err) {
+        alert(err);
+    }
+    return null;
+}
+export function get_window_pathname() {
+    try {
+        const Window = get_window();
+        if (!Window) {
+            return DEV_PREFIX;
+        }
+        return Window.location.pathname;
+    }
+    catch (err) {
+        alert(err);
+    }
+    return null;
+}
+export function get_window_parts() {
+    try {
+        return get_window_location();
+    }
+    catch (err) {
+        alert(err);
+    }
+    return null;
+}

package/dist/functions/fetch_utils/imports.js

@@ -0,0 +1,2 @@
+export { getAuthorizationHeader, getToken } from "./../auth_utils";
+export { readJsonFile, getConfigContent } from './../read_utils';

package/dist/functions/fetch_utils/index.js

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

package/dist/functions/fetch_utils/src/fetch_utils.js

@@ -0,0 +1,65 @@
+import { __awaiter } from "tslib";
+import { getAuthorizationHeader } from './../imports.js';
+import { getResult, parseResult } from './utils.js';
+export function fetchIt(endpoint_1) {
+    return __awaiter(this, arguments, void 0, function* (endpoint, body = null, method = null, headers = null, blob = false, configUrl = false, withCredentials = true, returnJson = true, returnResult = true) {
+        method = (method || "GET").toUpperCase();
+        // 1) auto-detect absolute URLs
+        const isAbsolute = typeof endpoint === "string" && /^https?:\/\//i.test(endpoint);
+        // 2) choose the URL
+        let url = endpoint;
+        // 3) prepare headers & body
+        headers = Object.assign(Object.assign(Object.assign({}, (body instanceof FormData ? {} : { "Content-Type": "application/json" })), getAuthorizationHeader()), headers);
+        const opts = {
+            method,
+            credentials: withCredentials ? "include" : "same-origin",
+            headers,
+            body: body instanceof FormData
+                ? body
+                : body != null && method !== "GET"
+                    ? JSON.stringify(body)
+                    : undefined,
+        };
+        let res = yield fetch(url, opts);
+        if (!res.ok) {
+            const err = yield res.text();
+            throw new Error(`HTTP ${res.status}: ${err}`);
+        }
+        if (blob)
+            return res.blob();
+        if (returnResult || returnJson) {
+            let JsonRes = parseResult(res);
+            if (returnResult) {
+                JsonRes = getResult(JsonRes);
+            }
+            return JsonRes;
+        }
+        return res;
+    });
+}
+// Constructs HTML directory path
+export function getHtmlDirectory(directory, filename) {
+    return `${directory}/${filename}.html`;
+}
+// Fetches HTML content
+export function fetchIndexHtml(filename_1) {
+    return __awaiter(this, arguments, void 0, function* (filename, directory = 'sf_index', base = 'html') {
+        const url = `/${base}/${directory}/${filename}.html`;
+        const response = yield fetch(url);
+        return yield response.text();
+    });
+}
+// Fetches and injects HTML content into container
+export function fetchIndexHtmlContainer(filename_1) {
+    return __awaiter(this, arguments, void 0, function* (filename, doc = document, directory = 'html') {
+        const container = `${filename}-container`;
+        const html = yield fetchIndexHtml(filename, directory);
+        const el = doc.getElementById(container);
+        if (el) {
+            el.innerHTML = html;
+        }
+        else {
+            console.warn(`⚠️ No container found for: #${container}`);
+        }
+    });
+}

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

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

package/dist/functions/fetch_utils/src/url_utils.js

@@ -0,0 +1,83 @@
+import path from 'path';
+export function urlJoin(...parts) {
+    var _a;
+    const s = (parts.length === 1 && Array.isArray(parts[0]) ? parts[0] : parts);
+    let r = "";
+    for (let i = 0; i < s.length; i++) {
+        let d = ((_a = s[i]) !== null && _a !== void 0 ? _a : "").toString();
+        if (!d)
+            continue;
+        if (i === 0)
+            r = d;
+        else {
+            d = d.replace(/^\/+/, "");
+            r = r.replace(/\/+$/, "");
+            r = `${r}/${d}`;
+        }
+    }
+    return r;
+}
+/**
+ * Returns a full URL.
+ * If partial_url is already absolute (starts with http), it is returned as is.
+ * Otherwise, it is combined with the base URL.
+ */
+export function get_full_url(partial_url, domain = null) {
+    if (typeof partial_url !== 'string') {
+        throw new Error('partial_url must be a string');
+    }
+    // If it already starts with http, assume it is absolute.
+    if (partial_url.startsWith('http')) {
+        return partial_url;
+    }
+    return urlJoin(domain, partial_url);
+}
+/**
+ * Returns a full file system path.
+ * If partial_path is already absolute, it is returned as is.
+ * Otherwise, it is joined with the base directory.
+ */
+export function get_full_path(partial_path, parent_dir = null) {
+    if (typeof partial_path !== 'string') {
+        throw new Error('partial_path must be a string');
+    }
+    if (path.isAbsolute(partial_path)) {
+        return partial_path;
+    }
+    return urlJoin(parent_dir, partial_path);
+}
+/**
+ * Converts a local file system path into its corresponding URL.
+ * It checks against the known directories in all_paths and replaces the matching base.
+ */
+export function path_to_url(filePath, all_paths) {
+    if (typeof filePath !== 'string') {
+        throw new Error('filePath must be a string');
+    }
+    for (const key in all_paths) {
+        const mapping = all_paths[key];
+        const normalizedBase = path.normalize(mapping.path);
+        if (filePath.startsWith(normalizedBase)) {
+            const relativePath = filePath.substring(normalizedBase.length);
+            return urlJoin(mapping.url, relativePath.replace(/\\/g, '/'));
+        }
+    }
+    return null;
+}
+/**
+ * Converts a URL into its corresponding local file system path.
+ * It checks against the known URL prefixes in all_paths and replaces the matching base.
+ */
+export function url_to_path(urlStr, all_paths) {
+    if (typeof urlStr !== 'string') {
+        throw new Error('urlStr must be a string');
+    }
+    for (const key in all_paths) {
+        const mapping = all_paths[key];
+        if (urlStr.startsWith(mapping.url)) {
+            const relativeUrl = urlStr.substring(mapping.url.length);
+            return urlJoin(mapping.path, relativeUrl);
+        }
+    }
+    return null;
+}

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

@@ -0,0 +1,101 @@
+import { __awaiter } from "tslib";
+import { getAuthorizationHeader, getToken } from './../imports.js';
+/**
+ * Unwraps nested { result } fields until you hit a non-object or no more "result" keys.
+ */
+export function getResult(obj) {
+    let current = obj;
+    while (current &&
+        typeof current === "object" &&
+        Object.prototype.hasOwnProperty.call(current, "result")) {
+        current = current.result;
+    }
+    return current;
+}
+export const get_result = getResult;
+// Determines HTTP method, defaults to GET or POST based on body
+export function getMethod(method = null, body = null) {
+    const validMethods = ['GET', 'POST', 'PUT', 'PATCH', 'PULL'];
+    method = (method || '').toUpperCase();
+    if (!validMethods.includes(method)) {
+        method = body ? 'POST' : 'GET';
+    }
+    return method;
+}
+// Gets headers, skips JSON headers when body is FormData
+export function getHeaders(headers = {}, method = null, body = null) {
+    const result = Object.assign({}, headers);
+    // inject auth if missing
+    if (!result.Authorization) {
+        const token = getToken();
+        Object.assign(result, getAuthorizationHeader(result, token));
+    }
+    method = getMethod(method, body);
+    // if it’s a multipart FormData, let the browser set the boundary header
+    if (body instanceof FormData) {
+        return result;
+    }
+    // otherwise for POST/PUT/PATCH default to JSON
+    if (['POST', 'PUT', 'PATCH'].includes(method) && !result['Content-Type']) {
+        result['Content-Type'] = 'application/json';
+    }
+    return result;
+}
+// Prepares request body, serializes to JSON for non-GET requests
+export function getBody(body = null, method = null) {
+    method = getMethod(method, body);
+    if (method === 'GET') {
+        return undefined;
+    }
+    if (body) {
+        try {
+            return JSON.stringify(body);
+        }
+        catch (err) {
+            return body;
+        }
+    }
+    return undefined;
+}
+// Prepares fetch variables, passes FormData intact
+export function getFetchVars(headers = null, method = null, body = null) {
+    method = getMethod(method, body);
+    headers = getHeaders(headers || {}, method, body);
+    // only JSON-stringify non-FormData bodies
+    if (!(body instanceof FormData)) {
+        body = getBody(body, method);
+    }
+    return { method, headers, body };
+}
+/*
+ * parseResult no longer needs to worry about JSON vs HTML redirect errors;
+ * all 401/403 have already been handled above.
+ */
+export function parseResult(res) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // runs checkResponse first, will throw if session is expired
+        res = checkResponse(res);
+        if (!res.ok) {
+            // for any other non-401 errors, you can still surface them
+            const errorText = yield res.text();
+            throw new Error(errorText || res.statusText);
+        }
+        // now safely parse JSON
+        return res.json();
+    });
+}
+/**
+ * Intercept 401/403 and force a clean redirect to login
+ * without ever showing an alert.
+ */
+export function checkResponse(res) {
+    if (res.status === 401 || res.status === 403) {
+        // 1) clear out the stale token
+        localStorage.removeItem("token");
+        // 2) replace history so "back" doesn’t re-trigger the protected route
+        window.history.replaceState({}, "", "/secure-files");
+        // 3) short-circuit all further fetch logic
+        throw new Error("SessionExpired");
+    }
+    return res;
+}

package/dist/functions/index.js

@@ -0,0 +1,17 @@
+export { useCallback, useRef, useState, useEffect } from "react";
+export * from './auth_utils';
+export * from './constants_utils';
+export * from './env_utils';
+export * from './fetch_utils';
+export * from './path_utils';
+export * from './rndm_utils';
+export * from './string_utils';
+export * from './type_utils';
+export * from './ui_utils';
+export * from './config_utils';
+export * from './read_utils';
+export * from './safe_utils';
+export * from './read_utils';
+export * from './variable_utils';
+export * from './math_utils';
+export * from './url_utils';

package/dist/functions/math_utils/index.js

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

package/dist/functions/math_utils/safe_math.js

@@ -0,0 +1,26 @@
+import { ensure_number } from './../type_utils/index.js';
+// take N args and coerce them all to numbers
+export function safeNums(...args) {
+    return args.map(ensure_number);
+}
+// divide the first value by each of the following
+export function safeDivide(...args) {
+    const [head, ...rest] = safeNums(...args);
+    // if we don’t have a head or any divisor is zero, bail
+    if (head === 0 || rest.some((d) => d === 0))
+        return 0;
+    return rest.reduce((acc, d) => acc / d, head);
+}
+// multiply all the values together
+export function safeMultiply(...args) {
+    const nums = safeNums(...args);
+    // if any number is zero, result is zero
+    if (nums.includes(0))
+        return 0;
+    return nums.reduce((acc, n) => acc * n, 1);
+}
+// round a value to two decimals by percent
+export function roundPercentage(x) {
+    const pct = safeMultiply(ensure_number(x), 100);
+    return safeDivide(Math.round(pct), 100);
+}

package/dist/functions/path_utils/imports.js

@@ -0,0 +1,28 @@
+/**
+ * In the browser we already have a WHATWG URL constructor on window.
+ * Here we re-export it as “url” so other modules can import it.
+ */
+const _url = typeof window !== 'undefined' ? window.URL : undefined;
+export { _url as url };
+/**
+ * Minimal fileURLToPath implementation for browser-side code.
+ * If you only ever need to strip off “file://” in development, this is enough.
+ */
+export function fileURLToPath(fileUrl) {
+    // e.g. fileUrl = "file:///Users/foo/bar.txt"
+    try {
+        const u = new URL(fileUrl);
+        return u.pathname;
+    }
+    catch (_a) {
+        // fallback: just strip file://
+        return fileUrl.replace(/^file:\/\//, '');
+    }
+}
+export { eatOuter, eatInner } from './../string_utils';
+export { ensure_list } from './../type_utils';
+export function getAbsolutePath() {
+    if (typeof window !== 'undefined')
+        return '';
+    return fileURLToPath(import.meta.url);
+}

package/dist/functions/path_utils/index.js

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

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

@@ -0,0 +1,17 @@
+import { make_path, get_dirname } from './path_utils.js';
+import { getSrcDir } from './src_dirs.js';
+export function getBaseDir() {
+    return get_dirname(getSrcDir());
+}
+export function getPublicDir() {
+    return make_path(getBaseDir(), 'public');
+}
+;
+export function getDistDir() {
+    return make_path(getBaseDir(), 'dist');
+}
+;
+export function getEnvDir() {
+    return make_path(getBaseDir(), '.env');
+}
+;

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

@@ -0,0 +1,42 @@
+import { make_path, get_dirname } from './path_utils.js';
+import { getAbsDir } from './paths.js';
+export function getFunctionsDir() {
+    return get_dirname(getAbsDir());
+}
+;
+export function geAuthsUtilsDirectory() {
+    return make_path(getFunctionsDir(), 'auths');
+}
+;
+export function geBackupsUtilsDirectory() {
+    return make_path(getFunctionsDir(), 'backups');
+}
+;
+export function geConstantsUtilsDirectory() {
+    return make_path(getFunctionsDir(), 'constants');
+}
+;
+export function geEnvUtilsDirectory() {
+    return make_path(getFunctionsDir(), 'env_utils');
+}
+;
+export function geFetchUtilsDirectory() {
+    return make_path(getFunctionsDir(), 'fetch_utils');
+}
+;
+export function geFileUtilsDirectory() {
+    return make_path(getFunctionsDir(), 'file_utils');
+}
+;
+export function gePathUtilsDirectory() {
+    return make_path(getFunctionsDir(), 'path_utils');
+}
+;
+export function geStringUtilsDirectory() {
+    return make_path(getFunctionsDir(), 'string_utils');
+}
+;
+export function geTypeUtilsDirectory() {
+    return make_path(getFunctionsDir(), 'type_utils');
+}
+;

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

@@ -0,0 +1,6 @@
+export * from './path_utils';
+export * from './paths';
+export * from './function_dirs';
+export * from './src_dirs';
+export * from './base_dirs';
+export * from './misc_dirs';

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

@@ -0,0 +1,15 @@
+import { getBaseDir, getEnvDir } from './base_dirs.js';
+import { make_path } from './path_utils.js';
+export function getEnvPath(string = '.env') {
+    return make_path(getEnvDir(), string);
+}
+;
+export function getDbConfigsPath() {
+    return make_path(getBaseDir(), 'dbConfigs');
+}
+export function getSchemasPath() {
+    return make_path(getDbConfigsPath(), 'schemas');
+}
+export function getSchemasDirPath(subPath) {
+    return make_path(getSchemasPath(), subPath);
+}

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

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