@putkoff/abstract-utilities 0.0.3

package/dist/esm/index.js

@@ -0,0 +1,1678 @@
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { useCallback, useState, useEffect } from 'react';
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __rest(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;
+}
+
+function __awaiter(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());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+let AppConfig;
+function loadConfig() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const base = (process.env.PUBLIC_URL || "").replace(/\/+$/, "");
+        const url = `${base}/config.json`;
+        const res = yield fetch(url);
+        if (!res.ok)
+            throw new Error(`Failed to load ${url}: ${res.status}`);
+        AppConfig = yield res.json();
+    });
+}
+
+/** Helper function to trigger file download */
+function triggerDownload(blob, filename) {
+    const url = URL.createObjectURL(blob);
+    const a = Object.assign(document.createElement("a"), {
+        href: url,
+        download: filename,
+    });
+    document.body.appendChild(a);
+    a.click();
+    a.remove();
+    URL.revokeObjectURL(url);
+    console.log(`✅ Successfully downloaded: ${filename}`);
+}
+
+/** Non-React “direct download” used by some old links (kept for parity) */
+function directDownload(relPath, filename) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const token = localStorage.getItem("token");
+        if (!token)
+            throw new Error("No auth token found");
+        const res = yield fetch("/secure-files/download", {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${token}`,
+                "Content-Type": "application/json",
+                Accept: "application/octet-stream",
+            },
+            body: JSON.stringify({ rel_path: relPath }),
+        });
+        if (!res.ok)
+            throw new Error(`Download failed: ${res.status}`);
+        const blob = yield res.blob();
+        triggerDownload(blob, filename);
+    });
+}
+
+/**
+***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`.
+*
+*/
+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) */
+function getToken() {
+    return localStorage.getItem("token");
+}
+/**
+ * Add a Bearer Authorization header.
+ * A shallow copy of headers is returned so callers can keep chaining.
+ */
+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. */
+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. */
+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). */
+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;
+    }
+}
+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                                                         */
+/* ------------------------------------------------------------------ */
+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);
+}
+
+function assertPath(path) {
+  if (typeof path !== 'string') {
+    throw new TypeError('Path must be a string. Received ' + JSON.stringify(path));
+  }
+}
+
+// Resolves . and .. elements in a path with directory names
+function normalizeStringPosix(path, allowAboveRoot) {
+  var res = '';
+  var lastSegmentLength = 0;
+  var lastSlash = -1;
+  var dots = 0;
+  var code;
+  for (var i = 0; i <= path.length; ++i) {
+    if (i < path.length)
+      code = path.charCodeAt(i);
+    else if (code === 47 /*/*/)
+      break;
+    else
+      code = 47 /*/*/;
+    if (code === 47 /*/*/) {
+      if (lastSlash === i - 1 || dots === 1) ; else if (lastSlash !== i - 1 && dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 /*.*/ || res.charCodeAt(res.length - 2) !== 46 /*.*/) {
+          if (res.length > 2) {
+            var lastSlashIndex = res.lastIndexOf('/');
+            if (lastSlashIndex !== res.length - 1) {
+              if (lastSlashIndex === -1) {
+                res = '';
+                lastSegmentLength = 0;
+              } else {
+                res = res.slice(0, lastSlashIndex);
+                lastSegmentLength = res.length - 1 - res.lastIndexOf('/');
+              }
+              lastSlash = i;
+              dots = 0;
+              continue;
+            }
+          } else if (res.length === 2 || res.length === 1) {
+            res = '';
+            lastSegmentLength = 0;
+            lastSlash = i;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          if (res.length > 0)
+            res += '/..';
+          else
+            res = '..';
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0)
+          res += '/' + path.slice(lastSlash + 1, i);
+        else
+          res = path.slice(lastSlash + 1, i);
+        lastSegmentLength = i - lastSlash - 1;
+      }
+      lastSlash = i;
+      dots = 0;
+    } else if (code === 46 /*.*/ && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+
+function _format(sep, pathObject) {
+  var dir = pathObject.dir || pathObject.root;
+  var base = pathObject.base || (pathObject.name || '') + (pathObject.ext || '');
+  if (!dir) {
+    return base;
+  }
+  if (dir === pathObject.root) {
+    return dir + base;
+  }
+  return dir + sep + base;
+}
+
+var posix = {
+  // path.resolve([from ...], to)
+  resolve: function resolve() {
+    var resolvedPath = '';
+    var resolvedAbsolute = false;
+    var cwd;
+
+    for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+      var path;
+      if (i >= 0)
+        path = arguments[i];
+      else {
+        if (cwd === undefined)
+          cwd = process.cwd();
+        path = cwd;
+      }
+
+      assertPath(path);
+
+      // Skip empty entries
+      if (path.length === 0) {
+        continue;
+      }
+
+      resolvedPath = path + '/' + resolvedPath;
+      resolvedAbsolute = path.charCodeAt(0) === 47 /*/*/;
+    }
+
+    // At this point the path should be resolved to a full absolute path, but
+    // handle relative paths to be safe (might happen when process.cwd() fails)
+
+    // Normalize the path
+    resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
+
+    if (resolvedAbsolute) {
+      if (resolvedPath.length > 0)
+        return '/' + resolvedPath;
+      else
+        return '/';
+    } else if (resolvedPath.length > 0) {
+      return resolvedPath;
+    } else {
+      return '.';
+    }
+  },
+
+  normalize: function normalize(path) {
+    assertPath(path);
+
+    if (path.length === 0) return '.';
+
+    var isAbsolute = path.charCodeAt(0) === 47 /*/*/;
+    var trailingSeparator = path.charCodeAt(path.length - 1) === 47 /*/*/;
+
+    // Normalize the path
+    path = normalizeStringPosix(path, !isAbsolute);
+
+    if (path.length === 0 && !isAbsolute) path = '.';
+    if (path.length > 0 && trailingSeparator) path += '/';
+
+    if (isAbsolute) return '/' + path;
+    return path;
+  },
+
+  isAbsolute: function isAbsolute(path) {
+    assertPath(path);
+    return path.length > 0 && path.charCodeAt(0) === 47 /*/*/;
+  },
+
+  join: function join() {
+    if (arguments.length === 0)
+      return '.';
+    var joined;
+    for (var i = 0; i < arguments.length; ++i) {
+      var arg = arguments[i];
+      assertPath(arg);
+      if (arg.length > 0) {
+        if (joined === undefined)
+          joined = arg;
+        else
+          joined += '/' + arg;
+      }
+    }
+    if (joined === undefined)
+      return '.';
+    return posix.normalize(joined);
+  },
+
+  relative: function relative(from, to) {
+    assertPath(from);
+    assertPath(to);
+
+    if (from === to) return '';
+
+    from = posix.resolve(from);
+    to = posix.resolve(to);
+
+    if (from === to) return '';
+
+    // Trim any leading backslashes
+    var fromStart = 1;
+    for (; fromStart < from.length; ++fromStart) {
+      if (from.charCodeAt(fromStart) !== 47 /*/*/)
+        break;
+    }
+    var fromEnd = from.length;
+    var fromLen = fromEnd - fromStart;
+
+    // Trim any leading backslashes
+    var toStart = 1;
+    for (; toStart < to.length; ++toStart) {
+      if (to.charCodeAt(toStart) !== 47 /*/*/)
+        break;
+    }
+    var toEnd = to.length;
+    var toLen = toEnd - toStart;
+
+    // Compare paths to find the longest common path from root
+    var length = fromLen < toLen ? fromLen : toLen;
+    var lastCommonSep = -1;
+    var i = 0;
+    for (; i <= length; ++i) {
+      if (i === length) {
+        if (toLen > length) {
+          if (to.charCodeAt(toStart + i) === 47 /*/*/) {
+            // We get here if `from` is the exact base path for `to`.
+            // For example: from='/foo/bar'; to='/foo/bar/baz'
+            return to.slice(toStart + i + 1);
+          } else if (i === 0) {
+            // We get here if `from` is the root
+            // For example: from='/'; to='/foo'
+            return to.slice(toStart + i);
+          }
+        } else if (fromLen > length) {
+          if (from.charCodeAt(fromStart + i) === 47 /*/*/) {
+            // We get here if `to` is the exact base path for `from`.
+            // For example: from='/foo/bar/baz'; to='/foo/bar'
+            lastCommonSep = i;
+          } else if (i === 0) {
+            // We get here if `to` is the root.
+            // For example: from='/foo'; to='/'
+            lastCommonSep = 0;
+          }
+        }
+        break;
+      }
+      var fromCode = from.charCodeAt(fromStart + i);
+      var toCode = to.charCodeAt(toStart + i);
+      if (fromCode !== toCode)
+        break;
+      else if (fromCode === 47 /*/*/)
+        lastCommonSep = i;
+    }
+
+    var out = '';
+    // Generate the relative path based on the path difference between `to`
+    // and `from`
+    for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
+      if (i === fromEnd || from.charCodeAt(i) === 47 /*/*/) {
+        if (out.length === 0)
+          out += '..';
+        else
+          out += '/..';
+      }
+    }
+
+    // Lastly, append the rest of the destination (`to`) path that comes after
+    // the common path parts
+    if (out.length > 0)
+      return out + to.slice(toStart + lastCommonSep);
+    else {
+      toStart += lastCommonSep;
+      if (to.charCodeAt(toStart) === 47 /*/*/)
+        ++toStart;
+      return to.slice(toStart);
+    }
+  },
+
+  _makeLong: function _makeLong(path) {
+    return path;
+  },
+
+  dirname: function dirname(path) {
+    assertPath(path);
+    if (path.length === 0) return '.';
+    var code = path.charCodeAt(0);
+    var hasRoot = code === 47 /*/*/;
+    var end = -1;
+    var matchedSlash = true;
+    for (var i = path.length - 1; i >= 1; --i) {
+      code = path.charCodeAt(i);
+      if (code === 47 /*/*/) {
+          if (!matchedSlash) {
+            end = i;
+            break;
+          }
+        } else {
+        // We saw the first non-path separator
+        matchedSlash = false;
+      }
+    }
+
+    if (end === -1) return hasRoot ? '/' : '.';
+    if (hasRoot && end === 1) return '//';
+    return path.slice(0, end);
+  },
+
+  basename: function basename(path, ext) {
+    if (ext !== undefined && typeof ext !== 'string') throw new TypeError('"ext" argument must be a string');
+    assertPath(path);
+
+    var start = 0;
+    var end = -1;
+    var matchedSlash = true;
+    var i;
+
+    if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
+      if (ext.length === path.length && ext === path) return '';
+      var extIdx = ext.length - 1;
+      var firstNonSlashEnd = -1;
+      for (i = path.length - 1; i >= 0; --i) {
+        var code = path.charCodeAt(i);
+        if (code === 47 /*/*/) {
+            // If we reached a path separator that was not part of a set of path
+            // separators at the end of the string, stop now
+            if (!matchedSlash) {
+              start = i + 1;
+              break;
+            }
+          } else {
+          if (firstNonSlashEnd === -1) {
+            // We saw the first non-path separator, remember this index in case
+            // we need it if the extension ends up not matching
+            matchedSlash = false;
+            firstNonSlashEnd = i + 1;
+          }
+          if (extIdx >= 0) {
+            // Try to match the explicit extension
+            if (code === ext.charCodeAt(extIdx)) {
+              if (--extIdx === -1) {
+                // We matched the extension, so mark this as the end of our path
+                // component
+                end = i;
+              }
+            } else {
+              // Extension does not match, so our result is the entire path
+              // component
+              extIdx = -1;
+              end = firstNonSlashEnd;
+            }
+          }
+        }
+      }
+
+      if (start === end) end = firstNonSlashEnd;else if (end === -1) end = path.length;
+      return path.slice(start, end);
+    } else {
+      for (i = path.length - 1; i >= 0; --i) {
+        if (path.charCodeAt(i) === 47 /*/*/) {
+            // If we reached a path separator that was not part of a set of path
+            // separators at the end of the string, stop now
+            if (!matchedSlash) {
+              start = i + 1;
+              break;
+            }
+          } else if (end === -1) {
+          // We saw the first non-path separator, mark this as the end of our
+          // path component
+          matchedSlash = false;
+          end = i + 1;
+        }
+      }
+
+      if (end === -1) return '';
+      return path.slice(start, end);
+    }
+  },
+
+  extname: function extname(path) {
+    assertPath(path);
+    var startDot = -1;
+    var startPart = 0;
+    var end = -1;
+    var matchedSlash = true;
+    // Track the state of characters (if any) we see before our first dot and
+    // after any path separator we find
+    var preDotState = 0;
+    for (var i = path.length - 1; i >= 0; --i) {
+      var code = path.charCodeAt(i);
+      if (code === 47 /*/*/) {
+          // If we reached a path separator that was not part of a set of path
+          // separators at the end of the string, stop now
+          if (!matchedSlash) {
+            startPart = i + 1;
+            break;
+          }
+          continue;
+        }
+      if (end === -1) {
+        // We saw the first non-path separator, mark this as the end of our
+        // extension
+        matchedSlash = false;
+        end = i + 1;
+      }
+      if (code === 46 /*.*/) {
+          // If this is our first dot, mark it as the start of our extension
+          if (startDot === -1)
+            startDot = i;
+          else if (preDotState !== 1)
+            preDotState = 1;
+      } else if (startDot !== -1) {
+        // We saw a non-dot and non-path separator before our dot, so we should
+        // have a good chance at having a non-empty extension
+        preDotState = -1;
+      }
+    }
+
+    if (startDot === -1 || end === -1 ||
+        // We saw a non-dot character immediately before the dot
+        preDotState === 0 ||
+        // The (right-most) trimmed path component is exactly '..'
+        preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+      return '';
+    }
+    return path.slice(startDot, end);
+  },
+
+  format: function format(pathObject) {
+    if (pathObject === null || typeof pathObject !== 'object') {
+      throw new TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
+    }
+    return _format('/', pathObject);
+  },
+
+  parse: function parse(path) {
+    assertPath(path);
+
+    var ret = { root: '', dir: '', base: '', ext: '', name: '' };
+    if (path.length === 0) return ret;
+    var code = path.charCodeAt(0);
+    var isAbsolute = code === 47 /*/*/;
+    var start;
+    if (isAbsolute) {
+      ret.root = '/';
+      start = 1;
+    } else {
+      start = 0;
+    }
+    var startDot = -1;
+    var startPart = 0;
+    var end = -1;
+    var matchedSlash = true;
+    var i = path.length - 1;
+
+    // Track the state of characters (if any) we see before our first dot and
+    // after any path separator we find
+    var preDotState = 0;
+
+    // Get non-dir info
+    for (; i >= start; --i) {
+      code = path.charCodeAt(i);
+      if (code === 47 /*/*/) {
+          // If we reached a path separator that was not part of a set of path
+          // separators at the end of the string, stop now
+          if (!matchedSlash) {
+            startPart = i + 1;
+            break;
+          }
+          continue;
+        }
+      if (end === -1) {
+        // We saw the first non-path separator, mark this as the end of our
+        // extension
+        matchedSlash = false;
+        end = i + 1;
+      }
+      if (code === 46 /*.*/) {
+          // If this is our first dot, mark it as the start of our extension
+          if (startDot === -1) startDot = i;else if (preDotState !== 1) preDotState = 1;
+        } else if (startDot !== -1) {
+        // We saw a non-dot and non-path separator before our dot, so we should
+        // have a good chance at having a non-empty extension
+        preDotState = -1;
+      }
+    }
+
+    if (startDot === -1 || end === -1 ||
+    // We saw a non-dot character immediately before the dot
+    preDotState === 0 ||
+    // The (right-most) trimmed path component is exactly '..'
+    preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+      if (end !== -1) {
+        if (startPart === 0 && isAbsolute) ret.base = ret.name = path.slice(1, end);else ret.base = ret.name = path.slice(startPart, end);
+      }
+    } else {
+      if (startPart === 0 && isAbsolute) {
+        ret.name = path.slice(1, startDot);
+        ret.base = path.slice(1, end);
+      } else {
+        ret.name = path.slice(startPart, startDot);
+        ret.base = path.slice(startPart, end);
+      }
+      ret.ext = path.slice(startDot, end);
+    }
+
+    if (startPart > 0) ret.dir = path.slice(0, startPart - 1);else if (isAbsolute) ret.dir = '/';
+
+    return ret;
+  },
+
+  sep: '/',
+  delimiter: ':',
+  win32: null,
+  posix: null
+};
+
+posix.posix = posix;
+
+var pathBrowserify = posix;
+
+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);
+}
+function truncateString(obj, maxLength = 20) {
+    const objLength = obj.length;
+    if (objLength > maxLength && maxLength) {
+        obj = getSubstring(obj, maxLength) + '...';
+    }
+    return obj;
+}
+/**
+ * Remove *every* occurrence of any prefix in `bases` from the *beginning*
+ * of `str`, looping until no prefix matches.
+ *
+ * @example
+ *   stripPrefixes('/site/site/docs', ['/site', '/static']);
+ *   // → '/docs'
+ */
+function stripPrefixes(str, bases = []) {
+    // normalise to a non-empty array of strings
+    const prefixes = (Array.isArray(bases) ? bases : [bases])
+        .filter(Boolean)
+        // longest first ⇒ '/site/files' is checked before '/site'
+        .sort((a, b) => b.length - a.length);
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const prefix of prefixes) {
+            if (str.startsWith(prefix)) {
+                str = str.slice(prefix.length);
+                changed = true; // start the loop again
+                break; // restart prefix scan from the longest one
+            }
+        }
+    }
+    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.
+ */
+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.
+ */
+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.
+ */
+function eatAll(str, listObjects) {
+    return eatOuter(eatInner(str, listObjects), listObjects);
+}
+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;
+}
+
+function ensure_list(obj) {
+    const objArray = Array.isArray(obj) ? obj : [obj];
+    return objArray;
+}
+
+/**
+ * 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.
+ */
+/**
+ * Minimal fileURLToPath implementation for browser-side code.
+ * If you only ever need to strip off “file://” in development, this is enough.
+ */
+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:\/\//, '');
+    }
+}
+function getAbsolutePath() {
+    return fileURLToPath(import.meta.url);
+}
+
+function get_dirname(filePath) {
+    if (!filePath)
+        return '';
+    return pathBrowserify.dirname(filePath);
+}
+function get_basename(filePath) {
+    if (!filePath)
+        return '';
+    return pathBrowserify.basename(filePath);
+}
+function get_filename(file_path) {
+    const ext = pathBrowserify.extname(file_path);
+    return pathBrowserify.basename(file_path, ext);
+}
+function get_extname(filePath) {
+    if (!filePath)
+        return '';
+    return pathBrowserify.extname(filePath);
+}
+function get_splitext(filePath) {
+    if (!filePath)
+        return { filename: '', extname: '' };
+    const ext = pathBrowserify.extname(filePath);
+    // Get the basename without the extension
+    const filename = pathBrowserify.basename(filePath, ext);
+    return { filename, ext };
+}
+function make_path(...segments) {
+    const list = ensure_list(segments);
+    let real_path = '';
+    for (let i = 0; i < list.length; i++) {
+        let segment = list[i]; // renamed, no shadowing
+        if (i === 0) {
+            real_path = segment;
+        }
+        else {
+            segment = eatInner(segment, ['/']);
+            real_path = eatOuter(real_path, ['/']);
+            real_path = `${real_path}/${segment}`;
+        }
+    }
+    return real_path || '';
+}
+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
+}
+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 || '';
+}
+function normalizeUrl(base, p) {
+    if (!p)
+        return base;
+    const cleanBase = base.replace(/\/+$/, ''); // regex literal
+    const cleanPath = p.replace(/^\/+/, '');
+    // collapse multiple “//” into one, but keep the “://” after protocol
+    return `${cleanBase}/${cleanPath}`.replace(/([^:])\/{2,}/g, '$1/');
+}
+
+/**
+ * Returns the absolute path of the current file.
+ */
+function getAbsDir() {
+    return get_dirname(getAbsolutePath());
+}
+function getAbsPath(subPath) {
+    return make_path(getAbsDir(), subPath);
+}
+
+function getFunctionsDir() {
+    return get_dirname(getAbsDir());
+}
+function geAuthsUtilsDirectory() {
+    return make_path(getFunctionsDir(), 'auths');
+}
+function geBackupsUtilsDirectory() {
+    return make_path(getFunctionsDir(), 'backups');
+}
+function geConstantsUtilsDirectory() {
+    return make_path(getFunctionsDir(), 'constants');
+}
+function geEnvUtilsDirectory() {
+    return make_path(getFunctionsDir(), 'env_utils');
+}
+function geFetchUtilsDirectory() {
+    return make_path(getFunctionsDir(), 'fetch_utils');
+}
+function geFileUtilsDirectory() {
+    return make_path(getFunctionsDir(), 'file_utils');
+}
+function gePathUtilsDirectory() {
+    return make_path(getFunctionsDir(), 'path_utils');
+}
+function geStringUtilsDirectory() {
+    return make_path(getFunctionsDir(), 'string_utils');
+}
+function geTypeUtilsDirectory() {
+    return make_path(getFunctionsDir(), 'type_utils');
+}
+
+function getSrcDir() {
+    return get_dirname(getFunctionsDir());
+}
+function geStaticDirectory() {
+    return make_path(getSrcDir(), 'static');
+}
+function getLibUtilsDirectory() {
+    return make_path(getSrcDir(), 'lib');
+}
+function getHooksUtilsDirectory() {
+    return make_path(getSrcDir(), 'hooks');
+}
+function getFunctionsUtilsDirectory() {
+    return make_path(getSrcDir(), 'functions');
+}
+function getComponentsUtilsDirectory() {
+    return make_path(getSrcDir(), 'components');
+}
+
+function getBaseDir() {
+    return get_dirname(getSrcDir());
+}
+function getPublicDir() {
+    return make_path(getBaseDir(), 'public');
+}
+function getDistDir() {
+    return make_path(getBaseDir(), 'dist');
+}
+function getEnvDir() {
+    return make_path(getBaseDir(), '.env');
+}
+
+function getEnvPath(string = '.env') {
+    return make_path(getEnvDir(), string);
+}
+function getDbConfigsPath() {
+    return make_path(getBaseDir(), 'dbConfigs');
+}
+function getSchemasPath() {
+    return make_path(getDbConfigsPath(), 'schemas');
+}
+function getSchemasDirPath(subPath) {
+    return make_path(getSchemasPath(), subPath);
+}
+
+// src/functions/rndm_utils/utils.ts
+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);
+}
+
+function ensureAbstractUrl(endpoint, slices = []) {
+    // 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);
+}
+/** Pulls base-URL from AppConfig.API_BASE_URL, strips trailing slashes */
+function getRawConfigUrl() {
+    var _a;
+    // Now AppConfig[key] is allowed because of the index signature
+    const rawBase = (_a = AppConfig.API_BASE_URL) !== null && _a !== void 0 ? _a : "";
+    return rawBase.replace(/\/+$/, "");
+}
+// Constructs API URL from endpoint
+function api(endpoint) {
+    return ensureAbstractUrl(endpoint);
+}
+// Checks if response is OK, handles 401/403 by redirecting to login
+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
+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
+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
+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
+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
+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 };
+}
+
+/**
+
+***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 ----------------------------
+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);
+    });
+}
+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) {
+        // strip leading slashes off the endpoint
+        method = method || "GET";
+        const cleanEndpoint = endpoint.replace(/^\/+/, "");
+        // decide whether to build off your API_BASE_URL or not
+        const rawBase = getRawConfigUrl();
+        const baseSlices = noApi
+            ? []
+            : rawBase.split("/").filter(Boolean);
+        // build final URL
+        const url = ensureAbstractUrl(cleanEndpoint, baseSlices);
+        // 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 (returnJson)
+            return res.json();
+        return res;
+    });
+}
+// Performs PATCH request
+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
+function fetchSharePatch(file) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const base = getRawConfigUrl();
+        const url = `${base}/files/share`;
+        const token = localStorage.getItem('token');
+        const resp = yield fetch(url, {
+            method: 'PATCH',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${token}`,
+            },
+            body: JSON.stringify(file),
+        });
+        if (!resp.ok) {
+            console.error('Error from server', yield resp.text());
+        }
+        else {
+            const data = yield resp.json();
+            console.log('Success!', data);
+        }
+    });
+}
+
+function downloadFile(item) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const token = requireToken();
+        const { filepath, filename } = item;
+        const body = { rel_path: filepath };
+        const headers = {
+            Authorization: `Bearer ${token}`,
+            Accept: "application/octet-stream",
+            "Content-Type": "application/json"
+        };
+        const blob = yield secureFetchIt("download", body, "POST", headers, true, true);
+        if (!blob || blob.size === 0) {
+            throw new Error(`Received empty file data for “${filename}”`);
+        }
+        triggerDownload(blob, filename);
+    });
+}
+
+function downloadSelect(relPath, filename) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const token = requireToken();
+        const body = { rel_path: relPath };
+        const headers = {
+            Authorization: `Bearer ${token}`,
+            Accept: "application/octet-stream",
+            "Content-Type": "application/json"
+        };
+        const blob = yield secureFetchIt("download", body, "POST", headers, true, true);
+        if (!blob || blob.size === 0) {
+            throw new Error(`Received empty file data for “${filename}”`);
+        }
+        triggerDownload(blob, filename);
+    });
+}
+
+/** Given a checkbox inside a table-row → download that row’s file. */
+function downloadRow(cb) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const row = cb.closest("tr");
+        const relPath = cb.value;
+        const filename = ((_b = (_a = row === null || row === void 0 ? void 0 : row.children[1]) === null || _a === void 0 ? void 0 : _a.textContent) === null || _b === void 0 ? void 0 : _b.trim()) || "downloaded_file";
+        if (relPath)
+            yield downloadSelect(relPath, filename);
+    });
+}
+/** Bulk download: pass a NodeList or array of checkboxes. */
+function downloadSelected(checkboxes) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const list = Array.from(checkboxes);
+        if (!list.length) {
+            alert("No files selected.");
+            return;
+        }
+        for (const cb of list) {
+            yield downloadRow(cb);
+        }
+    });
+}
+
+/**
+ * Classic “select all rows” logic (still handy in non-React views
+ * such as the admin dashboard).
+ */
+function syncHeaderCheckbox() {
+    const all = document.querySelectorAll(".file-checkbox");
+    const checked = document.querySelectorAll(".file-checkbox:checked");
+    const header = document.getElementById("select-all-checkbox");
+    header.indeterminate =
+        checked.length > 0 && checked.length < all.length;
+    header.checked = checked.length === all.length;
+}
+
+/** Wire up header + row checkboxes once the table is in the DOM. */
+function initSelectAll() {
+    const header = document.getElementById("select-all-checkbox");
+    const btn = document.getElementById("select-all");
+    // 1) header → toggle all
+    header.addEventListener("change", (e) => {
+        const on = e.target.checked;
+        document
+            .querySelectorAll(".file-checkbox")
+            .forEach((cb) => (cb.checked = on));
+    });
+    // 2) button → toggle all
+    btn.addEventListener("click", () => {
+        const cbs = Array.from(document.querySelectorAll(".file-checkbox"));
+        if (!cbs.length) {
+            alert("No files to select.");
+            return;
+        }
+        const anyUnchecked = cbs.some((cb) => !cb.checked);
+        cbs.forEach((cb) => (cb.checked = anyUnchecked));
+        syncHeaderCheckbox();
+    });
+    // 3) row boxes → keep header state
+    document
+        .querySelectorAll(".file-checkbox")
+        .forEach((cb) => cb.addEventListener("change", syncHeaderCheckbox));
+    syncHeaderCheckbox();
+}
+
+/** Utility for other screens: toggle a list of checkboxes on/off. */
+function toggleCheckboxes(cbs) {
+    if (!cbs.length) {
+        alert("No files to select.");
+        return;
+    }
+    const anyUnchecked = cbs.some((cb) => !cb.checked);
+    cbs.forEach((cb) => (cb.checked = anyUnchecked));
+    syncHeaderCheckbox();
+}
+
+/** Generic PATCH helper kept for other admin forms */
+function patchFileSetting(fileId, field, value) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const res = yield fetch(`/files/${fileId}/settings/${field}`, {
+            method: "PATCH",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ value }),
+        });
+        if (!res.ok) {
+            const err = yield res.json();
+            throw new Error(err.error || res.statusText);
+        }
+        return (yield res.json());
+    });
+}
+
+/** Classic file-upload for the fallback HTML page. */
+function uploadFile(file, subdir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const fileInput = file || document.getElementById("file-browser");
+        const subdirInput = subdir || document.getElementById("subdir");
+        const banner = document.getElementById("banner");
+        if (!((_a = fileInput.files) === null || _a === void 0 ? void 0 : _a.length)) {
+            alert("No file selected.");
+            return;
+        }
+        const formData = new FormData();
+        formData.append("file", fileInput.files[0]);
+        formData.append("subdir", subdirInput.value.trim());
+        try {
+            const json = yield secureFetchIt("upload", formData, "POST", null, false, true);
+            banner.textContent = `Uploaded: ${json.filepath}`;
+            fileInput.value = "";
+            subdirInput.value = "";
+            window.location.reload(); // no-op in React view
+        }
+        catch (err) {
+            console.error("Upload failed", err);
+            alert((_b = err === null || err === void 0 ? void 0 : err.message) !== null && _b !== void 0 ? _b : "Upload failed.");
+        }
+    });
+}
+
+function uploadFiles(file_1) {
+    return __awaiter(this, arguments, void 0, function* (file, subdir = '') {
+        var _a;
+        if (!(file instanceof File)) {
+            throw new Error('Invalid file: Must be a File object.');
+        }
+        if (typeof subdir !== 'string') {
+            throw new Error('Invalid subdir: Must be a string.');
+        }
+        const formData = new FormData();
+        formData.append('file', file);
+        formData.append('subdir', subdir.trim());
+        try {
+            const json = yield secureFetchIt('upload', formData, 'POST', null, false, true);
+            if (!json || typeof json !== 'object') {
+                throw new Error('Invalid response from server.');
+            }
+            if (!('filepath' in json) || typeof json.filepath !== 'string' || !json.filepath) {
+                throw new Error('Server response missing or invalid filepath.');
+            }
+            return { filepath: json.filepath };
+        }
+        catch (err) {
+            throw new Error(`Upload failed: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : 'Unknown error'}`);
+        }
+    });
+}
+
+function removeFile(item) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const token = requireToken();
+        const body = item;
+        const headers = {
+            Authorization: `Bearer ${token}`,
+            Accept: "application/octet-stream",
+            "Content-Type": "application/json"
+        };
+        const resp = yield secureFetchIt("remove", body, "POST", headers, false, true);
+        if (!resp || resp === false || (resp === null || resp === void 0 ? void 0 : resp.result) === false) {
+            throw new Error(`could not delete data: “${item.filename}”`);
+        }
+    });
+}
+
+/** Bulk download: pass a NodeList or array of checkboxes. */
+function removeSelected(checkboxes) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const list = Array.from(checkboxes);
+        if (!list.length) {
+            alert("No files selected.");
+            return;
+        }
+        for (const cb of list) {
+            yield removeFile(cb);
+        }
+    });
+}
+
+/** Given a checkbox inside a table-row → download that row’s file. */
+function removeRow(cb) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const row = cb.closest("tr");
+        alertit(row);
+        if (row && (row === null || row === void 0 ? void 0 : row.id))
+            yield removeFile(row);
+    });
+}
+
+/** GET /secure-list */
+function listFiles() {
+    return __awaiter(this, arguments, void 0, function* (setFiles = null) {
+        /** ← your request already returns the raw array */
+        const apiRows = yield secureFetchIt("list", null, "GET", null, false, true);
+        /** map API → UI ------------------------------------------------ */
+        const rows = apiRows.map((r) => ({
+            id: r.id,
+            filename: r.filename,
+            uploader_id: r.uploader_id,
+            filepath: r.filepath,
+            created_at: r.created_at,
+            download_count: r.download_count,
+            download_limit: r.download_limit,
+            shareable: Boolean(r.shareable),
+            needsPassword: !!r.share_password,
+            share_password: r.share_password,
+        }));
+        setFiles(rows);
+    });
+}
+
+function getToggleShare(file) {
+    if (file == true || (file === null || file === void 0 ? void 0 : file.shareable) == true) {
+        return false;
+    }
+    return false;
+}
+function updateFileShare(file) {
+    let updated = file;
+    const boolIt = getToggleShare(updated);
+    updated = Object.assign(Object.assign({}, file), { shareable: boolIt });
+    return updated;
+}
+/**
+ * Custom hook to toggle share settings on a file item
+ */
+function toggleShare(file) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const updated = updateFileShare(file);
+        try {
+            const resp = yield fetchSharePatch(updated);
+        }
+        catch (err) {
+            console.error('Failed to toggle share settings', err);
+            // Optionally revert UI state or show an error message
+        }
+    });
+}
+
+const PROTOCOL = 'https://';
+const DOMAIN_NAME = 'abstractendeavors';
+const BASE_URL = `${PROTOCOL}${DOMAIN_NAME}.com`;
+const SUB_DIR = 'secure-files';
+const PROD_PREFIX = `/${SUB_DIR}/`;
+const API_PREFIX = `/${SUB_DIR}/api`;
+const DEV_PREFIX = `/${SUB_DIR}-dev/`;
+
+function get_window() {
+    try {
+        if (typeof window !== 'undefined') {
+            return window;
+        }
+    }
+    catch (err) {
+        alert(err);
+    }
+    return null;
+}
+function get_window_location() {
+    try {
+        const Window = get_window();
+        if (!Window) {
+            return BASE_URL;
+        }
+        return Window.location;
+    }
+    catch (err) {
+        alert(err);
+    }
+    return null;
+}
+function get_window_pathname() {
+    try {
+        const Window = get_window();
+        if (!Window) {
+            return DEV_PREFIX;
+        }
+        return Window.location.pathname;
+    }
+    catch (err) {
+        alert(err);
+    }
+    return null;
+}
+function get_window_parts() {
+    try {
+        return get_window_location();
+    }
+    catch (err) {
+        alert(err);
+    }
+    return null;
+}
+
+function Button(_a) {
+    var { children, color = 'gray' } = _a, rest = __rest(_a, ["children", "color"]);
+    const base = 'rounded px-3 py-1 text-sm';
+    const palette = color === 'green' ? 'bg-green-600 text-white hover:bg-green-700' : 'bg-gray-200 hover:bg-gray-300';
+    return jsx("button", Object.assign({ className: `${base} ${palette}` }, rest, { children: children }));
+}
+
+function Checkbox(_a) {
+    var { label } = _a, rest = __rest(_a, ["label"]);
+    return (jsxs("label", { className: 'flex items-center gap-2 mb-4', children: [jsx("input", Object.assign({ type: 'checkbox' }, rest)), jsx("span", { children: label })] }));
+}
+
+function Input(_a) {
+    var { label, trailing } = _a, rest = __rest(_a, ["label", "trailing"]);
+    return (jsxs("label", { className: 'mb-4 block', children: [jsx("span", { className: 'block text-sm font-medium mb-1', children: label }), jsxs("div", { className: 'flex gap-2', children: [jsx("input", Object.assign({ className: 'flex-1 rounded border px-2 py-1 disabled:bg-gray-100' }, rest)), trailing] })] }));
+}
+
+function Spinner() {
+    return (jsx("p", { className: 'animate-pulse', children: "Loading\u2026" }));
+}
+
+/**
+ * Custom hook that returns a memoized loadFiles callback
+ */
+const useLoadFiles = (setLoading, setError, setFiles) => {
+    return useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
+        setLoading(true);
+        setError(null);
+        try {
+            /** ← your request already returns the raw array */
+            const apiRows = yield secureFetchIt("list", null, "GET", null, false, true);
+            /** map API → UI ------------------------------------------------ */
+            const rows = apiRows.map((r) => ({
+                id: r.id,
+                filename: r.filename,
+                uploader_id: r.uploader_id,
+                filepath: r.filepath,
+                created_at: r.created_at,
+                download_count: r.download_count,
+                download_limit: r.download_limit,
+                shareable: Boolean(r.shareable),
+                needsPassword: !!r.share_password,
+                share_password: r.share_password,
+            }));
+            setFiles(rows);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err
+                : new Error("Unknown error loading files"));
+        }
+        finally {
+            setLoading(false);
+        }
+    }), [setLoading, setError, setFiles]);
+};
+
+/**
+ * Custom hook to toggle share settings on a file item
+ */
+const useToggleShare = (setFiles) => {
+    return useCallback((file) => __awaiter(void 0, void 0, void 0, function* () {
+        const updated = Object.assign(Object.assign({}, file), { shareable: !file.shareable });
+        if (!updated.shareable) {
+            updated.needsPassword = false;
+            updated.share_password = null;
+            updated.download_limit = null;
+        }
+        try {
+            yield fetchSharePatch(updated);
+            setFiles((curr) => curr.map((f) => (f.id === file.id ? updated : f)));
+        }
+        catch (err) {
+            console.error('Failed to toggle share settings', err);
+            // Optionally revert UI state or show an error message
+        }
+    }), [setFiles]);
+};
+
+/**
+ * Custom hook for optimistic share-setting patch updates
+ */
+/**
+ * Custom hook to toggle share settings on a file item
+ */
+const usePatchShareSettings = (setFiles) => {
+    return useCallback((file) => __awaiter(void 0, void 0, void 0, function* () {
+        if (!file.shareable) {
+            file.needsPassword = false;
+            file.share_password = null;
+            file.download_limit = null;
+        }
+        try {
+            yield fetchSharePatch(file);
+            setFiles((curr) => curr.map((f) => (f.id === file.id ? file : f)));
+        }
+        catch (err) {
+            console.error('Failed to toggle share settings', err);
+            // Optionally revert UI state or show an error message
+        }
+    }), [setFiles]);
+};
+
+/**
+ * Custom hook to toggle share settings on a file item
+ */
+const useDeleteFile = (setFiles) => {
+    return useCallback((file) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            yield removeFile(file);
+            window.location.reload();
+        }
+        catch (err) {
+            console.error('Failed to toggle share settings', err);
+            // Optionally revert UI state or show an error message
+        }
+    }), [setFiles]);
+};
+
+function useFiles() {
+    const [files, setFiles] = useState([]);
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const loadCallback = useLoadFiles(setLoading, setError, setFiles);
+    const toggleShareCallback = useToggleShare(setFiles);
+    const patchShareSettingsCallback = usePatchShareSettings(setFiles);
+    const deleteFileCallback = useDeleteFile(setFiles);
+    useEffect(() => {
+        loadCallback();
+    }, [loadCallback]);
+    return {
+        files,
+        loading,
+        error,
+        load: loadCallback,
+        toggleShare: toggleShareCallback,
+        patchShareSettings: patchShareSettingsCallback,
+        deleteFile: deleteFileCallback,
+        setFiles,
+        setLoading,
+        setError,
+    };
+}
+
+export { API_PREFIX, AppConfig, BASE_URL, Button, Checkbox, DEV_PREFIX, DOMAIN_NAME, Input, PROD_PREFIX, PROTOCOL, SUB_DIR, Spinner, alertit, currentUsername, currentUsernames, decodeJwt, directDownload, downloadFile, downloadRow, downloadSelect, downloadSelected, eatAll, eatEnd, eatInner, eatOuter, ensure_list, fetchIt, fetchSharePatch, geAuthsUtilsDirectory, geBackupsUtilsDirectory, geConstantsUtilsDirectory, geEnvUtilsDirectory, geFetchUtilsDirectory, geFileUtilsDirectory, gePathUtilsDirectory, geStaticDirectory, geStringUtilsDirectory, geTypeUtilsDirectory, getAbsDir, getAbsPath, getAuthorizationHeader, getBaseDir, getComponentsUtilsDirectory, getDbConfigsPath, getDistDir, getEnvDir, getEnvPath, getFunctionsDir, getFunctionsUtilsDirectory, getHooksUtilsDirectory, getLibUtilsDirectory, getPublicDir, getSchemasDirPath, getSchemasPath, getSrcDir, getSubstring, getToggleShare, getToken, get_basename, get_dirname, get_extname, get_filename, get_splitext, get_window, get_window_location, get_window_parts, get_window_pathname, initSelectAll, isLoggedIn, isTokenExpired, listFiles, loadConfig, make_path, make_sanitized_path, normalizeUrl, patchFileSetting, removeFile, removeRow, removeSelected, requestPatch, requireToken, sanitizeFilename, secureFetchIt, stripPrefixes, syncHeaderCheckbox, toggleCheckboxes, toggleShare, triggerDownload, truncateString, updateFileShare, uploadFile, uploadFiles, useDeleteFile, useFiles, useLoadFiles, usePatchShareSettings, useToggleShare };
+//# sourceMappingURL=index.js.map