@putkoff/abstract-utilities 0.1.118 → 0.1.122

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

@@ -0,0 +1,95 @@
+/**
+***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`.
+*
+*/
+export function isLoggedIn() {
+    const tok = localStorage.getItem("token");
+    return !!tok && !isTokenExpired(tok !== null && tok !== void 0 ? tok : "");
+}
+/** Read raw JWT from LocalStorage (or null if absent) */
+export function getToken() {
+    return localStorage.getItem("token");
+}
+/**
+ * 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…");
+        localStorage.removeItem("token");
+        window.location.href = '/login';
+        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 tok = getToken();
+    if (!tok)
+        return null;
+    try {
+        const { username } = decodeJwt(tok);
+        return username !== null && username !== void 0 ? username : null;
+    }
+    catch (_a) {
+        return null;
+    }
+}
+export function currentUsernames() {
+    var _a;
+    const tok = localStorage.getItem("token");
+    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 @@
+export {};

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,33 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+let _cachedConfig = null;
+function loadConfig() {
+    return __awaiter(this, arguments, void 0, function* (filePath = null) {
+        // 1. If nobody passed a custom path, we default to "config.json" (relative)
+        const relativePath = filePath || 'config.json';
+        // 2. Resolve it against the running page’s URL (document.baseURI)
+        const configUrl = new URL(relativePath, document.baseURI).href;
+        // 3. Fetch + cache
+        if (_cachedConfig)
+            return _cachedConfig;
+        const res = yield fetch(configUrl);
+        if (!res.ok) {
+            throw new Error(`Could not fetch ${configUrl}: ${res.status}`);
+        }
+        _cachedConfig = (yield res.json());
+        return _cachedConfig;
+    });
+}
+export function getConfig(key) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const cfg = yield loadConfig();
+        return key ? cfg[key] : cfg;
+    });
+}

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';
+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.d.ts

@@ -4,5 +4,5 @@ export { stripPrefixes } from './../string_utils';
 export { alertit } from './../rndm_utils';
 export { ensure_list } from './../type_utils';
 export { eatInner } from './../string_utils';
-export type { LogoutButtonProps, FetchVariables } from './../../types';
+export type { LogoutButtonProps, FetchVariables, AppConfig } from './../../types';
 export { getConfig } from './../config_utils';

package/dist/functions/fetch_utils/imports.js

@@ -0,0 +1,7 @@
+export { getAuthorizationHeader } from "./../auth_utils";
+export { make_path } from './../path_utils';
+export { stripPrefixes } from './../string_utils';
+export { alertit } from './../rndm_utils';
+export { ensure_list } from './../type_utils';
+export { eatInner } from './../string_utils';
+export { getConfig } from './../config_utils';

package/dist/functions/fetch_utils/index.js

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

package/dist/functions/fetch_utils/src/fetchIt_utils.d.ts

@@ -7,7 +7,7 @@
 *
 */
 /** Pulls base-URL from AppConfig.API_BASE_URL, strips trailing slashes */
-export declare function get_app_config_url(endpoint: any, appKey?: any): Promise<string>;
+export declare function get_app_config_url(endpoint: string, appKey?: any): Promise<string>;
 export declare function fetchIt(endpoint: string, body?: unknown, method?: string | null, headers?: Record<string, string> | null, blob?: boolean | null, no_api?: boolean, requireAuth?: boolean): Promise<unknown>;
 export declare function secureFetchIt<T>(endpoint: any, body?: any, method?: any, headers?: Record<string, string> | null, blob?: boolean, noApi?: boolean, withCredentials?: boolean, returnJson?: boolean, returnReult?: boolean): Promise<T>;
 export declare function secureFetchIt(endpoint: any, body?: any, method?: any, headers?: Record<string, string> | null, blob?: boolean, noApi?: boolean, withCredentials?: boolean, returnJson?: boolean, returnReult?: boolean): Promise<Blob>;

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

@@ -0,0 +1,116 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { getFetchVars, checkResponse, api, parseResult, ensureAbstractUrl, getResult } from './utils';
+import { getAuthorizationHeader, getConfig } from './../imports';
+/**
+
+***Changes**: None, as it’s self-contained and doesn’t rely on external imports.
+*
+*4. **secureFetchIt** (`src/functions/fetch/secureFetchIt.ts`):
+*   Since `secureFetchIt` isn’t provided, we’ll create a minimal implementation based on its usage in `Login` and `uploadFiles`. It’s assumed to be a wrapper around `fetch` that handles authentication and JSON parsing.
+*
+*/
+/** Pulls base-URL from AppConfig.API_BASE_URL, strips trailing slashes */
+// src/functions/fetch/secureFetchIt.ts
+// --- fetch_utils/src/fetch_utils.ts ----------------------------
+export function get_app_config_url(endpoint_1) {
+    return __awaiter(this, arguments, void 0, function* (endpoint, appKey = 'BASE_API_URL') {
+        const cleanEndpoint = endpoint.replace(/^\/+/, '');
+        console.log(`cleanEndpoint == ${cleanEndpoint}`);
+        const config = yield getConfig();
+        console.log(`config == ${config}`);
+        const baseUrl = JSON.stringify(config);
+        console.log(`baseUrl == ${baseUrl}`);
+        appKey = appKey || 'BASE_API_URL';
+        console.log(`appKey == ${appKey}`);
+        const base = baseUrl[appKey]; // full AppConfig object
+        console.log(`base == ${base}`);
+        const slices = base.split('/').filter(Boolean);
+        console.log(`slices == ${slices}`);
+        return ensureAbstractUrl(cleanEndpoint, slices);
+    });
+}
+export function fetchIt(endpoint_1) {
+    return __awaiter(this, arguments, void 0, function* (endpoint, body = null, method = null, headers = null, blob = null, no_api = false, requireAuth = true) {
+        const vars = getFetchVars(headers, method, body);
+        const url = no_api ? endpoint : api(endpoint);
+        const res = yield fetch(url, vars);
+        return blob ? (checkResponse(res), res.blob()) : yield parseResult(res);
+    });
+}
+export function secureFetchIt(endpoint_1) {
+    return __awaiter(this, arguments, void 0, function* (endpoint, body = null, method = null, customHeaders = null, blob = false, noApi = false, withCredentials = true, returnJson = true, returnReult = true) {
+        // strip leading slashes off the endpoint
+        method = method || "GET";
+        let url = endpoint;
+        if (!noApi) {
+            url = yield get_app_config_url(endpoint);
+        }
+        // headers: JSON by default, plus any auth + overrides
+        const headers = Object.assign(Object.assign(Object.assign({}, (body instanceof FormData ? {} : { "Content-Type": "application/json" })), getAuthorizationHeader()), customHeaders);
+        const opts = {
+            method: method.toUpperCase(),
+            credentials: withCredentials ? "include" : "same-origin",
+            headers,
+            body: body instanceof FormData
+                ? body
+                : body != null && method.toUpperCase() !== "GET"
+                    ? JSON.stringify(body)
+                    : undefined,
+        };
+        console.debug("➡️ secureFetchIt →", url, opts);
+        const 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 (returnReult)
+            return getResult(res.json());
+        if (returnJson)
+            return res.json();
+        return res;
+    });
+}
+// Performs PATCH request
+export function requestPatch(url_1) {
+    return __awaiter(this, arguments, void 0, function* (url, body = null) {
+        const variables = getFetchVars(null, 'PATCH', body);
+        return yield fetch(api(url), variables);
+    });
+}
+// Performs PATCH request for file sharing
+export function fetchSharePatch(file_1) {
+    return __awaiter(this, arguments, void 0, function* (file, appKey = null) {
+        const cleanEndpoint = '/files/share';
+        // build final URL
+        const url = yield get_app_config_url(cleanEndpoint);
+        const token = localStorage.getItem('token');
+        const body = JSON.stringify(file);
+        const method = 'PATCH';
+        const headers = {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${token}`,
+        };
+        const resp = yield fetch(url, {
+            method,
+            headers,
+            body
+        });
+        if (!resp.ok) {
+            console.error('Error from server', yield resp.text());
+        }
+        else {
+            const data = yield resp.json();
+            console.log('Success!', data);
+        }
+    });
+}

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

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

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

@@ -0,0 +1,171 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { eatInner, stripPrefixes, make_path, getAuthorizationHeader, ensure_list } from './../imports';
+export function ensureAbstractUrl(endpoint, slices = []) {
+    slices = ['https//thedailydialectics.com', 'api', 'secure-files'];
+    // 1) build a prefix string like "api/v1/"
+    const prefix = slices.map((s) => `${s}/`).join("");
+    // 2) normalize the list you’ll use for stripping
+    const normalized = ["/", ...ensure_list(slices)];
+    // 3) remove any inner “/” duplicates from prefix
+    const target = eatInner(prefix, ["/"]);
+    // 4) drop any of those prefixes off the endpoint
+    const strippedEndpoint = stripPrefixes(endpoint, normalized);
+    // 5) hand it back to make_path to join “target” + “strippedEndpoint”
+    return make_path(target, strippedEndpoint);
+}
+/**
+ * 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;
+}
+// Constructs API URL from endpoint
+export function api(endpoint) {
+    return ensureAbstractUrl(endpoint);
+}
+// Checks if response is OK, handles 401/403 by redirecting to login
+export function checkResponse(res) {
+    if (!res.ok) {
+        if (res.status === 401 || res.status === 403) {
+            alert('Session expired. Please log in again.');
+            localStorage.removeItem('token');
+            window.location.href = '/secure-files/login';
+        }
+    }
+    return res;
+}
+// Parses JSON response and handles specific response shapes
+export function parseResult(res) {
+    return __awaiter(this, void 0, void 0, function* () {
+        res = checkResponse(res);
+        try {
+            const data = yield res.json();
+            if ((data === null || data === void 0 ? void 0 : data.success) === true && Array.isArray(data.result)) {
+                return data.result;
+            }
+            if ((data === null || data === void 0 ? void 0 : data.message) && typeof data.message === 'string') {
+                alert(`Error: ${data.message}`);
+            }
+            return data;
+        }
+        catch (err) {
+            throw new Error('Server returned invalid JSON');
+        }
+    });
+}
+// 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 = localStorage.getItem('token');
+        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 };
+}
+function tryParse(obj) {
+    try {
+        obj = JSON.stringify(obj);
+    }
+    catch (err) {
+        try {
+            obj = JSON.parse(obj);
+        }
+        catch (err) {
+        }
+    }
+    return obj;
+}
+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;
+}
+// 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(api(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/index.js

@@ -0,0 +1,12 @@
+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';

package/dist/functions/path_utils/imports.d.ts

@@ -2,14 +2,15 @@
  * 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.
  */
-export declare const url: {
+declare const _url: {
     new (url: string | URL, base?: string | URL): URL;
     prototype: URL;
     canParse(url: string | URL, base?: string | URL): boolean;
     createObjectURL(obj: Blob | MediaSource): string;
     parse(url: string | URL, base?: string | URL): URL | null;
     revokeObjectURL(url: string): void;
-};
+} | 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.

package/dist/functions/path_utils/imports.js

@@ -0,0 +1,26 @@
+/**
+ * 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.
+ */
+export const url = window.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() {
+    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';
+import { getSrcDir } from './src_dirs';
+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');
+}
+;