frontend-plus-react 0.1.0

package/dist/index.js

@@ -0,0 +1,3393 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/json4all/json4all.js
+var require_json4all = __commonJS({
+  "node_modules/json4all/json4all.js"(exports, module) {
+    "use strict";
+    (function codenautasModuleDefinition(root, name, factory) {
+      if (typeof root.globalModuleName !== "string") {
+        root.globalModuleName = name;
+      }
+      if (typeof exports === "object" && typeof module === "object") {
+        module.exports = factory();
+      } else if (typeof define === "function" && define.amd) {
+        define(factory);
+      } else if (typeof exports === "object") {
+        exports[root.globalModuleName] = factory();
+      } else {
+        root[root.globalModuleName] = factory();
+      }
+      root.globalModuleName = null;
+    })(
+      /*jshint -W040 */
+      exports,
+      "json4all",
+      function() {
+        var json4all = {};
+        json4all.PretendedClass = Symbol("Pretended Class");
+        function functionName(fun) {
+          if ("name" in fun) {
+            return fun.name;
+          } else {
+            return fun.toString().replace(/^\s*function\s*([^(]*)\((.|\s)*$/i, "$1");
+          }
+        }
+        function constructorName(obj) {
+          return functionName(obj[json4all.PretendedClass] || obj.constructor);
+        }
+        var root;
+        if (typeof window !== "undefined") {
+          root = window;
+        } else {
+          root = global;
+        }
+        root.json4allRegisteredTypes = root.json4allRegisteredTypes || {};
+        var types = root.json4allRegisteredTypes;
+        var thisPlatformSkipsUndefinedInArrays = true;
+        JSON.stringify([void 0], function(key, value) {
+          if (key === "0" || key === 0) {
+            thisPlatformSkipsUndefinedInArrays = false;
+          }
+          return value;
+        });
+        var thisPlatformHasReplacerBug = false;
+        JSON.parse('{"3":"33"}', function(key, value) {
+          if (value === void 0) {
+            thisPlatformHasReplacerBug = true;
+          }
+          return value;
+        });
+        function InternalValueForUndefined() {
+          throw new Error("this is not a function");
+        }
+        function InternalValueForUnset() {
+          throw new Error("this is not a function");
+        }
+        json4all.directTypes = {
+          "Object": true,
+          "Array": true,
+          "anonymous": true,
+          "": true
+        };
+        json4all.anonymizate = function(classedObject) {
+          var plainObject = {};
+          for (var attr in classedObject) {
+            plainObject[attr] = classedObject[attr];
+          }
+          return plainObject;
+        };
+        json4all.nonymizate = function(plainValue, Constructor) {
+          var typedValue = new Constructor();
+          for (var attr in plainValue) {
+            typedValue[attr] = plainValue[attr];
+          }
+          return typedValue;
+        };
+        json4all.replacer = function replacer(key, value) {
+          var realValue = this[key];
+          if (realValue === InternalValueForUndefined) {
+            this[key] = void 0;
+            return { $special: "undefined" };
+          }
+          if (key !== "" && (!(key in this) || realValue !== null && realValue instanceof Function)) {
+            return { $special: "unset" };
+          }
+          if (realValue === void 0 || typeof realValue === "undefined" || realValue !== null && realValue instanceof Function) {
+            return { $special: "undefined" };
+          }
+          if (realValue === null || typeof realValue !== "object" || key === "$escape") {
+            return value;
+          }
+          if ("$special" in realValue || "$escape" in realValue) {
+            return { $escape: realValue };
+          }
+          if (thisPlatformSkipsUndefinedInArrays && realValue instanceof Array) {
+            for (var i = 0; i < realValue.length; i++) {
+              if (typeof realValue[i] === "undefined") {
+                realValue[i] = InternalValueForUndefined;
+              }
+            }
+            return realValue;
+          }
+          var typeName = constructorName(realValue);
+          if (json4all.directTypes[typeName]) {
+            return value;
+          } else {
+            var typeDef = types[typeName];
+            if (typeDef) {
+              var replaced = { $special: typeDef.specialTag(realValue), $value: typeDef.deconstruct(realValue) };
+              var ref = realValue[RefKey];
+              if (ref !== void 0) {
+                replaced.$ref = ref;
+                if (json4all.$RefStoreSpace == null) {
+                  delete replaced.$value;
+                }
+              }
+              return replaced;
+            } else {
+              console.log("JSON4all.stringify unregistered object type", typeName);
+              throw new Error("JSON4all.stringify unregistered object type");
+            }
+          }
+        };
+        json4all.reviver = function reviver(key, plainValue) {
+          var log = false;
+          var result;
+          if (key === "$escape") {
+            return plainValue;
+          } else if (plainValue !== null && plainValue.$ref && json4all.$RefStoreSpace) {
+            var collection = json4all.$RefStoreSpace[plainValue.$ref[0][0]];
+            if (!collection) {
+              throw new Error("json4all ref collection invalid");
+            }
+            var object2 = collection[plainValue.$ref[1]];
+            if (!object2) {
+              throw new Error("json4all ref key invalid");
+            }
+            return object2;
+          } else if (plainValue !== null && plainValue.$special) {
+            if (plainValue.$special === "undefined") {
+              if (key === "") {
+                return void 0;
+              }
+              return InternalValueForUndefined;
+            } else if (plainValue.$special === "unset") {
+              return void 0;
+            } else {
+              var typeDef = types[plainValue.$special];
+              if (typeDef) {
+                result = new typeDef.construct(plainValue.$value, typeDef.constructor);
+              } else {
+                console.log("JSON4all.parse invalid $special", plainValue.$special);
+                throw new Error("JSON4all.parse invalid $special");
+              }
+            }
+          } else if (plainValue !== null && plainValue.$escape) {
+            return plainValue.$escape;
+          } else {
+            result = plainValue;
+            if (plainValue instanceof Object) {
+              for (var k in plainValue) {
+                if (plainValue[k] === InternalValueForUndefined) {
+                  plainValue[k] = void 0;
+                }
+              }
+            }
+          }
+          if (plainValue != null && plainValue.$ref) {
+            result[RefKey] = plainValue.$ref;
+          }
+          return result;
+        };
+        var directRegExp = /^((null|true|false)$|[-\]\[{}".0-9])/;
+        var directStringRegExp = /^[a-zA-ZÑñáéíóúüÁÉÍÓÚÜ_@-][0-9a-zA-ZÑñáéíóúüÁÉÍÓÚÜ_@-]{0,32}$/;
+        var AttributeNameRegExp = /^[a-zA-ZÑñáéíóúüÁÉÍÓÚÜ_@-][0-9a-zA-ZÑñáéíóúüÁÉÍÓÚÜ_@-]*($|,)/;
+        json4all.stringifyAnyPlace = function stringifyAnyPlace(value) {
+          return JSON.stringify(value, json4all.replacer);
+        };
+        var CHANNEL = {
+          object: { separator: ",", pairSeparator: ":", empty: function() {
+            return {};
+          } },
+          array: { separator: ";", pairSeparator: null, empty: function() {
+            return [];
+          } }
+        };
+        var SEPARATOR = { ",": "object", ";": "array" };
+        function maxConsumer() {
+          var fun = function(node) {
+            for (var channel2 in CHANNEL) {
+              if (node[channel2] > fun[channel2]) fun[channel2] = node[channel2];
+            }
+            return node.value;
+          };
+          for (var channel in CHANNEL) {
+            fun[channel] = null;
+          }
+          return fun;
+        }
+        function simpleValue(value) {
+          return { value, object: 0, array: 0 };
+        }
+        json4all.maxConsumer = maxConsumer;
+        json4all.mesureString = function mesureString(value) {
+          var currentSeparator = null;
+          var currentLength = 0;
+          var result = simpleValue(value);
+          for (var char of value) {
+            var channel = SEPARATOR[char];
+            if (channel) {
+              if (currentSeparator != char) {
+                currentLength = 0;
+                currentSeparator = char;
+              }
+              currentLength++;
+              if (currentLength > result[channel]) result[channel] = currentLength;
+            } else {
+              currentSeparator = null;
+            }
+          }
+          return result;
+        };
+        json4all.quoteString = function quoteString(text, escapeColon) {
+          var value = directStringRegExp.test(text) && !directRegExp.test(text) ? text : JSON.stringify(text);
+          if (escapeColon) value = value.replace(/:/g, "\\u003a");
+          return json4all.mesureString(value);
+        };
+        var STAR = "*";
+        var BANG = "!";
+        json4all.toUrl = function toUrl(value) {
+          return json4all.toUrlConstruct(value).value;
+        };
+        json4all.toUrlLines = function toUrlLines(value, eol) {
+          return json4all.toUrlConstruct(value, eol ? eol : "\n").value;
+        };
+        var repeat = (str, count) => Array.prototype.concat(new Array(count + 1)).join(str);
+        json4all.toUrlConstruct = function toUrlConstruct(value, addEol) {
+          if (value === null) return simpleValue("null");
+          if (value === void 0) return simpleValue("!undefined");
+          if (value instanceof Function) return simpleValue("!unset");
+          var typeName = constructorName(value);
+          if (typeof value === "string") {
+            return json4all.quoteString(value);
+          } else if (value && typeof value === "object" && !value[RefKey]) {
+            if (!json4all.directTypes[typeName]) {
+              var typeDef = types[typeName];
+              if (typeDef) {
+                var serializedValue = typeDef.serialize(value);
+                if (typeof serializedValue === "string") return json4all.mesureString(serializedValue);
+                return serializedValue;
+              } else {
+                console.log("JSON4all.stringify unregistered object type", typeName);
+                throw new Error("JSON4all.stringify unregistered object type");
+              }
+            } else {
+              var thisChannel = value instanceof Array ? "array" : "object";
+              var parts = [];
+              var result = simpleValue(null);
+              var cantSimplify = false;
+              var max = maxConsumer();
+              if (thisChannel == "array") {
+                for (var i = 0; i < value.length; i++) {
+                  var pair = [max(json4all.toUrlConstruct(value[i]))];
+                  parts.push(pair);
+                }
+              } else {
+                for (var attr in value) {
+                  var pair = [max(json4all.quoteString(attr, true)), max(json4all.toUrlConstruct(value[attr]))];
+                  parts.push(pair);
+                }
+              }
+              for (var channel in CHANNEL) {
+                result[channel] = (max[channel] || 0) + (channel == thisChannel ? 1 : 0);
+              }
+              var PairSep = ":";
+              var lengthSep = result[thisChannel];
+              var ListSep = addEol ? addEol : repeat(CHANNEL[thisChannel].separator, lengthSep);
+              result.value = (addEol ? "!json4all" + CHANNEL[thisChannel].separator : "") + ListSep + parts.map((pair2) => pair2.join(PairSep)).join(ListSep);
+              if (!cantSimplify && parts.length) {
+                return result;
+              }
+            }
+          }
+          return json4all.mesureString(JSON.stringify(value, json4all.replacer));
+        };
+        json4all.stringify = json4all.stringifyAnyPlace;
+        json4all.convertPlain2$special = function convertPlain2$special(o, internally) {
+          if (o != null && o instanceof Object) {
+            for (var key in o) {
+              var realKey = o[key] === void 0 && !isNaN(key) ? Number(key) : key;
+              json4all.convertPlain2$special(o[key], true);
+              var newValue = json4all.reviver(key, o[key]);
+              if (newValue === void 0 && !(o instanceof Array)) {
+                delete o[key];
+              } else {
+                o[key] = newValue;
+              }
+            }
+          }
+          if (!internally) {
+            return json4all.reviver("", o);
+          }
+        };
+        json4all.isTesting = true;
+        json4all.getPlainObject = function getPlainObject(payload, separator, initial, PairSep) {
+          var i = 0;
+          if (separator instanceof RegExp) {
+            var ListSep = separator;
+          } else {
+            var ListSep = "";
+            while (i < payload.length && payload[i] === separator) {
+              i++;
+              ListSep += separator;
+            }
+          }
+          var result = initial;
+          var parts = payload.split(ListSep).slice(1);
+          var index = -1;
+          for (var part of parts) {
+            if (PairSep) {
+              var pos = part.indexOf(PairSep);
+              if (pos < 0) {
+                throw new Error('JSON4all.parse error. Lack of colon "' + PairSep + '" in object');
+              }
+              var value = part.substr(pos + PairSep.length);
+              var index = json4all.parse(part.substr(0, pos));
+            } else {
+              var value = part;
+              index++;
+            }
+            var value = json4all.parse(value, true);
+            if (value !== InternalValueForUnset) {
+              result[index] = value;
+            }
+          }
+          return result;
+        };
+        json4all.parse = function parse2(text, inner) {
+          var payload = text[0] === STAR ? text.substr(1) : text;
+          if (payload[0] === BANG) {
+            payload = payload.substr(1);
+            if (payload === "undefined") return void 0;
+            if (payload === "unset") {
+              return inner ? InternalValueForUnset : void 0;
+            }
+            if (payload[0] == "@") {
+              var commaPosition = payload.indexOf(",");
+              var className = payload.substr(1, commaPosition - 1);
+              var typeDef = types[className];
+              if (!typeDef) {
+                throw new Error("JSON4all.parse unrecognize className " + className);
+              }
+              return typeDef.deserialize(payload).value;
+            }
+            if (payload[0] == "/") {
+              var typeDef = types.RegExp;
+              return typeDef.deserialize(payload).value;
+            }
+            if (payload.substr(0, 8) == "json4all") {
+              var iSeparator = SEPARATOR[payload[8]];
+              if (iSeparator) {
+                var channel = CHANNEL[iSeparator];
+                if (channel) {
+                  var eol = payload[9] == "\r" && payload[10] == "\n" ? "\r\n" : payload[9] == "\n" ? "\n" : null;
+                  if (eol) {
+                    return json4all.getPlainObject(payload.substr(8 + eol.length), /\r?\n/, channel.empty(), channel.pairSeparator);
+                  }
+                }
+              }
+            }
+            throw new Error("JSON4all.parse unrecognize ! token");
+          }
+          if (SEPARATOR[payload[0]]) {
+            var channel = CHANNEL[SEPARATOR[payload[0]]];
+            return json4all.getPlainObject(payload, channel.separator, channel.empty(), channel.pairSeparator);
+          }
+          for (var typeName in types) {
+            var typeDef = types[typeName];
+            var okDetected = null;
+            if (!typeDef.deserialize) {
+              throw new Error("JSON4all.parse type without deserialize: " + typeName);
+            }
+            var valueOk = null;
+            var { ok, value } = typeDef.deserialize(payload);
+            if (ok) {
+              valueOk = value;
+              if (json4all.isTesting) {
+                if (okDetected) {
+                  console.log("More than one way", typeName, okDetected, text, value, valueOk);
+                  throw Error("");
+                }
+                okDetected = typeName;
+              }
+              break;
+            }
+          }
+          if (okDetected) return valueOk;
+          if (typeof text === "string" && !directRegExp.test(text)) {
+            return text;
+          }
+          if (thisPlatformHasReplacerBug) {
+            var parsed = JSON.parse(text);
+            return json4all.convertPlain2$special(parsed);
+          } else {
+            return JSON.parse(text, json4all.reviver);
+          }
+        };
+        json4all.addType = function addType(typeConstructor, functions, skipIfExists) {
+          functions = functions || {};
+          var constructorName2 = typeof typeConstructor === "string" ? typeConstructor : functionName(typeConstructor);
+          if (skipIfExists && types[constructorName2]) {
+            return;
+          }
+          var prefix = "@" + constructorName2;
+          types[constructorName2] = {
+            construct: functions.construct || function construct(plainValue, constructor2) {
+              return typeConstructor.JSON4reviver(plainValue, constructor2);
+            },
+            deconstruct: functions.deconstruct || function deconstruct(o) {
+              return o.JSON4replacer();
+            },
+            specialTag: functions.specialTag || function specialTag(value) {
+              return constructorName2;
+            },
+            serialize: functions.serialize || function serialize(o) {
+              var plainObject = "JSON4replacer" in typeConstructor.prototype ? o.JSON4replacer() : functions.deconstruct(o);
+              var result = json4all.toUrlConstruct(plainObject);
+              result.value = BANG + prefix + result.value;
+              return result;
+            },
+            deserialize: functions.deserialize || function deserialize(plainValue) {
+              if (plainValue.startsWith(prefix + ",")) {
+                var plainObject = json4all.parse(STAR + plainValue.substr(prefix.length), constructor);
+                return {
+                  ok: true,
+                  value: "JSON4replacer" in typeConstructor.prototype ? typeConstructor.JSON4reviver(plainObject, typeConstructor) : functions.construct(plainObject, typeConstructor)
+                };
+              }
+              return { ok: false };
+            },
+            valueLike: functions.valueLike || typeConstructor.JSON4valueLike
+          };
+          if (typeof typeConstructor === "function") {
+            types[constructorName2].constructor = typeConstructor;
+          }
+        };
+        var NativeDateRegExp = /^\d\d\d\d-\d\d-\d\dT\d\d:\d\d:\d\d(\.\d*)?Z$/;
+        json4all.DateFunctions = {
+          construct: function construct(plainValue) {
+            return new Date(plainValue);
+          },
+          deconstruct: function deconstruct(o) {
+            return o.getTime();
+          },
+          serialize: function serialize(o) {
+            return o.toISOString();
+          },
+          deserialize: function deserialize(plainValue) {
+            var ok = NativeDateRegExp.test(plainValue);
+            var value = ok && new Date(plainValue) || null;
+            return { ok, value };
+          },
+          valueLike: true
+        };
+        json4all.addType(Date, json4all.DateFunctions, true);
+        json4all.addType(RegExp, {
+          construct: function construct(plainValue) {
+            return new RegExp(plainValue.source, plainValue.flags);
+          },
+          deconstruct: function deconstruct(o) {
+            return { source: o.source, flags: o.toString().substr(o.toString().lastIndexOf("/") + 1) };
+          },
+          serialize: function serialize(o) {
+            return BANG + "/" + o.source + "/" + o.flags;
+          },
+          deserialize: function deserialize(plainValue) {
+            var ok = false;
+            var value = null;
+            plainValue.replace(/^\/(.+)\/(\w*)$/, function(_, pattern, flags) {
+              value = new RegExp(pattern, flags);
+              ok = true;
+            });
+            return { ok, value };
+          },
+          valueLike: true
+        });
+        json4all._types = types;
+        const RefKey = Symbol("RefKey for RefMap");
+        json4all.RefKey = RefKey;
+        json4all.RefStoreSpace = (myCollection) => {
+          json4all.$RefStoreSpace = myCollection;
+        };
+        json4all.RefStore = (path) => {
+          var myCollection = json4all.$RefStoreSpace;
+          var o = {};
+          var p = new Proxy(o, {
+            /*
+            get:function(target, prop, _receiver) {
+                return target[prop];
+            },
+            */
+            /** @param {Partial<{[key in K]:V}>} target */
+            /** @param {K} prop */
+            /** @param {V} value */
+            set: function(target, prop, value) {
+              if (
+                // @ts-expect-error RefKey no está en el tipo original
+                value[RefKey] == null
+              ) {
+                value[RefKey] = [path, prop];
+              } else if (
+                // @ts-expect-error RefKey no está en el tipo original
+                value[RefKey][1] != prop
+              ) {
+                console.log("This value was stored in another place", path, prop);
+                throw new Error("This value was stored in another place");
+              }
+              return Reflect.set(target, prop, value);
+            }
+          });
+          myCollection[path[0]] = p;
+          return p;
+        };
+        json4all.$props2serialize = Symbol("props2serialize");
+        json4all.addProperty = function(constructorPosition) {
+          var innerFunction = (classPrototype, prop, index) => {
+            if (!(json4all.$props2serialize in classPrototype)) {
+              classPrototype[json4all.$props2serialize] = [];
+            }
+            var info = { name: prop };
+            if (typeof constructorPosition === "number") info.construct = constructorPosition;
+            classPrototype[json4all.$props2serialize].push(info);
+          };
+          if (typeof constructorPosition === "number") {
+            return innerFunction;
+          } else {
+            return innerFunction.apply(null, arguments);
+          }
+        };
+        json4all.pretendClass = function(object2, Constructor) {
+          object2[json4all.PretendedClass] = Constructor;
+          object2.JSON4replacer = Constructor.prototype.JSON4replacer;
+        };
+        json4all.addClass = (constructor2) => {
+          if (!(json4all.$props2serialize in constructor2.prototype)) {
+            throw new Error("must add parameters or properties");
+          }
+          var propList = constructor2.prototype[json4all.$props2serialize];
+          constructor2.prototype.JSON4replacer = function() {
+            var o = {};
+            for (var prop of propList) {
+              o[prop.name] = this[prop.name];
+            }
+            return o;
+          };
+          constructor2.JSON4reviver = function(value, constructor3) {
+            var constructParams = propList.filter((p2) => p2.construct != null).map((p2) => value[p2.name]);
+            var o = new constructor3(...constructParams);
+            for (var p of propList) {
+              if (!p.construct) {
+                o[p.name] = value[p.name];
+              }
+            }
+            return o;
+          };
+          json4all.addType(constructor2);
+        };
+        return json4all;
+      }
+    );
+  }
+});
+
+// src/components/grid/GenericDataGrid.tsx
+import { useState as useState4, useEffect, useCallback as useCallback4, useMemo as useMemo2, useRef } from "react";
+import { DataGrid } from "react-data-grid";
+import "react-data-grid/lib/styles.css";
+
+// src/hooks/useApiCall.ts
+import { useState as useState2, useCallback as useCallback2 } from "react";
+
+// src/contexts/SnackbarContext.tsx
+import React, { createContext, useContext, useState, useCallback } from "react";
+import MuiAlert from "@mui/material/Alert";
+import Snackbar from "@mui/material/Snackbar";
+import { jsx, jsxs } from "react/jsx-runtime";
+var SnackbarAlert = React.forwardRef(function SnackbarAlert2(props, ref) {
+  return /* @__PURE__ */ jsx(MuiAlert, { elevation: 6, ref, variant: "filled", ...props });
+});
+var SnackbarContext = createContext(void 0);
+var DEFAULT_SUCCESS_DURATION = 3e3;
+var DEFAULT_ERROR_DURATION = 5e3;
+var SnackbarProvider = ({ children }) => {
+  const [snackbar, setSnackbar] = useState({
+    open: false,
+    message: "",
+    severity: "info",
+    duration: DEFAULT_SUCCESS_DURATION
+    // Valor inicial
+  });
+  const showSnackbar = useCallback((message, severity, duration) => {
+    const finalDuration = duration !== void 0 && duration !== null ? duration : severity === "error" ? DEFAULT_ERROR_DURATION : DEFAULT_SUCCESS_DURATION;
+    setSnackbar({
+      open: true,
+      message,
+      severity,
+      duration: finalDuration
+    });
+  }, []);
+  const showSuccess = useCallback((message, duration) => showSnackbar(message, "success", duration), [showSnackbar]);
+  const showError = useCallback((message, duration) => showSnackbar(message, "error", duration), [showSnackbar]);
+  const showWarning = useCallback((message, duration) => showSnackbar(message, "warning", duration), [showSnackbar]);
+  const showInfo = useCallback((message, duration) => showSnackbar(message, "info", duration), [showSnackbar]);
+  const handleCloseSnackbar = (event, reason) => {
+    if (reason === "clickaway") {
+      return;
+    }
+    setSnackbar((prev) => ({ ...prev, open: false }));
+  };
+  return /* @__PURE__ */ jsxs(SnackbarContext.Provider, { value: { showSnackbar, showSuccess, showError, showWarning, showInfo }, children: [
+    children,
+    /* @__PURE__ */ jsx(
+      Snackbar,
+      {
+        open: snackbar.open,
+        autoHideDuration: snackbar.duration,
+        onClose: handleCloseSnackbar,
+        anchorOrigin: { vertical: "top", horizontal: "center" },
+        children: /* @__PURE__ */ jsx(SnackbarAlert, { onClose: handleCloseSnackbar, severity: snackbar.severity, children: snackbar.message })
+      }
+    )
+  ] });
+};
+var useSnackbar = () => {
+  const context = useContext(SnackbarContext);
+  if (context === void 0) {
+    throw new Error("useSnackbar must be used within a SnackbarProvider");
+  }
+  return context;
+};
+
+// src/env.ts
+var getEnvVar = (key) => {
+  if (typeof import.meta !== "undefined" && import.meta.env) {
+    const viteKey = `VITE_${key}`;
+    if (import.meta.env[viteKey]) {
+      return import.meta.env[viteKey];
+    }
+  }
+  if (typeof process !== "undefined" && process.env) {
+    const craKey = `REACT_APP_${key}`;
+    if (process.env[craKey]) {
+      return process.env[craKey];
+    }
+    if (process.env[key]) {
+      return process.env[key];
+    }
+  }
+  console.warn(`Variable de entorno "${key}" no encontrada. Aseg\xFArate de definirla con el prefijo correcto (VITE_ o REACT_APP_).`);
+  return "";
+};
+var envConfig = {
+  backendUrl: getEnvVar("BACKEND_URL")
+  // Agrega aquí las demás variables siguiendo el mismo patrón
+};
+
+// src/utils/fetchApi.ts
+async function fetchApi(endPoint, options) {
+  const BACKEND_URL = envConfig.backendUrl;
+  const defaultHeaders = {
+    "Content-Type": "application/x-www-form-urlencoded"
+  };
+  const config = {
+    ...options,
+    headers: {
+      ...defaultHeaders,
+      ...options?.headers
+    },
+    credentials: "include"
+  };
+  if (config.method === "GET" || config.method === "HEAD") {
+    delete config.body;
+  }
+  return await fetch(BACKEND_URL + endPoint, config);
+}
+var executeBackendProcedure = async (procedureName, params) => {
+  function stringifyObjectsAndArraysInParams(params2) {
+    const newParams = {};
+    for (const key in params2) {
+      if (Object.prototype.hasOwnProperty.call(params2, key)) {
+        const value = params2[key];
+        if (typeof value === "object" && value !== null) {
+          try {
+            newParams[key] = JSON.stringify(value);
+          } catch (e) {
+            console.warn(`Warning: Could not stringify value for key '${key}'. Keeping original value. Error:`, e);
+            newParams[key] = value;
+          }
+        } else {
+          newParams[key] = value;
+        }
+      }
+    }
+    return newParams;
+  }
+  const body = new URLSearchParams(stringifyObjectsAndArraysInParams(params));
+  const response = await fetchApi(`/${procedureName}`, { body, method: "POST" });
+  if (response.ok) {
+    const rawResponseTextDefinition = await response.text();
+    const result = JSON.parse(rawResponseTextDefinition.replace(/^--\n/, ""));
+    if (result.error) {
+      throw new Error(result.error.message);
+    } else {
+      return result;
+    }
+  } else {
+    const errorTextDefinition = await response.text();
+    throw new Error(`Error al ejecutar procedure '${procedureName}': ${response.status} - ${errorTextDefinition}`);
+  }
+};
+
+// src/hooks/useApiCall.ts
+var useApiCall = () => {
+  const { showSnackbar } = useSnackbar();
+  const [loading, setLoading] = useState2(false);
+  const [error, setError] = useState2(null);
+  const callApi = useCallback2(async (procedureName, params) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await executeBackendProcedure(procedureName, params);
+      return result === null ? void 0 : result;
+    } catch (err) {
+      setError(err);
+      let snackbarMessage = `Error inesperado al ejecutar '${procedureName}'.`;
+      if (err instanceof TypeError) {
+        snackbarMessage = `Problema de conexi\xF3n: ${err.message}. Por favor, revisa tu internet o intenta de nuevo.`;
+      } else if (err instanceof Error) {
+        snackbarMessage = err.message;
+      }
+      showSnackbar(snackbarMessage, "error");
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  }, [showSnackbar]);
+  return { callApi, loading, error };
+};
+
+// src/components/grid/GenericDataGrid.tsx
+import {
+  CircularProgress,
+  Typography as Typography5,
+  Box as Box4,
+  Alert,
+  useTheme,
+  Button as Button2,
+  IconButton
+} from "@mui/material";
+
+// src/utils/functions.tsx
+var JSON4all = __toESM(require_json4all(), 1);
+
+// src/store/index.ts
+import { configureStore, combineReducers } from "@reduxjs/toolkit";
+import {
+  persistStore,
+  persistReducer,
+  FLUSH,
+  REHYDRATE,
+  PAUSE,
+  PERSIST,
+  PURGE,
+  REGISTER
+} from "redux-persist";
+import storage from "redux-persist/lib/storage";
+
+// src/store/clientContextSlice.ts
+import { createSlice, createAsyncThunk } from "@reduxjs/toolkit";
+var initialState = {
+  menu: [],
+  procedure: {},
+  procedures: [],
+  config: {},
+  // Inicializa con un objeto vacío o valores por defecto adecuados
+  useragent: {},
+  // Igual aquí
+  username: "",
+  status: "idle",
+  // Por defecto, sin carga
+  error: null
+  // Sin error
+};
+var fetchClientContext = createAsyncThunk(
+  "clientContext/fetchClientContext",
+  async (_, { rejectWithValue }) => {
+    try {
+      const setupResponse = await fetchApi("/client-setup", { method: "GET" });
+      if (!setupResponse.ok) {
+        const errorData = await setupResponse.text();
+        throw new Error(errorData || "Error al obtener configuraci\xF3n del cliente");
+      }
+      const clientSetup = await setupResponse.json();
+      return clientSetup;
+    } catch (error) {
+      return rejectWithValue(error.message || "Error desconocido al cargar el contexto");
+    }
+  }
+);
+var clientContextSlice = createSlice({
+  name: "clientContext",
+  initialState,
+  reducers: {
+    // Un reducer para limpiar el contexto del cliente (ej. al cerrar sesión)
+    clearClientContext: (state) => {
+      Object.assign(state, initialState);
+    }
+    // Puedes añadir otros reducers aquí si necesitas modificar partes del clientContext directamente
+    // pero el thunk es la forma preferida para la carga inicial.
+  },
+  // **extraReducers maneja las acciones del thunk asíncrono**
+  extraReducers: (builder) => {
+    builder.addCase(fetchClientContext.pending, (state) => {
+      state.status = "loading";
+      state.error = null;
+    }).addCase(fetchClientContext.fulfilled, (state, action) => {
+      state.status = "succeeded";
+      state.menu = action.payload.menu;
+      state.procedure = action.payload.procedure;
+      state.procedures = action.payload.procedures;
+      state.config = action.payload.config;
+      state.useragent = action.payload.useragent;
+      state.username = action.payload.username;
+      state.error = null;
+    }).addCase(fetchClientContext.rejected, (state, action) => {
+      state.status = "failed";
+      state.error = action.payload || "Fallo al cargar el contexto del cliente";
+    });
+  }
+});
+var { clearClientContext } = clientContextSlice.actions;
+var clientContextSlice_default = clientContextSlice.reducer;
+
+// src/store/routerSlice.ts
+import { createSlice as createSlice2 } from "@reduxjs/toolkit";
+var initialState2 = {
+  currentPath: "/",
+  previousPath: null,
+  redirectPath: null
+  // <--- Inicializamos en null
+};
+var routerSlice = createSlice2({
+  name: "router",
+  initialState: initialState2,
+  reducers: {
+    setCurrentPath: (state, action) => {
+      state.previousPath = state.currentPath;
+      state.currentPath = action.payload;
+    },
+    setRedirectPath: (state, action) => {
+      state.redirectPath = action.payload;
+    },
+    resetRouterState: (state) => {
+      state.currentPath = "/";
+      state.previousPath = null;
+      state.redirectPath = null;
+    }
+  }
+});
+var { setCurrentPath, setRedirectPath, resetRouterState } = routerSlice.actions;
+var routerSlice_default = routerSlice.reducer;
+
+// src/store/menuUiSlice.ts
+import { createSlice as createSlice3 } from "@reduxjs/toolkit";
+var initialState3 = {
+  isDrawerOpen: false,
+  subMenuOpenStates: {}
+};
+var menuUiSlice = createSlice3({
+  name: "menuUi",
+  initialState: initialState3,
+  reducers: {
+    setDrawerOpen: (state, action) => {
+      state.isDrawerOpen = action.payload;
+    },
+    toggleDrawer: (state) => {
+      state.isDrawerOpen = !state.isDrawerOpen;
+    },
+    setSubMenuOpen: (state, action) => {
+      state.subMenuOpenStates[action.payload.menuName] = action.payload.isOpen;
+    },
+    toggleSubMenu: (state, action) => {
+      state.subMenuOpenStates[action.payload] = !state.subMenuOpenStates[action.payload];
+    },
+    // --- NUEVO REDUCER: Establecer el estado de todos los submenús ---
+    setAllSubMenusOpen: (state, action) => {
+      for (const menuName in state.subMenuOpenStates) {
+        if (Object.prototype.hasOwnProperty.call(state.subMenuOpenStates, menuName)) {
+          state.subMenuOpenStates[menuName] = action.payload;
+        }
+      }
+    },
+    resetMenuUiState: (state) => {
+      Object.assign(state, initialState3);
+    }
+  }
+});
+var {
+  setDrawerOpen,
+  toggleDrawer,
+  setSubMenuOpen,
+  toggleSubMenu,
+  setAllSubMenusOpen,
+  // ¡Exportamos la nueva acción!
+  resetMenuUiState
+} = menuUiSlice.actions;
+var menuUiSlice_default = menuUiSlice.reducer;
+
+// src/store/index.ts
+import { useDispatch, useSelector } from "react-redux";
+var rootReducer = combineReducers({
+  clientContext: clientContextSlice_default,
+  router: routerSlice_default,
+  menuUi: menuUiSlice_default
+  // ...otros slices
+});
+var persistConfig = {
+  key: "root",
+  storage,
+  whitelist: ["clientContext", "router", "menuUi"]
+};
+var persistedReducer = persistReducer(persistConfig, rootReducer);
+var store = configureStore({
+  reducer: persistedReducer,
+  middleware: (getDefaultMiddleware) => getDefaultMiddleware({
+    serializableCheck: {
+      ignoredActions: [FLUSH, REHYDRATE, PAUSE, PERSIST, PURGE, REGISTER]
+    }
+  })
+});
+var persistor = persistStore(store);
+var useAppDispatch = useDispatch;
+var useAppSelector = useSelector;
+var useClientContextStatus = () => {
+  return useAppSelector((state) => state.clientContext.status);
+};
+var useIsDrawerOpen = () => {
+  return useAppSelector((state) => state.menuUi.isDrawerOpen);
+};
+var useSubMenuOpenState = (menuName) => {
+  return useAppSelector((state) => state.menuUi.subMenuOpenStates[menuName] || false);
+};
+var useRedirectPath = () => {
+  return useAppSelector((state) => state.router.redirectPath);
+};
+
+// src/utils/functions.tsx
+var cambiarGuionesBajosPorEspacios = (texto) => texto.replace(/_/g, " ");
+
+// src/components/grid/GenericDataGrid.tsx
+import SearchIcon from "@mui/icons-material/Search";
+import SearchOffIcon from "@mui/icons-material/SearchOff";
+import AddIcon from "@mui/icons-material/Add";
+import DeleteIcon from "@mui/icons-material/Delete";
+
+// src/components/grid/PkHeaderRenderer.tsx
+import { Box, Typography } from "@mui/material";
+import { jsx as jsx2 } from "react/jsx-runtime";
+function PkHeaderRenderer(props) {
+  const { column } = props;
+  const isPrimaryKey = column.isPK;
+  return /* @__PURE__ */ jsx2(
+    Box,
+    {
+      sx: {
+        display: "flex",
+        flexDirection: "column",
+        justifyContent: "center",
+        alignItems: "flex-start",
+        padding: "4px",
+        boxSizing: "border-box",
+        height: "100%"
+      },
+      children: /* @__PURE__ */ jsx2(
+        Typography,
+        {
+          variant: "body2",
+          sx: {
+            fontWeight: "bold",
+            textDecoration: isPrimaryKey ? "underline" : "none",
+            fontSize: "0.875rem"
+            // Puedes ajustar el tamaño si es necesario
+          },
+          children: column.name
+        }
+      )
+    }
+  );
+}
+var PkHeaderRenderer_default = PkHeaderRenderer;
+
+// src/components/grid/PkCellRenderer.tsx
+import { Typography as Typography2 } from "@mui/material";
+import { jsx as jsx3 } from "react/jsx-runtime";
+function PkCellRenderer(props) {
+  const { column, row } = props;
+  const isPrimaryKey = column.isPK;
+  const rowAsRecord = row;
+  const value = rowAsRecord[column.key];
+  return /* @__PURE__ */ jsx3(
+    Typography2,
+    {
+      variant: "body2",
+      sx: {
+        //fontWeight: isPrimaryKey ? 'bold' : 'normal',
+        fontSize: "0.875rem",
+        // Ajusta el tamaño si es necesario
+        whiteSpace: "nowrap",
+        overflow: "hidden",
+        textOverflow: "ellipsis",
+        width: "100%"
+      },
+      children: value === null || value === void 0 ? "" : String(value)
+    }
+  );
+}
+var PkCellRenderer_default = PkCellRenderer;
+
+// src/components/ConfirmDialog.tsx
+import Dialog from "@mui/material/Dialog";
+import DialogTitle from "@mui/material/DialogTitle";
+import DialogContent from "@mui/material/DialogContent";
+import DialogContentText from "@mui/material/DialogContentText";
+import DialogActions from "@mui/material/DialogActions";
+import Button from "@mui/material/Button";
+import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+var ConfirmDialog = ({ open, onClose, title, message }) => {
+  return /* @__PURE__ */ jsxs2(
+    Dialog,
+    {
+      open,
+      onClose: () => onClose(false),
+      "aria-labelledby": "confirm-dialog-title",
+      "aria-describedby": "confirm-dialog-description",
+      children: [
+        /* @__PURE__ */ jsx4(DialogTitle, { id: "confirm-dialog-title", children: title }),
+        /* @__PURE__ */ jsx4(DialogContent, { children: /* @__PURE__ */ jsx4(DialogContentText, { id: "confirm-dialog-description", children: message }) }),
+        /* @__PURE__ */ jsxs2(DialogActions, { children: [
+          /* @__PURE__ */ jsx4(Button, { onClick: () => onClose(false), color: "primary", children: "Cancelar" }),
+          /* @__PURE__ */ jsx4(Button, { onClick: () => onClose(true), color: "error", autoFocus: true, children: "Confirmar" })
+        ] })
+      ]
+    }
+  );
+};
+
+// src/components/grid/FilterInputRender.tsx
+import { InputBase } from "@mui/material";
+import { jsx as jsx5 } from "react/jsx-runtime";
+function FilterInputRenderer({
+  column,
+  filters,
+  setFilters
+}) {
+  return /* @__PURE__ */ jsx5(
+    InputBase,
+    {
+      value: filters[column.key] || "",
+      onChange: (e) => setFilters({
+        ...filters,
+        [column.key]: e.target.value
+      }),
+      sx: {
+        width: "100%",
+        margin: "0",
+        border: "1px solid #ccc",
+        borderRadius: "4px",
+        padding: "2px 4px",
+        fontSize: "0.8rem",
+        boxSizing: "border-box"
+      },
+      onClick: (e) => e.stopPropagation()
+    }
+  );
+}
+var FilterInputRender_default = FilterInputRenderer;
+
+// src/components/grid/InputRendered.tsx
+import { useCallback as useCallback3, useMemo, useState as useState3 } from "react";
+import InputBase2 from "@mui/material/InputBase";
+import { jsx as jsx6 } from "react/jsx-runtime";
+function InputRenderer({
+  column,
+  row,
+  rowIdx,
+  tableDefinition,
+  onRowChange,
+  onClose,
+  setCellFeedback,
+  onEnterPress,
+  setTableData,
+  setLocalCellChanges,
+  localCellChanges,
+  primaryKey
+}) {
+  const tableName = tableDefinition.tableName;
+  const [editingValue, setEditingValue] = useState3(row[column.key]);
+  const { showSuccess, showError } = useSnackbar();
+  const initialRowId = useMemo(() => getPrimaryKeyValues(row, primaryKey), [row, primaryKey]);
+  const { callApi, loading, error } = useApiCall();
+  const handleCommit = useCallback3(async (currentValue, closeEditor, focusNextCell) => {
+    const processedNewValue = typeof currentValue === "string" ? currentValue.trim() === "" ? null : currentValue.trim() : currentValue;
+    const potentialUpdatedRow = { ...row, [column.key]: processedNewValue };
+    const arePKValuesFilled = tableDefinition.primaryKey.every(
+      (key) => potentialUpdatedRow[key] !== void 0 && potentialUpdatedRow[key] !== null && String(potentialUpdatedRow[key]).trim() !== ""
+    );
+    const isNewRow = !arePKValuesFilled || potentialUpdatedRow[NEW_ROW_INDICATOR];
+    const isMandatoryField = tableDefinition.primaryKey.includes(column.key) || tableDefinition.fields.find((f) => f.name === column.key)?.nullable === false;
+    const isMandatoryFieldEmpty = isNewRow && isMandatoryField && (processedNewValue === null || processedNewValue === void 0 || String(processedNewValue).trim() === "");
+    if (processedNewValue === row[column.key] && !isNewRow && !isMandatoryFieldEmpty) {
+      console.log("No se guard\xF3: el valor no cambi\xF3 (y no es una nueva fila o campo obligatorio vac\xEDo que se est\xE1 iniciando).");
+      onClose(false, focusNextCell);
+      setLocalCellChanges((prev) => {
+        const newMap = new Map(prev);
+        const columnKeys = newMap.get(initialRowId);
+        if (columnKeys) {
+          columnKeys.delete(column.key);
+          if (columnKeys.size === 0) {
+            newMap.delete(initialRowId);
+          } else {
+            newMap.set(initialRowId, columnKeys);
+          }
+        }
+        return newMap;
+      });
+      return;
+    }
+    const oldRowData = { ...row };
+    const primaryKeyValuesForBackend = tableDefinition.primaryKey.map((key) => potentialUpdatedRow[key]);
+    const currentRowIdBeforeUpdate = getPrimaryKeyValues(oldRowData, tableDefinition.primaryKey);
+    onRowChange({ ...row, [column.key]: processedNewValue }, true);
+    onClose(true, focusNextCell);
+    if (isNewRow) {
+      const areAllMandatoryFieldsFilled = tableDefinition.fields.every((fieldDef) => {
+        const isMandatory = fieldDef.nullable === false || fieldDef.isPk;
+        const fieldValue = potentialUpdatedRow[fieldDef.name];
+        return !isMandatory || fieldValue !== null && fieldValue !== void 0 && String(fieldValue).trim() !== "";
+      });
+      if (!areAllMandatoryFieldsFilled) {
+        console.log("Nueva fila: Faltan campos obligatorios. No se guarda en el backend todav\xEDa.");
+        setLocalCellChanges((prev) => {
+          const newMap = new Map(prev);
+          const currentColumnsInRow = newMap.get(initialRowId) || /* @__PURE__ */ new Set();
+          tableDefinition.fields.forEach((fieldDef) => {
+            const isMandatory = fieldDef.nullable === false || fieldDef.isPk;
+            const isEditable = fieldDef.editable !== false;
+            const fieldValue = potentialUpdatedRow[fieldDef.name];
+            if (isMandatory && isEditable && (fieldValue === null || fieldValue === void 0 || String(fieldValue).trim() === "")) {
+              currentColumnsInRow.add(fieldDef.name);
+            } else {
+              currentColumnsInRow.delete(fieldDef.name);
+            }
+          });
+          newMap.set(initialRowId, currentColumnsInRow);
+          return newMap;
+        });
+        return;
+      } else {
+        console.log("Nueva fila: Todos los campos obligatorios est\xE1n llenos. Procediendo a guardar.");
+        setLocalCellChanges((prev) => {
+          const newMap = new Map(prev);
+          newMap.delete(initialRowId);
+          return newMap;
+        });
+      }
+    }
+    const status = isNewRow ? "new" : "update";
+    let rowToSend = {};
+    if (isNewRow) {
+      tableDefinition.fields.forEach((fieldDef) => {
+        const fieldValue = potentialUpdatedRow[fieldDef.name];
+        if (fieldValue !== void 0 && fieldValue !== null && String(fieldValue).trim() !== "") {
+          rowToSend[fieldDef.name] = fieldValue;
+        } else if (tableDefinition.primaryKey.includes(fieldDef.name) && (fieldValue === null || fieldValue === void 0 || String(fieldValue).trim() === "")) {
+          rowToSend[fieldDef.name] = fieldValue;
+        }
+      });
+      if (localCellChanges.has(initialRowId)) {
+        localCellChanges.get(initialRowId)?.forEach((colKey) => {
+          if (!rowToSend.hasOwnProperty(colKey)) {
+            rowToSend[colKey] = potentialUpdatedRow[colKey];
+          }
+        });
+      }
+      delete rowToSend[NEW_ROW_INDICATOR];
+    } else {
+      rowToSend[column.key] = processedNewValue;
+      tableDefinition.primaryKey.forEach((pkField) => {
+        rowToSend[pkField] = potentialUpdatedRow[pkField];
+      });
+    }
+    try {
+      const response = await callApi("table_record_save", {
+        table: tableName,
+        primaryKeyValues: primaryKeyValuesForBackend,
+        newRow: rowToSend,
+        oldRow: oldRowData,
+        status
+      });
+      setLocalCellChanges((prev) => {
+        const newMap = new Map(prev);
+        const columnKeys = newMap.get(initialRowId);
+        if (columnKeys) {
+          columnKeys.delete(column.key);
+          if (columnKeys.size === 0) {
+            newMap.delete(initialRowId);
+          } else {
+            newMap.set(initialRowId, columnKeys);
+          }
+        }
+        return newMap;
+      });
+      showSuccess("Registro guardado exitosamente!");
+      let finalRowIdForFeedback;
+      let persistedRowData;
+      if (response.row && isNewRow) {
+        persistedRowData = { ...response.row };
+        setTableData((prevData) => {
+          const newData = [...prevData];
+          const originalRowId = getPrimaryKeyValues(oldRowData, tableDefinition.primaryKey);
+          const rowIndex = newData.findIndex((r) => getPrimaryKeyValues(r, tableDefinition.primaryKey) === originalRowId);
+          if (rowIndex !== -1) {
+            newData[rowIndex] = persistedRowData;
+          } else {
+            console.warn("Fila no encontrada para actualizar despu\xE9s de la inserci\xF3n. Podr\xEDa haber un problema de sincronizaci\xF3n.");
+            const newPrimaryKeyId = getPrimaryKeyValues(persistedRowData, tableDefinition.primaryKey);
+            const newRowIndex = newData.findIndex((r) => getPrimaryKeyValues(r, tableDefinition.primaryKey) === newPrimaryKeyId);
+            if (newRowIndex !== -1) {
+              newData[newRowIndex] = persistedRowData;
+            }
+          }
+          return newData;
+        });
+        finalRowIdForFeedback = getPrimaryKeyValues(persistedRowData, tableDefinition.primaryKey);
+      } else {
+        persistedRowData = potentialUpdatedRow;
+        const isPrimaryKeyColumn = tableDefinition.primaryKey.includes(column.key);
+        finalRowIdForFeedback = isPrimaryKeyColumn ? getPrimaryKeyValues(potentialUpdatedRow, tableDefinition.primaryKey) : currentRowIdBeforeUpdate;
+      }
+      setCellFeedback({ rowId: finalRowIdForFeedback, columnKey: column.key, type: "success" });
+    } catch (err) {
+      console.error("Error al guardar el registro:", err);
+      setCellFeedback({ rowId: currentRowIdBeforeUpdate, columnKey: column.key, type: "error" });
+      onRowChange(oldRowData, true);
+    }
+  }, [
+    column,
+    row,
+    onRowChange,
+    tableName,
+    tableDefinition.primaryKey,
+    tableDefinition.fields,
+    showSuccess,
+    showError,
+    setCellFeedback,
+    onClose,
+    setTableData,
+    setLocalCellChanges,
+    localCellChanges,
+    initialRowId
+  ]);
+  const handleKeyDown = useCallback3((event) => {
+    if (event.key === "Enter") {
+      handleCommit(editingValue, true, true);
+      event.preventDefault();
+      if (onEnterPress) {
+        onEnterPress(rowIdx, column.key);
+      }
+    } else if (event.key === "Tab") {
+      handleCommit(editingValue, true, true);
+    }
+  }, [handleCommit, editingValue, column.key, rowIdx, onEnterPress]);
+  const handleBlur = useCallback3(() => {
+    handleCommit(editingValue, true, false);
+  }, [handleCommit, editingValue]);
+  const fieldDefinition = tableDefinition.fields.find((f) => f.name === column.key);
+  const isFieldEditable = fieldDefinition?.editable !== false;
+  return /* @__PURE__ */ jsx6(
+    InputBase2,
+    {
+      value: editingValue === null ? "" : editingValue,
+      onChange: (e) => setEditingValue(e.target.value),
+      onKeyDown: handleKeyDown,
+      onBlur: handleBlur,
+      placeholder: "",
+      sx: {
+        width: "100%",
+        margin: "0",
+        border: "1px solid #ccc",
+        borderRadius: "4px",
+        padding: "2px 4px",
+        fontSize: "0.8rem",
+        boxSizing: "border-box"
+      },
+      onClick: (e) => e.stopPropagation(),
+      autoFocus: true,
+      disabled: !isFieldEditable
+    }
+  );
+}
+var InputRendered_default = InputRenderer;
+
+// src/components/grid/ExampleClientSideComponent.tsx
+import { Box as Box2, Typography as Typography3 } from "@mui/material";
+import { jsx as jsx7 } from "react/jsx-runtime";
+var ExampleClientSideComponent = ({ row, column, fieldDefinition }) => {
+  const value = row[column.key];
+  return /* @__PURE__ */ jsx7(Box2, { sx: {
+    padding: 0.5,
+    width: "100%",
+    height: "100%",
+    display: "flex",
+    alignItems: "center",
+    backgroundColor: value === "Special" ? "lightblue" : "transparent"
+  }, children: /* @__PURE__ */ jsx7(Typography3, { variant: "body2", sx: { fontWeight: "bold" }, children: value ? `CS: ${value}` : "N/A" }) });
+};
+var ExampleClientSideComponent_default = ExampleClientSideComponent;
+
+// src/components/grid/FallbackClientSideRenderer.tsx
+import { Box as Box3, Typography as Typography4, Tooltip } from "@mui/material";
+import WarningAmberIcon from "@mui/icons-material/WarningAmber";
+import { jsx as jsx8, jsxs as jsxs3 } from "react/jsx-runtime";
+var FallbackClientSideRenderer = ({ column, row, fieldDefinition }) => {
+  const value = row[column.key];
+  const clientSideName = fieldDefinition?.clientSide || "Desconocido";
+  return /* @__PURE__ */ jsx8(Tooltip, { title: `Componente clientSide '${clientSideName}' no implementado. Mostrando valor por defecto.`, children: /* @__PURE__ */ jsxs3(
+    Box3,
+    {
+      sx: {
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "space-between",
+        // Para espaciar el valor y el icono
+        gap: 1,
+        // Espacio entre elementos
+        width: "100%",
+        height: "100%",
+        paddingLeft: "8px",
+        backgroundColor: "rgba(255, 193, 7, 0.1)",
+        // Amarillo claro para advertencia
+        border: "1px dashed rgba(255, 193, 7, 0.5)",
+        boxSizing: "border-box",
+        overflow: "hidden"
+        // Evita que el contenido se desborde
+      },
+      children: [
+        /* @__PURE__ */ jsx8(Typography4, { variant: "body2", noWrap: true, sx: { flexGrow: 1 }, children: value !== null && value !== void 0 ? String(value) : "*Vac\xEDo*" }),
+        /* @__PURE__ */ jsx8(
+          WarningAmberIcon,
+          {
+            sx: {
+              fontSize: 18,
+              color: "warning.main",
+              marginRight: "4px"
+              // Pequeño margen a la derecha del icono
+            }
+          }
+        )
+      ]
+    }
+  ) });
+};
+var FallbackClientSideRenderer_default = FallbackClientSideRenderer;
+
+// src/components/grid/clientSides.ts
+var clientSides = {
+  "ExampleClientSideComponent": ExampleClientSideComponent_default,
+  // Aseguramos el tipo aquí también
+  "FallbackClientSideRenderer": FallbackClientSideRenderer_default
+  // Y aquí
+};
+var extendClientSides = (newRenderers) => {
+  clientSides = { ...clientSides, ...newRenderers };
+  console.log("clientSides extendidos:", clientSides);
+};
+
+// src/components/grid/GenericDataGrid.tsx
+import { Fragment, jsx as jsx9, jsxs as jsxs4 } from "react/jsx-runtime";
+var getPrimaryKeyValues = (row, primaryKey) => {
+  return primaryKey.map((key) => {
+    return row[key] !== void 0 && row[key] !== null ? String(row[key]) : "NULL_OR_UNDEFINED";
+  }).join("|");
+};
+var NEW_ROW_INDICATOR = ".$new";
+var GenericDataGrid = ({
+  tableName,
+  fixedFields
+}) => {
+  const [tableDefinition, setTableDefinition] = useState4(null);
+  const [tableData, setTableData] = useState4([]);
+  const [isFilterRowVisible, setIsFilterRowVisible] = useState4(false);
+  const [filters, setFilters] = useState4({});
+  const [selectedRows, setSelectedRows] = useState4(() => /* @__PURE__ */ new Set());
+  const [cellFeedback, setCellFeedback] = useState4(null);
+  const [localCellChanges, setLocalCellChanges] = useState4(/* @__PURE__ */ new Map());
+  const theme = useTheme();
+  const [openConfirmDialog, setOpenConfirmDialog] = useState4(false);
+  const [rowToDelete, setRowToDelete] = useState4(null);
+  const [exitingRowIds, setExitingRowIds] = useState4(/* @__PURE__ */ new Set());
+  const { showSuccess, showError, showWarning, showInfo } = useSnackbar();
+  const feedbackTimerRef = useRef(null);
+  const dataGridRef = useRef(null);
+  const { callApi, loading, error } = useApiCall();
+  useEffect(() => {
+    setFilters({});
+    setIsFilterRowVisible(false);
+    setSelectedRows(/* @__PURE__ */ new Set());
+    setTableDefinition(null);
+    setTableData([]);
+    setCellFeedback(null);
+    setLocalCellChanges(/* @__PURE__ */ new Map());
+    setOpenConfirmDialog(false);
+    setRowToDelete(null);
+    setExitingRowIds(/* @__PURE__ */ new Set());
+    if (feedbackTimerRef.current) {
+      clearTimeout(feedbackTimerRef.current);
+    }
+  }, [tableName]);
+  useEffect(() => {
+    const fetchDataAndDefinition = async () => {
+      try {
+        const definition = await callApi("table_structure", { table: tableName });
+        setTableDefinition(definition);
+        const data = await callApi("table_data", {
+          table: tableName,
+          fixedFields
+          // Envía el array fixedFields directamente a la API
+        });
+        setTableData(data);
+      } catch (err) {
+        setTableDefinition(null);
+        setTableData([]);
+        showError(`Error al cargar datos para la tabla '${tableName}': ${err.message || "Error desconocido"}`);
+      } finally {
+      }
+    };
+    fetchDataAndDefinition();
+  }, [tableName, fixedFields, showError]);
+  useEffect(() => {
+    if (cellFeedback) {
+      if (feedbackTimerRef.current) {
+        clearTimeout(feedbackTimerRef.current);
+      }
+      const timerDuration = cellFeedback.type === "success" ? 4e3 : 3e3;
+      feedbackTimerRef.current = setTimeout(() => {
+        setCellFeedback(null);
+      }, timerDuration);
+    }
+    return () => {
+      if (feedbackTimerRef.current) {
+        clearTimeout(feedbackTimerRef.current);
+      }
+    };
+  }, [cellFeedback]);
+  const primaryKey = useMemo2(() => {
+    if (!tableDefinition) return ["id"];
+    return tableDefinition.primaryKey && tableDefinition.primaryKey.length > 0 ? tableDefinition.primaryKey : ["id"];
+  }, [tableDefinition]);
+  const toggleFilterVisibility = useCallback4(() => {
+    setIsFilterRowVisible((prev) => {
+      if (prev) {
+        setFilters({});
+      }
+      return !prev;
+    });
+  }, []);
+  const handleAddRow = useCallback4(() => {
+    if (!tableDefinition) {
+      showWarning("No se puede agregar una fila sin la definici\xF3n de la tabla.");
+      return;
+    }
+    const newRow = {};
+    tableDefinition.fields.forEach((field) => {
+      newRow[field.name] = null;
+    });
+    newRow[NEW_ROW_INDICATOR] = true;
+    if (fixedFields) {
+      fixedFields.forEach((fixedField) => {
+        newRow[fixedField.fieldName] = fixedField.value;
+      });
+    }
+    setTableData((prevData) => [newRow, ...prevData]);
+    setSelectedRows(/* @__PURE__ */ new Set());
+    const tempRowId = getPrimaryKeyValues(newRow, primaryKey);
+    setLocalCellChanges((prev) => {
+      const newMap = new Map(prev);
+      const mandatoryEditableColumns = /* @__PURE__ */ new Set();
+      tableDefinition.fields.forEach((field) => {
+        const isMandatory = field.nullable === false || field.isPk;
+        const isEditable = field.editable !== false;
+        if (isMandatory && isEditable) {
+          mandatoryEditableColumns.add(field.name);
+        }
+      });
+      newMap.set(tempRowId, mandatoryEditableColumns);
+      return newMap;
+    });
+  }, [tableDefinition, showWarning, primaryKey, fixedFields]);
+  const handleDeleteRow = useCallback4(async (row) => {
+    setRowToDelete(row);
+    setOpenConfirmDialog(true);
+  }, []);
+  const handleConfirmDelete = useCallback4(async (confirm) => {
+    setOpenConfirmDialog(false);
+    if (!confirm || !rowToDelete) {
+      showWarning("Eliminaci\xF3n cancelada por el usuario.");
+      setRowToDelete(null);
+      return;
+    }
+    if (!tableDefinition || !tableName) {
+      showError("No se puede eliminar la fila sin la definici\xF3n de la tabla o el nombre de la tabla.");
+      setRowToDelete(null);
+      return;
+    }
+    const rowId = getPrimaryKeyValues(rowToDelete, primaryKey);
+    setExitingRowIds((prev) => new Set(prev).add(rowId));
+    setTimeout(async () => {
+      if (rowToDelete[NEW_ROW_INDICATOR]) {
+        setTimeout(() => {
+          setTableData((prevData) => prevData.filter((row) => getPrimaryKeyValues(row, primaryKey) !== rowId));
+          setLocalCellChanges((prev) => {
+            const newMap = new Map(prev);
+            newMap.delete(rowId);
+            return newMap;
+          });
+          setSelectedRows((prev) => {
+            const newSet = new Set(prev);
+            newSet.delete(rowId);
+            return newSet;
+          });
+          setExitingRowIds((prev) => {
+            const newSet = new Set(prev);
+            newSet.delete(rowId);
+            return newSet;
+          });
+          showInfo(`Fila no guardada '${rowId}' eliminada localmente.`);
+          setRowToDelete(null);
+        }, 500);
+        return;
+      }
+      try {
+        const primaryKeyValues = tableDefinition.primaryKey.map((key) => rowToDelete[key]);
+        await callApi("table_record_delete", {
+          table: tableName,
+          primaryKeyValues
+        });
+        console.log(`Fila con ID ${rowId} eliminada exitosamente del backend.`);
+        setTimeout(() => {
+          setTableData((prevData) => prevData.filter((row) => getPrimaryKeyValues(row, primaryKey) !== rowId));
+          setLocalCellChanges((prev) => {
+            const newMap = new Map(prev);
+            newMap.delete(rowId);
+            return newMap;
+          });
+          setSelectedRows((prev) => {
+            const newSet = new Set(prev);
+            newSet.delete(rowId);
+            return newSet;
+          });
+          setExitingRowIds((prev) => {
+            const newSet = new Set(prev);
+            newSet.delete(rowId);
+            return newSet;
+          });
+          showSuccess(`Fila '${rowId}' eliminada exitosamente.`);
+          setRowToDelete(null);
+        }, 500);
+      } catch (err) {
+        console.error(`Error al eliminar la fila '${rowId}':`, err);
+        showError(`Error al eliminar la fila '${rowId}': ${err.message || "Error desconocido"}`);
+        setExitingRowIds((prev) => {
+          const newSet = new Set(prev);
+          newSet.delete(rowId);
+          return newSet;
+        });
+        setRowToDelete(null);
+      }
+    }, 10);
+  }, [rowToDelete, tableDefinition, tableName, primaryKey, showInfo, showSuccess, showError, showWarning, setTableData, setLocalCellChanges, setSelectedRows]);
+  const filteredRows = useMemo2(() => {
+    let rows = tableData;
+    if (isFilterRowVisible) {
+      Object.keys(filters).forEach((key) => {
+        const filterValue = filters[key].toLowerCase();
+        if (filterValue) {
+          rows = rows.filter((row) => {
+            const cellValue = String(row[key] || "").toLowerCase();
+            return cellValue.includes(filterValue);
+          });
+        }
+      });
+    }
+    return rows;
+  }, [tableData, filters, isFilterRowVisible]);
+  const handleEnterKeyPressInEditor = useCallback4((rowIndex, columnKey, currentColumns) => {
+    if (dataGridRef.current && tableDefinition) {
+      const currentColumnIndex = currentColumns.findIndex((col) => col.key === columnKey);
+      if (currentColumnIndex !== -1) {
+        let nextColumnIndex = currentColumnIndex + 1;
+        let nextRowIndex = rowIndex;
+        let foundNextTarget = false;
+        while (!foundNextTarget) {
+          if (nextColumnIndex >= currentColumns.length) {
+            nextColumnIndex = 0;
+            nextRowIndex++;
+            if (nextRowIndex >= filteredRows.length) {
+              nextRowIndex = 0;
+              nextColumnIndex = 0;
+              if (filteredRows.length === 0 || rowIndex === filteredRows.length - 1 && currentColumnIndex === currentColumns.length - 1) {
+                foundNextTarget = true;
+                break;
+              }
+            }
+          }
+          const nextColumn = currentColumns[nextColumnIndex];
+          if (nextColumn) {
+            const fieldDefinition = tableDefinition.fields.find((f) => f.name === nextColumn.key);
+            const isEditableField = fieldDefinition?.editable !== false;
+            if (nextColumn.key !== "filterToggle" && nextColumn.key !== "deleteAction" && isEditableField) {
+              foundNextTarget = true;
+            } else {
+              nextColumnIndex++;
+            }
+          } else {
+            nextColumnIndex++;
+          }
+        }
+        if (foundNextTarget) {
+          dataGridRef.current.selectCell({ rowIdx: nextRowIndex, idx: nextColumnIndex }, { enableEditor: false, scrollIntoView: true });
+        }
+      }
+    }
+  }, [filteredRows, tableDefinition]);
+  const columns = useMemo2(() => {
+    if (!tableDefinition) return [];
+    const fieldsToShow = tableDefinition.fields.filter((field) => {
+      const fixedFieldEntry = fixedFields?.find((f) => f.fieldName === field.name);
+      return !(fixedFieldEntry && fixedFieldEntry.until === void 0);
+    });
+    const defaultColumns = fieldsToShow.map((field) => {
+      const isFixedField = fixedFields?.some((f) => f.fieldName === field.name);
+      const isFieldEditable = field.editable !== false && !isFixedField;
+      return {
+        key: field.name,
+        name: field.label || cambiarGuionesBajosPorEspacios(field.name),
+        resizable: true,
+        sortable: true,
+        editable: isFieldEditable,
+        // Usar la nueva bandera de editable
+        flexGrow: 1,
+        minWidth: 60,
+        isPK: field.isPk,
+        renderHeaderCell: (props) => /* @__PURE__ */ jsx9(PkHeaderRenderer_default, { ...props }),
+        renderSummaryCell: ({ column }) => {
+          const fixedFieldEntry = fixedFields?.find((f) => f.fieldName === column.key);
+          if (fixedFieldEntry && fixedFieldEntry.until === void 0) return null;
+          return isFilterRowVisible ? /* @__PURE__ */ jsx9(
+            FilterInputRender_default,
+            {
+              column,
+              filters,
+              setFilters
+            }
+          ) : null;
+        },
+        renderCell: (props) => {
+          const rowId = getPrimaryKeyValues(props.row, primaryKey);
+          const fieldDefinition = tableDefinition.fields.find((f) => f.name === props.column.key);
+          if (fieldDefinition?.clientSide) {
+            const ClientSideComponent = clientSides[fieldDefinition.clientSide];
+            if (ClientSideComponent) {
+              return /* @__PURE__ */ jsx9(
+                ClientSideComponent,
+                {
+                  ...props,
+                  fieldDefinition,
+                  tableDefinition,
+                  primaryKey
+                }
+              );
+            } else {
+              return /* @__PURE__ */ jsx9(
+                FallbackClientSideRenderer_default,
+                {
+                  ...props,
+                  fieldDefinition,
+                  tableDefinition,
+                  primaryKey
+                }
+              );
+            }
+          }
+          let cellBackgroundColor = "transparent";
+          if (cellFeedback && cellFeedback.rowId === rowId && cellFeedback.columnKey === props.column.key) {
+            cellBackgroundColor = cellFeedback.type === "error" ? theme.palette.error.light : theme.palette.success.light;
+          } else {
+            const isNewRowLocalCheck = props.row[NEW_ROW_INDICATOR];
+            const isMandatory = tableDefinition.primaryKey.includes(props.column.key) || tableDefinition.fields.find((f) => f.name === props.column.key)?.nullable === false;
+            const hasValue = props.row[props.column.key] !== null && props.row[props.column.key] !== void 0 && String(props.row[props.column.key]).trim() !== "";
+            const isFixedFieldCurrent = fixedFields?.some((f) => f.fieldName === props.column.key);
+            if (isFixedFieldCurrent) {
+              cellBackgroundColor = theme.palette.action.selected;
+            } else if (isNewRowLocalCheck && isMandatory && !hasValue || localCellChanges.has(rowId) && localCellChanges.get(rowId)?.has(props.column.key)) {
+              cellBackgroundColor = theme.palette.info.light;
+            }
+          }
+          return /* @__PURE__ */ jsx9(
+            Box4,
+            {
+              sx: {
+                position: "absolute",
+                top: 0,
+                left: 0,
+                width: "100%",
+                height: "100%",
+                backgroundColor: cellBackgroundColor,
+                transition: "background-color 0.3s ease-in-out",
+                display: "flex",
+                alignItems: "center",
+                paddingLeft: "8px",
+                boxSizing: "border-box"
+              },
+              children: /* @__PURE__ */ jsx9(
+                PkCellRenderer_default,
+                {
+                  ...props,
+                  column: { ...props.column, isPK: !!field.isPk }
+                }
+              )
+            }
+          );
+        }
+      };
+    });
+    const filterToggleColumn = {
+      key: "filterToggle",
+      name: "",
+      width: 50,
+      resizable: false,
+      sortable: false,
+      frozen: true,
+      renderHeaderCell: () => /* @__PURE__ */ jsx9(
+        IconButton,
+        {
+          color: "inherit",
+          onClick: toggleFilterVisibility,
+          size: "small",
+          title: isFilterRowVisible ? "Ocultar filtros" : "Mostrar filtros",
+          sx: { p: 0.5 },
+          children: isFilterRowVisible ? /* @__PURE__ */ jsx9(SearchOffIcon, { sx: { fontSize: 20 } }) : /* @__PURE__ */ jsx9(SearchIcon, { sx: { fontSize: 20 } })
+        }
+      ),
+      renderSummaryCell: () => null
+    };
+    const deleteActionColumn = {
+      key: "deleteAction",
+      name: "",
+      width: 50,
+      resizable: false,
+      sortable: false,
+      frozen: true,
+      renderHeaderCell: () => null,
+      renderSummaryCell: () => null,
+      renderCell: ({ row }) => {
+        if (!tableDefinition.allow?.delete) {
+          return null;
+        }
+        return /* @__PURE__ */ jsx9(Box4, { sx: { display: "flex", justifyContent: "center", alignItems: "center", height: "100%" }, children: /* @__PURE__ */ jsx9(
+          Button2,
+          {
+            variant: "outlined",
+            color: "error",
+            size: "small",
+            onClick: () => handleDeleteRow(row),
+            title: "Eliminar fila",
+            sx: {
+              minWidth: 35,
+              height: 30,
+              p: 0.5,
+              "& .MuiButton-startIcon": { m: 0 }
+            },
+            children: /* @__PURE__ */ jsx9(DeleteIcon, { sx: { fontSize: 18 } })
+          }
+        ) });
+      }
+    };
+    const allColumns = [filterToggleColumn, deleteActionColumn, ...defaultColumns];
+    return allColumns.map((col) => {
+      if (col.editable) {
+        const fieldDefinition = tableDefinition.fields.find((f) => f.name === col.key);
+        const isFixedField = fixedFields?.some((f) => f.fieldName === col.key);
+        const isFieldEditableByUI = fieldDefinition?.editable !== false && !isFixedField;
+        if (!isFieldEditableByUI) {
+          return { ...col, renderEditCell: void 0 };
+        }
+        return {
+          ...col,
+          renderEditCell: (props) => {
+            return /* @__PURE__ */ jsx9(
+              InputRendered_default,
+              {
+                ...props,
+                tableDefinition,
+                setCellFeedback,
+                onEnterPress: (rowIndex, columnKey) => handleEnterKeyPressInEditor(rowIndex, columnKey, allColumns),
+                setTableData,
+                setLocalCellChanges,
+                localCellChanges,
+                primaryKey
+              }
+            );
+          }
+        };
+      }
+      return col;
+    });
+  }, [
+    tableDefinition,
+    isFilterRowVisible,
+    filters,
+    toggleFilterVisibility,
+    cellFeedback,
+    primaryKey,
+    theme.palette.success.light,
+    theme.palette.error.light,
+    theme.palette.info.light,
+    theme.palette.action.selected,
+    // Añade el color de campos fijos
+    handleEnterKeyPressInEditor,
+    setTableData,
+    localCellChanges,
+    handleDeleteRow,
+    fixedFields
+    // Añade fixedFields como dependencia
+  ]);
+  const showNoRowsMessage = filteredRows.length === 0 && !loading && !error;
+  const handleRowsChange = useCallback4((updatedRows) => {
+    setTableData(updatedRows);
+  }, []);
+  const handleCellClick = useCallback4((args) => {
+    const fieldDefinition = tableDefinition?.fields.find((f) => f.name === args.column.key);
+    const isFixedField = fixedFields?.some((f) => f.fieldName === args.column.key);
+    const isEditable = fieldDefinition?.editable !== false && !isFixedField;
+    console.log("Clicked column index:", args.column.idx);
+    console.log("Clicked row index:", args.rowIdx);
+    console.log("Is editable:", isEditable);
+  }, [tableDefinition, fixedFields]);
+  if (loading) {
+    return /* @__PURE__ */ jsxs4(Box4, { display: "flex", justifyContent: "center", alignItems: "center", minHeight: "200px", children: [
+      /* @__PURE__ */ jsx9(CircularProgress, {}),
+      /* @__PURE__ */ jsx9(Typography5, { variant: "h6", sx: { ml: 2 }, children: "Cargando tabla..." })
+    ] });
+  }
+  if (error) {
+    return /* @__PURE__ */ jsx9(Box4, { display: "flex", justifyContent: "center", alignItems: "center", minHeight: "200px", children: /* @__PURE__ */ jsx9(Alert, { severity: "error", children: error.message }) });
+  }
+  if (!tableDefinition) {
+    return /* @__PURE__ */ jsx9(Box4, { display: "flex", justifyContent: "center", alignItems: "center", minHeight: "200px", children: /* @__PURE__ */ jsx9(Alert, { severity: "warning", children: "No se pudo cargar la definici\xF3n de la tabla." }) });
+  }
+  return /* @__PURE__ */ jsxs4(Box4, { sx: { p: 0, display: "flex", flexDirection: "column", height: "100%", boxSizing: "border-box" }, children: [
+    /* @__PURE__ */ jsx9(Box4, { sx: { display: "flex", justifyContent: "space-between", alignItems: "center", px: 2, pt: 2, pb: 1 }, children: /* @__PURE__ */ jsx9(Typography5, { variant: "h4", gutterBottom: true, sx: { m: 0 }, children: cambiarGuionesBajosPorEspacios(tableDefinition.title || tableDefinition.name) }) }),
+    tableDefinition.allow?.insert && /* @__PURE__ */ jsx9(Box4, { sx: { display: "flex", px: 2 }, children: /* @__PURE__ */ jsx9(
+      Button2,
+      {
+        variant: "contained",
+        onClick: handleAddRow,
+        startIcon: /* @__PURE__ */ jsx9(AddIcon, {}),
+        children: "Nuevo Registro"
+      }
+    ) }),
+    /* @__PURE__ */ jsx9(Box4, { sx: { px: 2, pt: 2, pb: 1, fontSize: "0.9rem" }, children: filteredRows.length === tableData.length ? /* @__PURE__ */ jsxs4(Box4, { children: [
+      "mostrando ",
+      `${tableData.length} registros`
+    ] }) : /* @__PURE__ */ jsx9(Fragment, { children: /* @__PURE__ */ jsxs4(Box4, { children: [
+      "mostrando ",
+      `${filteredRows.length} registros filtrados`
+    ] }) }) }),
+    /* @__PURE__ */ jsxs4(
+      Box4,
+      {
+        sx: {
+          flexGrow: showNoRowsMessage ? 0 : 1,
+          height: showNoRowsMessage ? "150px" : "100%",
+          boxSizing: "border-box",
+          position: "relative",
+          overflowX: "auto",
+          overflowY: "auto",
+          px: 2,
+          pb: 2
+        },
+        children: [
+          /* @__PURE__ */ jsx9(
+            DataGrid,
+            {
+              ref: dataGridRef,
+              columns,
+              rows: filteredRows.map((row) => ({
+                ...row,
+                style: exitingRowIds.has(getPrimaryKeyValues(row, primaryKey)) ? { maxHeight: 0, opacity: 0, overflow: "hidden" } : { maxHeight: "35px", opacity: 1 }
+              })),
+              enableVirtualization: true,
+              rowKeyGetter: (row) => getPrimaryKeyValues(row, primaryKey),
+              onSelectedRowsChange: setSelectedRows,
+              onRowsChange: handleRowsChange,
+              selectedRows,
+              rowHeight: (row) => exitingRowIds.has(getPrimaryKeyValues(row, primaryKey)) ? 0 : 35,
+              style: { height: "100%", width: "100%", boxSizing: "border-box" },
+              headerRowHeight: 35,
+              topSummaryRows: isFilterRowVisible ? [{ id: "filterRow" }] : void 0,
+              summaryRowHeight: isFilterRowVisible ? 35 : 0,
+              onCellClick: handleCellClick
+            }
+          ),
+          showNoRowsMessage && /* @__PURE__ */ jsx9(
+            Box4,
+            {
+              sx: {
+                position: "absolute",
+                top: isFilterRowVisible ? "70px" : "36px",
+                left: (theme2) => theme2.spacing(2),
+                right: (theme2) => theme2.spacing(2),
+                bottom: (theme2) => theme2.spacing(2),
+                display: "flex",
+                justifyContent: "center",
+                alignItems: "center",
+                backgroundColor: "rgba(255, 255, 255, 0.9)",
+                color: (theme2) => theme2.palette.text.secondary,
+                border: (theme2) => `1px solid ${theme2.palette.divider}`,
+                borderRadius: "4px",
+                zIndex: 1
+              },
+              children: /* @__PURE__ */ jsx9(Typography5, { variant: "h6", children: "No hay filas para mostrar." })
+            }
+          )
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx9(
+      ConfirmDialog,
+      {
+        open: openConfirmDialog,
+        onClose: handleConfirmDelete,
+        title: "Confirmar Eliminaci\xF3n",
+        message: rowToDelete && rowToDelete[NEW_ROW_INDICATOR] ? `\xBFEst\xE1s seguro de que quieres eliminar esta nueva fila (ID: ${getPrimaryKeyValues(rowToDelete, primaryKey)}) localmente?` : rowToDelete ? `\xBFEst\xE1s seguro de que quieres eliminar la fila con ID: ${getPrimaryKeyValues(rowToDelete, primaryKey)} de la base de datos? Esta acci\xF3n es irreversible.` : "\xBFEst\xE1s seguro de que quieres eliminar este registro? Esta acci\xF3n es irreversible."
+      }
+    )
+  ] });
+};
+var GenericDataGrid_default = GenericDataGrid;
+
+// src/App.tsx
+import React11, { useEffect as useEffect7 } from "react";
+import { BrowserRouter, Routes, Route, useLocation as useLocation4, Navigate as Navigate2 } from "react-router-dom";
+
+// src/components/MainLayout.tsx
+import { useEffect as useEffect3 } from "react";
+import { Outlet } from "react-router-dom";
+import {
+  Box as Box7,
+  AppBar,
+  Toolbar,
+  Typography as Typography8,
+  Button as Button3,
+  Drawer,
+  CssBaseline,
+  IconButton as IconButton2,
+  useTheme as useTheme2,
+  useMediaQuery
+} from "@mui/material";
+
+// src/contexts/AppContext.tsx
+import { createContext as createContext2, useContext as useContext2, useState as useState5, useEffect as useEffect2, useCallback as useCallback5, useMemo as useMemo3 } from "react";
+import { useNavigate } from "react-router-dom";
+import { useSelector as useSelector2, useDispatch as useDispatch2 } from "react-redux";
+import { jsx as jsx10 } from "react/jsx-runtime";
+var AuthContext = createContext2(void 0);
+var useApp = () => {
+  const context = useContext2(AuthContext);
+  if (!context) {
+    throw new Error("useApp must be used within an AppProvider");
+  }
+  const clientContext = useSelector2((state) => state.clientContext);
+  return { ...context, clientContext };
+};
+var AppProvider = ({ children }) => {
+  console.log("AppProvider rendered/re-rendered");
+  const [isLoggedIn, setIsLoggedIn] = useState5(false);
+  const [showSessionExpiredMessage, setShowSessionExpiredMessage] = useState5(false);
+  const dispatch = useDispatch2();
+  const clientContext = useSelector2((state) => state.clientContext);
+  const navigate = useNavigate();
+  const checkSession = useCallback5(async () => {
+    try {
+      const response = await fetchApi("/keep-alive.json", { method: "GET" });
+      if (response.ok) {
+        setIsLoggedIn(true);
+        setShowSessionExpiredMessage(false);
+        if (clientContext.status === "idle" || clientContext.status === "failed") {
+          console.log("Client context needs loading/reloading, dispatching fetchClientContext thunk...");
+          try {
+            await dispatch(fetchClientContext()).unwrap();
+            console.log("Client context data loaded successfully by Redux.");
+          } catch (loadError) {
+            console.error("Error loading client context data during session check:", loadError);
+          }
+        }
+      } else {
+        setIsLoggedIn(false);
+        dispatch(clearClientContext());
+        if (!showSessionExpiredMessage && window.location.pathname !== "/login") {
+          setShowSessionExpiredMessage(true);
+        }
+      }
+    } catch (error) {
+      console.error("Error checking session:", error);
+      setIsLoggedIn(false);
+      dispatch(clearClientContext());
+      if (!showSessionExpiredMessage && window.location.pathname !== "/login") {
+        setShowSessionExpiredMessage(true);
+      }
+    }
+  }, [dispatch, clientContext.status, showSessionExpiredMessage]);
+  useEffect2(() => {
+    checkSession();
+    const intervalId = setInterval(checkSession, 15 * 1e3);
+    return () => {
+      clearInterval(intervalId);
+    };
+  }, [checkSession]);
+  const authContextValue = useMemo3(() => ({
+    isLoggedIn,
+    setIsLoggedIn,
+    checkSession,
+    showSessionExpiredMessage,
+    setShowSessionExpiredMessage
+  }), [
+    isLoggedIn,
+    setIsLoggedIn,
+    checkSession,
+    showSessionExpiredMessage,
+    setShowSessionExpiredMessage
+  ]);
+  return /* @__PURE__ */ jsx10(AuthContext.Provider, { value: authContextValue, children });
+};
+
+// src/components/MainLayout.tsx
+import LogoutIcon from "@mui/icons-material/Logout";
+import MenuIcon from "@mui/icons-material/Menu";
+import ChevronLeftIcon from "@mui/icons-material/ChevronLeft";
+
+// src/components/SideMenu.tsx
+import { List, ListItem, ListItemButton, ListItemIcon, ListItemText, Divider, Box as Box6, Typography as Typography7, Collapse } from "@mui/material";
+import ExpandLess from "@mui/icons-material/ExpandLess";
+import ExpandMore from "@mui/icons-material/ExpandMore";
+import TableChartIcon from "@mui/icons-material/TableChart";
+import FolderIcon from "@mui/icons-material/Folder";
+import DnsIcon from "@mui/icons-material/Dns";
+import HomeIcon from "@mui/icons-material/Home";
+import WarningAmberIcon3 from "@mui/icons-material/WarningAmber";
+import DesktopWindowsIcon from "@mui/icons-material/DesktopWindows";
+import UnfoldMoreIcon from "@mui/icons-material/UnfoldMore";
+import UnfoldLessIcon from "@mui/icons-material/UnfoldLess";
+import { useNavigate as useNavigate2, useLocation } from "react-router-dom";
+import { blue, orange, teal, red, grey } from "@mui/material/colors";
+
+// src/pages/WScreens.tsx
+import { Box as Box5, Typography as Typography6, Paper } from "@mui/material";
+import ConstructionIcon from "@mui/icons-material/Construction";
+import WarningAmberIcon2 from "@mui/icons-material/WarningAmber";
+import { jsx as jsx11, jsxs as jsxs5 } from "react/jsx-runtime";
+var MyCustomDashboard = ({ screenName }) => {
+  return /* @__PURE__ */ jsx11(Box5, { sx: { p: 4, display: "flex", flexDirection: "column", alignItems: "center", justifyContent: "center", height: "100%" }, children: /* @__PURE__ */ jsxs5(Paper, { elevation: 3, sx: { p: 4, textAlign: "center", maxWidth: 600 }, children: [
+    /* @__PURE__ */ jsxs5(Typography6, { variant: "h5", component: "h1", gutterBottom: true, children: [
+      "\xA1Bienvenido a tu WScreen: ",
+      screenName,
+      "!"
+    ] }),
+    /* @__PURE__ */ jsx11(Typography6, { variant: "body1", color: "text.secondary", children: "Esta es una pantalla de interfaz de usuario personalizada." }),
+    /* @__PURE__ */ jsx11(Box5, { sx: { mt: 3 }, children: /* @__PURE__ */ jsx11(ConstructionIcon, { sx: { fontSize: 80, color: "primary.main" } }) })
+  ] }) });
+};
+var FallbackWScreen = ({ screenName }) => {
+  return /* @__PURE__ */ jsx11(Box5, { sx: { p: 4, display: "flex", flexDirection: "column", alignItems: "center", justifyContent: "center", height: "100%" }, children: /* @__PURE__ */ jsxs5(Paper, { elevation: 3, sx: { p: 4, textAlign: "center", maxWidth: 600, backgroundColor: "warning.light", border: "1px solid orange" }, children: [
+    /* @__PURE__ */ jsx11(Typography6, { variant: "h5", component: "h1", gutterBottom: true, color: "warning.dark", children: "WScreen No Implementada" }),
+    /* @__PURE__ */ jsxs5(Typography6, { variant: "body1", color: "warning.dark", children: [
+      'No se encontr\xF3 un componente implementado para la **WScreen**: **`"$',
+      screenName,
+      '"`**. Por favor, verifica el `menuType` en la definici\xF3n del men\xFA o aseg\xFArate de que el componente est\xE9 correctamente importado y mapeado en el frontend.'
+    ] }),
+    /* @__PURE__ */ jsx11(Box5, { sx: { mt: 3 }, children: /* @__PURE__ */ jsx11(WarningAmberIcon2, { sx: { fontSize: 80, color: "warning.dark" } }) })
+  ] }) });
+};
+var wScreens = {
+  "MyCustomDashboard": MyCustomDashboard
+  // Agrega más componentes de wScreen aquí:
+  // 'AnotherWScreen': AnotherWScreenComponent,
+};
+var WScreens_default = FallbackWScreen;
+
+// src/components/SideMenu.tsx
+import { Fragment as Fragment2, jsx as jsx12, jsxs as jsxs6 } from "react/jsx-runtime";
+var MenuListItem = ({ item, level, onMenuItemClick }) => {
+  const navigate = useNavigate2();
+  const location = useLocation();
+  const open = useSubMenuOpenState(item.name);
+  const dispatch = useAppDispatch();
+  const handleClick = () => {
+    if (item.menuType === "menu") {
+      dispatch(toggleSubMenu(item.name));
+    } else {
+      let path = "";
+      const queryParams = new URLSearchParams();
+      if (item.menuType === "table") {
+        path = `/menu/${item.name}`;
+        if (item.td) queryParams.append("td", JSON.stringify(item.td));
+        if (item.fc) queryParams.append("fc", JSON.stringify(item.fc));
+        if (queryParams.toString()) {
+          path = `${path}?${queryParams.toString()}`;
+        }
+      } else if (item.menuType === "proc") {
+        path = `/procedures/${item.name}`;
+      } else {
+        const WScreenComponent = wScreens[item.menuType];
+        if (WScreenComponent !== void 0) {
+          path = `/wScreens/${item.menuType}`;
+        } else {
+          path = `/wScreens-fallback/${item.menuType}`;
+          console.warn(`Menu type '${item.menuType}' no reconocido o WScreen no mapeada.`);
+        }
+      }
+      if (path) {
+        navigate(path);
+      }
+      if (onMenuItemClick) {
+        onMenuItemClick();
+      }
+    }
+  };
+  const getIcon = (item2) => {
+    switch (item2.menuType) {
+      case "table":
+        return /* @__PURE__ */ jsx12(TableChartIcon, { sx: { color: blue[700] } });
+      case "proc":
+        return /* @__PURE__ */ jsx12(DnsIcon, { sx: { color: teal[700] } });
+      case "menu":
+        return /* @__PURE__ */ jsx12(FolderIcon, { sx: { color: orange[800] } });
+      default:
+        const WScreenComponent = wScreens[item2.menuType];
+        if (WScreenComponent !== void 0) {
+          return /* @__PURE__ */ jsx12(DesktopWindowsIcon, { sx: { color: grey[700] } });
+        }
+        return /* @__PURE__ */ jsx12(WarningAmberIcon3, { sx: { color: red[500] } });
+    }
+  };
+  const currentPath = location.pathname;
+  let isSelected = false;
+  if (item.menuType === "table") {
+    isSelected = currentPath === `/menu/table/${item.name}`;
+  } else if (item.menuType === "proc") {
+    isSelected = currentPath === `/procedures/${item.name}`;
+  } else {
+    isSelected = currentPath.startsWith(`/wScreens/${item.menuType}`) || currentPath.startsWith(`/wScreens-fallback/${item.menuType}`);
+  }
+  return /* @__PURE__ */ jsxs6(Fragment2, { children: [
+    /* @__PURE__ */ jsxs6(
+      ListItemButton,
+      {
+        onClick: handleClick,
+        sx: { pl: level * 2 },
+        selected: isSelected,
+        children: [
+          /* @__PURE__ */ jsx12(ListItemIcon, { sx: { minWidth: "38px" }, children: getIcon(item) }),
+          /* @__PURE__ */ jsx12(ListItemText, { primary: item.label || item.name }),
+          item.menuType === "menu" ? open ? /* @__PURE__ */ jsx12(ExpandLess, {}) : /* @__PURE__ */ jsx12(ExpandMore, {}) : null
+        ]
+      }
+    ),
+    item.menuType === "menu" && /* @__PURE__ */ jsx12(Collapse, { in: open, timeout: "auto", unmountOnExit: true, children: /* @__PURE__ */ jsx12(List, { component: "div", disablePadding: true, children: item.menuContent.map((subItem) => /* @__PURE__ */ jsx12(
+      MenuListItem,
+      {
+        item: subItem,
+        level: level + 1,
+        onMenuItemClick
+      },
+      subItem.name
+    )) }) })
+  ] });
+};
+var SideMenu = ({ onMenuItemClick }) => {
+  const { clientContext } = useApp();
+  const navigate = useNavigate2();
+  const location = useLocation();
+  const dispatch = useAppDispatch();
+  const subMenuOpenStates = useAppSelector((state) => state.menuUi.subMenuOpenStates);
+  const allSubMenusKeys = Object.keys(subMenuOpenStates);
+  const openSubMenusCount = allSubMenusKeys.filter((key) => subMenuOpenStates[key]).length;
+  const isMostlyOpen = allSubMenusKeys.length > 0 && openSubMenusCount / allSubMenusKeys.length > 0.5;
+  const handleHomeClick = () => {
+    navigate("/home");
+    if (onMenuItemClick) {
+      onMenuItemClick();
+    }
+  };
+  const handleToggleAllSubMenus = () => {
+    dispatch(setAllSubMenusOpen(!isMostlyOpen));
+  };
+  if (!clientContext || !clientContext.menu) {
+    return /* @__PURE__ */ jsx12(Box6, { sx: { p: 2, textAlign: "center" }, children: /* @__PURE__ */ jsx12(Typography7, { variant: "body2", color: "text.secondary", children: "Cargando men\xFA..." }) });
+  }
+  const isHomeSelected = location.pathname === "/home";
+  return /* @__PURE__ */ jsxs6(Box6, { sx: { width: "100%", flexShrink: 0 }, children: [
+    clientContext.menu.some((item) => item.menuType === "menu") && /* @__PURE__ */ jsx12(ListItem, { disablePadding: true, children: /* @__PURE__ */ jsxs6(ListItemButton, { onClick: handleToggleAllSubMenus, children: [
+      /* @__PURE__ */ jsx12(ListItemIcon, { sx: { minWidth: "38px" }, children: isMostlyOpen ? /* @__PURE__ */ jsx12(UnfoldLessIcon, {}) : /* @__PURE__ */ jsx12(UnfoldMoreIcon, {}) }),
+      /* @__PURE__ */ jsx12(ListItemText, { primary: isMostlyOpen ? "colapsar " : "expandir" })
+    ] }) }),
+    /* @__PURE__ */ jsx12(Divider, {}),
+    /* @__PURE__ */ jsxs6(List, { children: [
+      /* @__PURE__ */ jsx12(ListItem, { disablePadding: true, children: /* @__PURE__ */ jsxs6(ListItemButton, { onClick: handleHomeClick, selected: isHomeSelected, children: [
+        /* @__PURE__ */ jsx12(ListItemIcon, { sx: { minWidth: "38px" }, children: /* @__PURE__ */ jsx12(HomeIcon, {}) }),
+        /* @__PURE__ */ jsx12(ListItemText, { primary: "Inicio" })
+      ] }) }),
+      /* @__PURE__ */ jsx12(Divider, {}),
+      clientContext.menu.map((menuItem) => /* @__PURE__ */ jsx12(
+        MenuListItem,
+        {
+          item: menuItem,
+          level: 1,
+          onMenuItemClick
+        },
+        menuItem.name
+      ))
+    ] })
+  ] });
+};
+var SideMenu_default = SideMenu;
+
+// src/hooks/useLogout.tsx
+import { useCallback as useCallback6 } from "react";
+import { useNavigate as useNavigate3 } from "react-router-dom";
+import { useDispatch as useDispatch3 } from "react-redux";
+var useLogout = () => {
+  const { setIsLoggedIn } = useApp();
+  const dispatch = useDispatch3();
+  const navigate = useNavigate3();
+  const logout = useCallback6(async () => {
+    try {
+      const response = await fetchApi("/logout", { method: "GET" });
+      if (response.status === 401 || response.ok) {
+        console.log("Sesi\xF3n cerrada correctamente o ya deslogueado");
+      } else {
+        console.error("Error al cerrar sesi\xF3n:", await response.text());
+      }
+    } catch (error) {
+      console.error("Error de red al intentar cerrar sesi\xF3n:", error);
+    } finally {
+      setIsLoggedIn(false);
+      dispatch(clearClientContext());
+      navigate("/login", { replace: true });
+    }
+  }, [setIsLoggedIn, dispatch, navigate]);
+  return logout;
+};
+var useLogout_default = useLogout;
+
+// src/components/MainLayout.tsx
+import { jsx as jsx13, jsxs as jsxs7 } from "react/jsx-runtime";
+var drawerWidth = 240;
+var MainLayout = () => {
+  const { clientContext } = useApp();
+  const logout = useLogout_default();
+  const isDrawerOpen = useIsDrawerOpen();
+  const dispatch = useAppDispatch();
+  const theme = useTheme2();
+  const isMobile = useMediaQuery(theme.breakpoints.down("sm"));
+  useEffect3(() => {
+    if (isMobile && isDrawerOpen) {
+      dispatch(setDrawerOpen(false));
+    }
+  }, [isMobile, isDrawerOpen, dispatch]);
+  const handleToggleDrawer = () => {
+    dispatch(toggleDrawer());
+  };
+  const handleDrawerCloseMobile = () => {
+    if (isMobile && isDrawerOpen) {
+      dispatch(setDrawerOpen(false));
+    }
+  };
+  if (!clientContext) {
+    return /* @__PURE__ */ jsx13(Box7, { sx: { display: "flex", justifyContent: "center", alignItems: "center", height: "100vh" }, children: /* @__PURE__ */ jsx13(Typography8, { children: "Cargando dise\xF1o de la aplicaci\xF3n..." }) });
+  }
+  const appBarOffset = theme.mixins.toolbar;
+  return /* @__PURE__ */ jsxs7(Box7, { sx: { display: "flex", height: "100vh" }, children: [
+    /* @__PURE__ */ jsx13(CssBaseline, {}),
+    /* @__PURE__ */ jsx13(
+      AppBar,
+      {
+        position: "fixed",
+        sx: {
+          zIndex: (theme2) => theme2.zIndex.drawer + 1,
+          transition: (theme2) => theme2.transitions.create(["width", "margin"], {
+            easing: theme2.transitions.easing.sharp,
+            duration: theme2.transitions.duration.leavingScreen
+          }),
+          ...isDrawerOpen && {
+            width: `calc(100% - ${drawerWidth}px)`,
+            marginLeft: `${drawerWidth}px`,
+            transition: (theme2) => theme2.transitions.create(["width", "margin"], {
+              easing: theme2.transitions.easing.easeOut,
+              duration: theme2.transitions.duration.enteringScreen
+            })
+          }
+        },
+        children: /* @__PURE__ */ jsxs7(Toolbar, { children: [
+          /* @__PURE__ */ jsx13(
+            IconButton2,
+            {
+              color: "inherit",
+              "aria-label": "open drawer",
+              onClick: handleToggleDrawer,
+              edge: "start",
+              sx: {
+                marginRight: 2.2
+              },
+              children: isDrawerOpen ? /* @__PURE__ */ jsx13(ChevronLeftIcon, {}) : /* @__PURE__ */ jsx13(MenuIcon, {})
+            }
+          ),
+          /* @__PURE__ */ jsx13(Typography8, { variant: "h6", noWrap: true, component: "div", sx: { flexGrow: 1 }, children: isDrawerOpen ? "" : clientContext.config.title }),
+          /* @__PURE__ */ jsx13(Typography8, { variant: "subtitle1", component: "div", sx: { mr: 2 }, children: clientContext.username }),
+          /* @__PURE__ */ jsx13(
+            Button3,
+            {
+              color: "inherit",
+              onClick: logout,
+              startIcon: /* @__PURE__ */ jsx13(LogoutIcon, {}),
+              children: "Salir"
+            }
+          )
+        ] })
+      }
+    ),
+    /* @__PURE__ */ jsxs7(
+      Drawer,
+      {
+        variant: "persistent",
+        anchor: "left",
+        open: isDrawerOpen,
+        sx: {
+          width: drawerWidth,
+          flexShrink: 0,
+          "& .MuiDrawer-paper": {
+            width: drawerWidth,
+            boxSizing: "border-box",
+            overflowX: "hidden",
+            overflowY: "auto"
+          }
+        },
+        children: [
+          /* @__PURE__ */ jsx13(
+            Toolbar,
+            {
+              sx: {
+                display: "flex",
+                alignItems: "center",
+                justifyContent: "flex-end",
+                px: 1,
+                fontSize: "1.3rem",
+                minHeight: theme.mixins.toolbar.minHeight
+              },
+              children: isDrawerOpen ? clientContext.config.title : ""
+            }
+          ),
+          /* @__PURE__ */ jsx13(SideMenu_default, { onMenuItemClick: handleDrawerCloseMobile })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx13(
+      Box7,
+      {
+        component: "main",
+        sx: {
+          flexGrow: 1,
+          transition: (theme2) => theme2.transitions.create("margin", {
+            easing: theme2.transitions.easing.sharp,
+            duration: theme2.transitions.duration.leavingScreen
+          }),
+          marginLeft: `-${drawerWidth}px`,
+          ...isDrawerOpen && {
+            transition: (theme2) => theme2.transitions.create("margin", {
+              easing: theme2.transitions.easing.easeOut,
+              duration: theme2.transitions.duration.enteringScreen
+            }),
+            marginLeft: 0
+          },
+          minWidth: 0,
+          flexShrink: 0,
+          // Asegúrate de que el paddingTop sea suficiente para la AppBar
+          paddingTop: `${appBarOffset.minHeight}px`,
+          height: "100%",
+          boxSizing: "border-box",
+          display: "flex",
+          flexDirection: "column",
+          width: isDrawerOpen ? `calc(100% - ${drawerWidth}px)` : "100%"
+        },
+        children: /* @__PURE__ */ jsx13(Outlet, {})
+      }
+    )
+  ] });
+};
+var MainLayout_default = MainLayout;
+
+// src/components/SessionExpiredMessage.tsx
+import { Box as Box8, Typography as Typography9, Button as Button4, Modal } from "@mui/material";
+import { useNavigate as useNavigate4 } from "react-router-dom";
+import { jsx as jsx14, jsxs as jsxs8 } from "react/jsx-runtime";
+var style = {
+  position: "absolute",
+  top: "50%",
+  left: "50%",
+  transform: "translate(-50%, -50%)",
+  width: 400,
+  bgcolor: "background.paper",
+  border: "2px solid #000",
+  boxShadow: 24,
+  p: 4,
+  textAlign: "center",
+  borderRadius: 2
+};
+var SessionExpiredMessage = () => {
+  const { showSessionExpiredMessage, setShowSessionExpiredMessage, setIsLoggedIn } = useApp();
+  const navigate = useNavigate4();
+  const handleClose = () => {
+    setShowSessionExpiredMessage(false);
+    setIsLoggedIn(false);
+    navigate("/login", { replace: true });
+  };
+  return /* @__PURE__ */ jsx14(
+    Modal,
+    {
+      open: showSessionExpiredMessage,
+      onClose: () => {
+      },
+      "aria-labelledby": "session-expired-modal-title",
+      "aria-describedby": "session-expired-modal-description",
+      disableEscapeKeyDown: true,
+      slotProps: {
+        backdrop: {
+          // Esto es crucial en MUI v5: detiene la propagación del evento de clic en el backdrop,
+          // impidiendo que el modal se cierre al hacer clic fuera.
+          onClick: (event) => event.stopPropagation(),
+          sx: {
+            backgroundColor: "rgba(100, 100, 100, 0.95)"
+            // Ajusta el color y la opacidad para un fondo más oscuro
+          }
+        }
+      },
+      children: /* @__PURE__ */ jsxs8(Box8, { sx: style, children: [
+        /* @__PURE__ */ jsx14(Typography9, { id: "session-expired-modal-title", variant: "h6", component: "h2", gutterBottom: true, children: "\xA1Sesi\xF3n Expirada!" }),
+        /* @__PURE__ */ jsx14(Typography9, { id: "session-expired-modal-description", sx: { mt: 2, mb: 3 }, children: "Tu sesi\xF3n ha expirado por inactividad o por seguridad. Por favor, inicia sesi\xF3n de nuevo." }),
+        /* @__PURE__ */ jsx14(Button4, { variant: "contained", color: "primary", onClick: handleClose, children: "Ir al Login" })
+      ] })
+    }
+  );
+};
+var SessionExpiredMessage_default = SessionExpiredMessage;
+
+// src/pages/HomePage.tsx
+import { Box as Box9, Typography as Typography10 } from "@mui/material";
+import { jsx as jsx15, jsxs as jsxs9 } from "react/jsx-runtime";
+var HomePage = () => {
+  const { clientContext } = useApp();
+  return /* @__PURE__ */ jsxs9(Box9, { sx: { p: 3 }, children: [
+    /* @__PURE__ */ jsx15(Typography10, { variant: "h4", component: "h1", gutterBottom: true, children: `Bienvenido/a ${clientContext?.username}` }),
+    /* @__PURE__ */ jsx15(Typography10, { variant: "body1", children: "Usa el men\xFA lateral para navegar por las diferentes secciones." })
+  ] });
+};
+var HomePage_default = HomePage;
+
+// src/pages/LogoutPage.tsx
+import { useEffect as useEffect4 } from "react";
+import { Box as Box10, Typography as Typography11, CircularProgress as CircularProgress2 } from "@mui/material";
+import { jsx as jsx16, jsxs as jsxs10 } from "react/jsx-runtime";
+var LogoutPage = () => {
+  const logout = useLogout_default();
+  useEffect4(() => {
+    logout();
+  }, [logout]);
+  return /* @__PURE__ */ jsxs10(Box10, { sx: {
+    display: "flex",
+    flexDirection: "column",
+    justifyContent: "center",
+    alignItems: "center",
+    height: "100vh",
+    textAlign: "center"
+  }, children: [
+    /* @__PURE__ */ jsx16(CircularProgress2, { size: 60 }),
+    /* @__PURE__ */ jsx16(Typography11, { variant: "h6", sx: { mt: 2 }, children: "Cerrando sesi\xF3n..." })
+  ] });
+};
+var LogoutPage_default = LogoutPage;
+
+// src/pages/LoginPage.tsx
+import { useState as useState6 } from "react";
+import { Button as Button5, TextField, Typography as Typography12, Alert as Alert2, AlertTitle, Box as Box11, CircularProgress as CircularProgress3 } from "@mui/material";
+import { useForm, Controller } from "react-hook-form";
+import { zodResolver } from "@hookform/resolvers/zod";
+import * as z from "zod";
+import { useNavigate as useNavigate5 } from "react-router-dom";
+import { useDispatch as useDispatch4 } from "react-redux";
+import { Fragment as Fragment3, jsx as jsx17, jsxs as jsxs11 } from "react/jsx-runtime";
+var loginSchema = z.object({
+  username: z.string().min(1, "El usuario es requerido"),
+  // Añadir validación básica
+  password: z.string().min(1, "La contrase\xF1a es requerida")
+  // Añadir validación básica
+});
+var LoginPage = () => {
+  const navigate = useNavigate5();
+  const [loginError, setLoginError] = useState6(null);
+  const [isSubmitting, setIsSubmitting] = useState6(false);
+  const { setIsLoggedIn, checkSession } = useApp();
+  const dispatch = useDispatch4();
+  const {
+    control,
+    handleSubmit,
+    formState: { errors },
+    reset
+  } = useForm({
+    resolver: zodResolver(loginSchema),
+    defaultValues: {
+      username: "",
+      password: ""
+    }
+  });
+  const onSubmit = async (data) => {
+    setIsSubmitting(true);
+    setLoginError(null);
+    try {
+      const body = new URLSearchParams({
+        username: data.username,
+        password: data.password
+      });
+      const loginResponse = await fetchApi("/login", {
+        method: "POST",
+        body
+        // URLSearchParams se envía directamente como body para form-urlencoded
+        // Asegúrate de que el Content-Type en el backend maneje 'application/x-www-form-urlencoded'
+      });
+      if (!loginResponse.ok || !loginResponse.url.endsWith("/menu")) {
+        const errorText = "Credenciales incorrectas o error al iniciar sesi\xF3n";
+        throw new Error(errorText);
+      }
+      setIsLoggedIn(true);
+      await dispatch(fetchClientContext()).unwrap();
+      console.log("Login exitoso y clientContext cargado.");
+      navigate("/home");
+      reset();
+    } catch (error) {
+      console.error("Error al iniciar sesi\xF3n:", error);
+      setIsLoggedIn(false);
+      setLoginError(error.message || "Ocurri\xF3 un error al iniciar sesi\xF3n. Int\xE9ntalo de nuevo.");
+    } finally {
+      setIsSubmitting(false);
+    }
+  };
+  return /* @__PURE__ */ jsx17(
+    Box11,
+    {
+      display: "flex",
+      alignItems: "center",
+      justifyContent: "center",
+      minHeight: "100vh",
+      bgcolor: "#f5f5f5",
+      children: /* @__PURE__ */ jsxs11(
+        Box11,
+        {
+          width: "100%",
+          maxWidth: "400px",
+          padding: 4,
+          bgcolor: "white",
+          borderRadius: 8,
+          boxShadow: 3,
+          children: [
+            /* @__PURE__ */ jsx17(Typography12, { variant: "h5", align: "center", gutterBottom: true, children: "Iniciar Sesi\xF3n" }),
+            /* @__PURE__ */ jsxs11("form", { onSubmit: handleSubmit(onSubmit), className: "space-y-4", children: [
+              /* @__PURE__ */ jsxs11("div", { children: [
+                /* @__PURE__ */ jsx17("label", { htmlFor: "username", children: /* @__PURE__ */ jsx17(Typography12, { variant: "subtitle1", component: "div", sx: { fontWeight: "medium" }, children: "Usuario" }) }),
+                /* @__PURE__ */ jsx17(
+                  Controller,
+                  {
+                    name: "username",
+                    control,
+                    render: ({ field }) => /* @__PURE__ */ jsx17(
+                      TextField,
+                      {
+                        ...field,
+                        type: "text",
+                        placeholder: "Ingresa tu usuario",
+                        fullWidth: true,
+                        margin: "normal",
+                        error: !!errors.username,
+                        helperText: errors.username?.message,
+                        disabled: isSubmitting
+                      }
+                    )
+                  }
+                )
+              ] }),
+              /* @__PURE__ */ jsxs11("div", { children: [
+                /* @__PURE__ */ jsx17("label", { htmlFor: "password", children: /* @__PURE__ */ jsx17(Typography12, { variant: "subtitle1", component: "div", sx: { fontWeight: "medium" }, children: "Contrase\xF1a" }) }),
+                /* @__PURE__ */ jsx17(
+                  Controller,
+                  {
+                    name: "password",
+                    control,
+                    render: ({ field }) => /* @__PURE__ */ jsx17(
+                      TextField,
+                      {
+                        ...field,
+                        type: "password",
+                        placeholder: "Ingresa tu contrase\xF1a",
+                        fullWidth: true,
+                        margin: "normal",
+                        error: !!errors.password,
+                        helperText: errors.password?.message,
+                        disabled: isSubmitting
+                      }
+                    )
+                  }
+                )
+              ] }),
+              /* @__PURE__ */ jsx17(Button5, { type: "submit", fullWidth: true, variant: "contained", color: "primary", disabled: isSubmitting, sx: { mt: 2 }, children: isSubmitting ? /* @__PURE__ */ jsxs11(Fragment3, { children: [
+                /* @__PURE__ */ jsx17(CircularProgress3, { size: 20, sx: { mr: 1 } }),
+                "Iniciando sesi\xF3n..."
+              ] }) : "Iniciar Sesi\xF3n" })
+            ] }),
+            loginError && /* @__PURE__ */ jsxs11(Alert2, { severity: "error", sx: { mt: 2, maxHeight: "200px" }, children: [
+              " ",
+              /* @__PURE__ */ jsx17(AlertTitle, { children: "Error" }),
+              loginError
+            ] })
+          ]
+        }
+      )
+    }
+  );
+};
+var LoginPage_default = LoginPage;
+
+// src/components/ProcedureForm.tsx
+import React7, { useState as useState7, useCallback as useCallback7, useMemo as useMemo4 } from "react";
+import { useParams } from "react-router-dom";
+import {
+  TextField as TextField2,
+  Button as Button6,
+  FormControl,
+  InputLabel,
+  Select,
+  MenuItem,
+  Checkbox,
+  FormControlLabel,
+  FormHelperText,
+  Typography as Typography14,
+  Box as Box13,
+  CircularProgress as CircularProgress4,
+  Alert as Alert3,
+  Divider as Divider2,
+  Paper as Paper3
+} from "@mui/material";
+
+// src/pages/procedure-results/SuccessDisplay.tsx
+import { Box as Box12, Typography as Typography13, Paper as Paper2 } from "@mui/material";
+import { jsx as jsx18, jsxs as jsxs12 } from "react/jsx-runtime";
+var SuccessDisplay = ({ data }) => {
+  return /* @__PURE__ */ jsxs12(Paper2, { elevation: 2, sx: { p: 2, mt: 2, bgcolor: "success.light", color: "success.contrastText" }, children: [
+    /* @__PURE__ */ jsx18(Typography13, { variant: "h6", sx: { fontSize: "1rem", mb: 1 }, children: "\xA1Operaci\xF3n Exitosa!" }),
+    /* @__PURE__ */ jsx18(Typography13, { variant: "body2", sx: { fontSize: "0.85rem" }, children: "Detalles del resultado:" }),
+    /* @__PURE__ */ jsx18(Box12, { sx: { bgcolor: "success.dark", p: 1, borderRadius: 1, mt: 1, overflowX: "auto" }, children: /* @__PURE__ */ jsx18("pre", { style: { margin: 0, fontSize: "0.75rem", color: "white" }, children: JSON.stringify(data, null, 2) }) }),
+    /* @__PURE__ */ jsx18(Typography13, { variant: "body2", sx: { fontSize: "0.8rem", mt: 1 }, children: "Puedes revisar los detalles anteriores o cerrar este mensaje." })
+  ] });
+};
+var SuccessDisplay_default = SuccessDisplay;
+
+// src/pages/procedure-results/resultsOk.ts
+var resultsOk = {
+  "successful_operation": SuccessDisplay_default
+};
+var extendResultsOk = (newComponents) => {
+  resultsOk = { ...resultsOk, ...newComponents };
+};
+
+// src/components/ProcedureForm.tsx
+import { jsx as jsx19, jsxs as jsxs13 } from "react/jsx-runtime";
+var ProcedureForm = () => {
+  const { procedureName } = useParams();
+  const { clientContext } = useApp();
+  const { callApi, loading: apiLoading, error: apiError } = useApiCall();
+  const [validationErrors, setValidationErrors] = useState7({});
+  const [successMessage, setSuccessMessage] = useState7(null);
+  const [executionLog, setExecutionLog] = useState7([]);
+  const [procedureResultData, setProcedureResultData] = useState7(null);
+  const procedure = useMemo4(() => {
+    if (procedureName && clientContext?.procedure) {
+      return clientContext.procedure[procedureName];
+    }
+    return void 0;
+  }, [procedureName, clientContext]);
+  const [formValues, setFormValues] = useState7(() => {
+    if (!procedure) return {};
+    const initialValues = {};
+    procedure.parameters.forEach((param) => {
+      if (param.defaultValue !== void 0) {
+        initialValues[param.name] = param.defaultValue;
+      } else if (param.specialDefaultValue) {
+        switch (param.specialDefaultValue) {
+          case "current_date":
+            initialValues[param.name] = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+            break;
+          case "current_datetime":
+            const now = /* @__PURE__ */ new Date();
+            initialValues[param.name] = now.toISOString().substring(0, 16);
+            break;
+          default:
+            initialValues[param.name] = param.specialDefaultValue;
+            break;
+        }
+      } else {
+        initialValues[param.name] = "";
+      }
+    });
+    return initialValues;
+  });
+  React7.useEffect(() => {
+    if (procedure) {
+      setValidationErrors({});
+      setSuccessMessage(null);
+      setProcedureResultData(null);
+      const newInitialValues = {};
+      procedure.parameters.forEach((param) => {
+        if (param.defaultValue !== void 0) {
+          newInitialValues[param.name] = param.defaultValue;
+        } else if (param.specialDefaultValue) {
+          switch (param.specialDefaultValue) {
+            case "current_date":
+              newInitialValues[param.name] = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+              break;
+            case "current_datetime":
+              const now = /* @__PURE__ */ new Date();
+              newInitialValues[param.name] = now.toISOString().substring(0, 16);
+              break;
+            default:
+              newInitialValues[param.name] = param.specialDefaultValue;
+              break;
+          }
+        } else {
+          newInitialValues[param.name] = "";
+        }
+      });
+      setFormValues(newInitialValues);
+      setExecutionLog([]);
+    }
+  }, [procedure]);
+  const addLogMessage = useCallback7((message, isError = false) => {
+    const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString("es-AR");
+    setExecutionLog((prev) => [...prev, `[${timestamp}] ${isError ? "ERROR: " : ""}${message}`]);
+  }, []);
+  const handleChange = useCallback7((e, child) => {
+    const { name, value } = e.target;
+    let newValue = value;
+    if (e.target.type === "checkbox") {
+      newValue = e.target.checked;
+    }
+    setFormValues((prevValues) => ({
+      ...prevValues,
+      [name]: newValue
+    }));
+    setValidationErrors((prev) => ({ ...prev, [name]: null }));
+    setSuccessMessage(null);
+    setProcedureResultData(null);
+  }, []);
+  const handleSubmit = async (e) => {
+    e.preventDefault();
+    setValidationErrors({});
+    setSuccessMessage(null);
+    setExecutionLog([]);
+    setProcedureResultData(null);
+    if (!procedure) {
+      addLogMessage("Error: La definici\xF3n del procedimiento no est\xE1 disponible.", true);
+      return;
+    }
+    addLogMessage(`Iniciando ejecuci\xF3n del procedimiento: ${procedure.action}...`);
+    const paramsToSend = {};
+    let currentValidationErrors = {};
+    let hasOverallError = false;
+    for (const param of procedure.parameters) {
+      let value = formValues[param.name];
+      let processedValue = value;
+      let paramError = null;
+      switch (param.typeName) {
+        case "decimal":
+        case "double":
+          if (value === "" || value === null) {
+            processedValue = null;
+          } else {
+            processedValue = parseFloat(value);
+            if (isNaN(processedValue)) {
+              paramError = `El valor para "${param.label || param.name}" no es un n\xFAmero v\xE1lido.`;
+            }
+          }
+          break;
+        case "integer":
+        case "bigint":
+          if (value === "" || value === null) {
+            processedValue = null;
+          } else {
+            processedValue = parseInt(value, 10);
+            if (isNaN(processedValue)) {
+              paramError = `El valor para "${param.label || param.name}" no es un entero v\xE1lido.`;
+            }
+          }
+          break;
+        case "boolean":
+          processedValue = !!value;
+          break;
+        case "jsonb":
+        case "jsona":
+          if (value === "" || value === null) {
+            processedValue = null;
+          } else {
+            try {
+              processedValue = JSON.parse(value);
+            } catch (jsonError) {
+              paramError = `Error en el formato JSON para "${param.label || param.name}": ${jsonError.message}`;
+            }
+          }
+          break;
+        case "bytea":
+          processedValue = value instanceof File ? value : value === "" ? null : value;
+          break;
+        case "text":
+        case "date":
+        case "timestamp":
+        case "time":
+        case "interval":
+        case "tsrange":
+        case "time_range":
+        case "daterange":
+        default:
+          processedValue = value === "" ? null : value;
+          break;
+      }
+      const hasDefaultValue = param.defaultValue !== void 0 || param.specialDefaultValue !== void 0;
+      const isEmpty = processedValue === null || processedValue === void 0 || typeof processedValue === "string" && processedValue.trim() === "";
+      if (!hasDefaultValue && isEmpty) {
+        paramError = `El campo "${param.label || param.name}" es obligatorio y no puede estar vac\xEDo.`;
+      }
+      if (paramError) {
+        currentValidationErrors[param.name] = paramError;
+        hasOverallError = true;
+        addLogMessage(`Error de validaci\xF3n para "${param.label || param.name}": ${paramError}`, true);
+      }
+      paramsToSend[param.name] = processedValue;
+    }
+    if (hasOverallError) {
+      setValidationErrors(currentValidationErrors);
+      addLogMessage("No se puede ejecutar el procedimiento debido a errores de validaci\xF3n en el formulario.", true);
+      return;
+    }
+    addLogMessage(`Par\xE1metros a enviar: ${JSON.stringify(paramsToSend, null, 2)}`);
+    try {
+      addLogMessage("Invocando procedimiento a trav\xE9s de useApiCall...");
+      const result = await callApi(procedure.action, paramsToSend);
+      if (result !== void 0) {
+        setSuccessMessage(procedure.resultOk || "Procedimiento ejecutado con \xE9xito.");
+        addLogMessage("Procedimiento ejecutado con \xE9xito.");
+        addLogMessage(`Resultado: ${JSON.stringify(result, null, 2)}`);
+        setProcedureResultData(result);
+        console.log("Resultado del procedimiento:", result);
+      } else {
+        addLogMessage("Procedimiento finalizado con errores.", true);
+      }
+    } catch (err) {
+      console.error("Error al ejecutar el procedimiento (capturado en ProcedureForm):", err);
+      addLogMessage(`Error en la ejecuci\xF3n: ${err.message || "Error desconocido."}`, true);
+    } finally {
+      addLogMessage("Ejecuci\xF3n finalizada.");
+    }
+  };
+  const renderInputField = useCallback7((param) => {
+    const hasError = !!validationErrors[param.name];
+    const errorMessage = validationErrors[param.name];
+    const commonProps = {
+      id: param.name,
+      name: param.name,
+      label: param.label || param.name,
+      variant: "outlined",
+      fullWidth: true,
+      margin: "dense",
+      required: !(param.defaultValue !== void 0 || param.specialDefaultValue !== void 0),
+      size: "small",
+      helperText: errorMessage || param.description,
+      error: hasError,
+      disabled: apiLoading,
+      onChange: handleChange,
+      sx: { fontSize: "0.8rem" }
+    };
+    if (param.options && param.options.length > 0) {
+      return /* @__PURE__ */ jsxs13(FormControl, { fullWidth: true, margin: "dense", size: "small", error: hasError, required: commonProps.required, children: [
+        /* @__PURE__ */ jsx19(InputLabel, { id: `${param.name}-label`, sx: { fontSize: "0.8rem" }, children: param.label || param.name }),
+        /* @__PURE__ */ jsxs13(
+          Select,
+          {
+            labelId: `${param.name}-label`,
+            value: formValues[param.name] === void 0 ? "" : formValues[param.name],
+            onChange: handleChange,
+            name: param.name,
+            id: param.name,
+            label: param.label || param.name,
+            disabled: apiLoading,
+            sx: { fontSize: "0.8rem" },
+            renderValue: (selected) => /* @__PURE__ */ jsx19(Typography14, { sx: { fontSize: "0.8rem" }, children: selected }),
+            children: [
+              (!commonProps.required || formValues[param.name] === "") && /* @__PURE__ */ jsx19(MenuItem, { value: "", sx: { fontSize: "0.8rem" }, children: /* @__PURE__ */ jsx19("em", { children: "Seleccione..." }) }),
+              param.options.map((option) => /* @__PURE__ */ jsx19(MenuItem, { value: option, sx: { fontSize: "0.8rem" }, children: option }, option))
+            ]
+          }
+        ),
+        (param.description || errorMessage) && /* @__PURE__ */ jsx19(FormHelperText, { sx: { fontSize: "0.7rem" }, children: errorMessage || param.description })
+      ] });
+    }
+    switch (param.typeName) {
+      case "text":
+      case "interval":
+      case "tsrange":
+      case "time_range":
+      case "daterange":
+        return /* @__PURE__ */ jsx19(TextField2, { type: "text", value: formValues[param.name] || "", ...commonProps });
+      case "decimal":
+      case "double":
+        return /* @__PURE__ */ jsx19(TextField2, { type: "number", inputProps: { step: "any", style: { fontSize: "0.8rem" } }, value: formValues[param.name] || "", ...commonProps });
+      case "integer":
+      case "bigint":
+        return /* @__PURE__ */ jsx19(TextField2, { type: "number", inputProps: { step: "1", style: { fontSize: "0.8rem" } }, value: formValues[param.name] || "", ...commonProps });
+      case "boolean":
+        return /* @__PURE__ */ jsx19(
+          FormControlLabel,
+          {
+            control: /* @__PURE__ */ jsx19(
+              Checkbox,
+              {
+                checked: !!formValues[param.name],
+                onChange: handleChange,
+                name: param.name,
+                id: param.name,
+                disabled: apiLoading,
+                size: "small"
+              }
+            ),
+            label: /* @__PURE__ */ jsx19(Typography14, { sx: { fontSize: "0.8rem", color: hasError ? "error.main" : "inherit" }, children: param.label || param.name }),
+            sx: { mt: 1, mb: 0 }
+          }
+        );
+      case "date":
+      case "timestamp":
+      case "time":
+        return /* @__PURE__ */ jsx19(TextField2, { type: param.typeName === "date" ? "date" : param.typeName === "timestamp" ? "datetime-local" : "time", value: formValues[param.name] || "", ...commonProps, InputLabelProps: { shrink: true, sx: { fontSize: "0.8rem" } } });
+      case "jsonb":
+      case "jsona":
+        return /* @__PURE__ */ jsx19(TextField2, { multiline: true, rows: 5, value: formValues[param.name] || "", ...commonProps, InputProps: { sx: { fontSize: "0.8rem" } } });
+      case "bytea":
+        return /* @__PURE__ */ jsxs13(FormControl, { fullWidth: true, margin: "dense", error: hasError, required: commonProps.required, children: [
+          /* @__PURE__ */ jsx19(Typography14, { variant: "body2", color: "textSecondary", component: "label", htmlFor: param.name, sx: { fontSize: "0.8rem", color: hasError ? "error.main" : "text.secondary" }, children: param.label || param.name }),
+          /* @__PURE__ */ jsx19(
+            "input",
+            {
+              type: "file",
+              id: param.name,
+              name: param.name,
+              onChange: (e) => {
+                const files = e.target.files;
+                setFormValues((prev) => ({ ...prev, [param.name]: files && files.length > 0 ? files[0] : void 0 }));
+              },
+              disabled: apiLoading,
+              style: { padding: "6px 0", fontSize: "0.8rem" }
+            }
+          ),
+          (param.description || errorMessage) && /* @__PURE__ */ jsx19(FormHelperText, { sx: { fontSize: "0.7rem" }, children: errorMessage || param.description })
+        ] });
+      default:
+        return /* @__PURE__ */ jsx19(TextField2, { type: "text", value: formValues[param.name] || "", ...commonProps });
+    }
+  }, [formValues, handleChange, apiLoading, validationErrors]);
+  const ResultDisplayContent = useMemo4(() => {
+    if (!procedureResultData || !procedure?.resultOk) return null;
+    const ComponentToRender = resultsOk[procedure.resultOk];
+    if (ComponentToRender) {
+      return /* @__PURE__ */ jsx19(ComponentToRender, { data: procedureResultData });
+    } else {
+      return /* @__PURE__ */ jsxs13(Paper3, { elevation: 2, sx: { p: 2, mt: 0, bgcolor: "warning.light" }, children: [
+        /* @__PURE__ */ jsxs13(Typography14, { variant: "h6", sx: { fontSize: "1rem", mb: 1 }, children: [
+          "el componente para resolver el resultOk: '",
+          procedure.resultOk,
+          "' definido en el procedure no existe o no est\xE1 mapeado."
+        ] }),
+        /* @__PURE__ */ jsx19(Box13, { sx: {
+          bgcolor: "warning.dark",
+          p: 1,
+          borderRadius: 1
+        }, children: /* @__PURE__ */ jsx19("pre", { style: { margin: 0, fontSize: "0.75rem", color: "white" }, children: JSON.stringify(procedureResultData, null, 2) }) })
+      ] });
+    }
+  }, [procedureResultData, procedure]);
+  if (!procedure) {
+    return /* @__PURE__ */ jsxs13(Box13, { sx: {
+      p: 2,
+      width: "100%",
+      boxSizing: "border-box",
+      mt: 0,
+      bgcolor: "background.paper",
+      borderRadius: 2,
+      boxShadow: 3,
+      textAlign: "center"
+    }, children: [
+      /* @__PURE__ */ jsx19(CircularProgress4, { sx: { mb: 2 } }),
+      /* @__PURE__ */ jsx19(Typography14, { variant: "h6", color: "text.secondary", children: "Cargando procedimiento o no encontrado..." })
+    ] });
+  }
+  return (
+    // Esta es la Box más externa que ahora controlará el scroll
+    /* @__PURE__ */ jsxs13(Box13, { sx: {
+      p: 2,
+      ml: 1,
+      mt: 2,
+      mr: 1,
+      boxSizing: "border-box",
+      bgcolor: "background.paper",
+      borderRadius: 2,
+      boxShadow: 3,
+      fontSize: "0.8rem",
+      maxHeight: "calc(100vh - 100px)",
+      // Ajusta esta altura máxima según el espacio disponible en tu layout
+      overflowY: "auto",
+      // Habilita el scroll vertical para todo el contenido de esta Box
+      overflowX: "hidden"
+      // Oculta el scroll horizontal si no es necesario para el contenedor principal
+    }, children: [
+      /* @__PURE__ */ jsx19(Typography14, { variant: "h5", component: "h2", gutterBottom: true, align: "left", children: cambiarGuionesBajosPorEspacios(procedure.proceedLabel || procedure.action) }),
+      Object.values(validationErrors).some((err) => err !== null) && /* @__PURE__ */ jsxs13(Alert3, { severity: "error", sx: { mb: 2, fontSize: "0.8rem" }, children: [
+        "Por favor, corrige los errores en el formulario antes de enviar.",
+        /* @__PURE__ */ jsx19("ul", { children: Object.values(validationErrors).map((err, idx) => err && /* @__PURE__ */ jsx19("li", { children: err }, idx)) })
+      ] }),
+      !Object.values(validationErrors).some((err) => err !== null) && apiError && /* @__PURE__ */ jsx19(Alert3, { severity: "error", sx: { mb: 2, fontSize: "0.8rem" }, children: apiError.message }),
+      !Object.values(validationErrors).some((err) => err !== null) && !apiError && successMessage && /* @__PURE__ */ jsx19(Alert3, { severity: "success", sx: { mb: 2, fontSize: "0.8rem" }, children: successMessage }),
+      /* @__PURE__ */ jsxs13("form", { onSubmit: handleSubmit, children: [
+        procedure.parameters.map((param) => /* @__PURE__ */ jsx19("div", { children: renderInputField(param) }, param.name)),
+        /* @__PURE__ */ jsx19(
+          Button6,
+          {
+            type: "submit",
+            variant: "contained",
+            color: "primary",
+            disabled: apiLoading || Object.values(validationErrors).some((err) => err !== null),
+            sx: { mt: 2 },
+            size: "medium",
+            startIcon: apiLoading ? /* @__PURE__ */ jsx19(CircularProgress4, { size: 20, color: "inherit" }) : null,
+            children: apiLoading ? "Ejecutando..." : procedure.proceedLabel || "Ejecutar"
+          }
+        )
+      ] }),
+      ResultDisplayContent && /* @__PURE__ */ jsxs13(Box13, { sx: { mt: 2 }, children: [
+        " ",
+        ResultDisplayContent
+      ] }),
+      executionLog.length > 0 && /* @__PURE__ */ jsxs13(Box13, { sx: { mt: 3 }, children: [
+        /* @__PURE__ */ jsx19(Divider2, { sx: { mb: 2 } }),
+        /* @__PURE__ */ jsx19(Typography14, { variant: "h6", gutterBottom: true, sx: { fontSize: "0.9rem" }, children: "Registro de Ejecuci\xF3n" }),
+        /* @__PURE__ */ jsx19(
+          Box13,
+          {
+            sx: {
+              bgcolor: "grey.100",
+              p: 2,
+              borderRadius: 1,
+              maxHeight: "200px",
+              // Este log puede tener su propio scroll interno si es muy largo
+              overflowY: "auto",
+              fontFamily: "monospace",
+              fontSize: "0.75rem",
+              whiteSpace: "pre-wrap"
+            },
+            children: executionLog.map((log, index) => /* @__PURE__ */ jsx19(
+              Typography14,
+              {
+                component: "pre",
+                sx: {
+                  margin: 0,
+                  color: log.includes("ERROR:") ? "error.main" : "text.primary",
+                  fontSize: "inherit"
+                },
+                children: log
+              },
+              index
+            ))
+          }
+        )
+      ] })
+    ] })
+  );
+};
+var ProcedureForm_default = ProcedureForm;
+
+// src/App.tsx
+import { Provider } from "react-redux";
+import { PersistGate } from "redux-persist/integration/react";
+
+// src/components/PrivateRoute.tsx
+import { useEffect as useEffect5 } from "react";
+import { Navigate, useLocation as useLocation2 } from "react-router-dom";
+import { Fragment as Fragment4, jsx as jsx20 } from "react/jsx-runtime";
+var PrivateRoute = ({ children }) => {
+  const location = useLocation2();
+  const dispatch = useAppDispatch();
+  const clientContextStatus = useClientContextStatus();
+  const isAuthenticated = clientContextStatus === "succeeded";
+  const isLoadingAuth = clientContextStatus === "loading";
+  console.log(`[PrivateRoute] Render: Path=${location.pathname}, AuthStatus=${clientContextStatus}, IsAuthenticated=${isAuthenticated}, IsLoadingAuth=${isLoadingAuth}`);
+  useEffect5(() => {
+    console.log(`[PrivateRoute] Effect: Path=${location.pathname}, AuthStatus=${clientContextStatus}, IsAuthenticated=${isAuthenticated}, IsLoadingAuth=${isLoadingAuth}`);
+    if (!isAuthenticated && !isLoadingAuth && location.pathname !== "/login") {
+      const path = location.pathname + location.search;
+      console.log(`[PrivateRoute] ACTION: Dispatching setRedirectPath(${path})`);
+      dispatch(setRedirectPath(path));
+    } else if (isAuthenticated) {
+      console.log(`[PrivateRoute] User is authenticated, no redirectPath set.`);
+    } else if (isLoadingAuth) {
+      console.log(`[PrivateRoute] Still loading authentication.`);
+    } else if (location.pathname === "/login") {
+      console.log(`[PrivateRoute] Currently on /login, not setting redirectPath.`);
+    }
+  }, [isAuthenticated, isLoadingAuth, location, dispatch, clientContextStatus]);
+  if (isLoadingAuth) {
+    console.log(`[PrivateRoute] Returning loading state...`);
+    return /* @__PURE__ */ jsx20("p", { children: "Verificando autenticaci\xF3n..." });
+  }
+  if (!isAuthenticated) {
+    console.log(`[PrivateRoute] User not authenticated, navigating to /login`);
+    return /* @__PURE__ */ jsx20(Navigate, { to: "/login", replace: true });
+  }
+  console.log(`[PrivateRoute] User authenticated, rendering children.`);
+  return /* @__PURE__ */ jsx20(Fragment4, { children });
+};
+var PrivateRoute_default = PrivateRoute;
+
+// src/components/InitialRedirectHandler.tsx
+import { useEffect as useEffect6 } from "react";
+import { useLocation as useLocation3, useNavigate as useNavigate6 } from "react-router-dom";
+var InitialRedirectHandler = () => {
+  const location = useLocation3();
+  const navigate = useNavigate6();
+  const dispatch = useAppDispatch();
+  const redirectPath = useRedirectPath();
+  const clientContextStatus = useClientContextStatus();
+  useEffect6(() => {
+    dispatch(setCurrentPath(location.pathname + location.search));
+  }, [location, dispatch]);
+  useEffect6(() => {
+    if (clientContextStatus === "succeeded") {
+      if (redirectPath && redirectPath !== "/login") {
+        console.log("Redirigiendo a la ruta guardada:", redirectPath);
+        navigate(redirectPath);
+        dispatch(setRedirectPath(null));
+      } else if (location.pathname === "/login" || location.pathname === "/") {
+        console.log("Usuario autenticado, redirigiendo a /home por defecto.");
+        navigate("/home");
+      }
+    }
+  }, [clientContextStatus, redirectPath, location.pathname, navigate, dispatch]);
+  return null;
+};
+var InitialRedirectHandler_default = InitialRedirectHandler;
+
+// src/pages/GenericDataGridPage.tsx
+import { useParams as useParams2 } from "react-router-dom";
+import { Box as Box14, Alert as Alert4, Typography as Typography15 } from "@mui/material";
+import { jsx as jsx21, jsxs as jsxs14 } from "react/jsx-runtime";
+var GenericDataGridPage = () => {
+  const { tableName } = useParams2();
+  if (!tableName) {
+    return /* @__PURE__ */ jsx21(Box14, { display: "flex", justifyContent: "center", alignItems: "center", minHeight: "200px", children: /* @__PURE__ */ jsxs14(Alert4, { severity: "error", children: [
+      /* @__PURE__ */ jsx21(Typography15, { variant: "h6", children: "Error: Nombre de tabla no especificado en la URL." }),
+      /* @__PURE__ */ jsx21(Typography15, { variant: "body1", children: "Por favor, aseg\xFArate de que la URL contenga el nombre de la tabla (ej. `/data/users`)." })
+    ] }) });
+  }
+  return /* @__PURE__ */ jsx21(GenericDataGrid_default, { tableName, fixedFields: [] });
+};
+var GenericDataGridPage_default = GenericDataGridPage;
+
+// src/pages/MenuTablePage.tsx
+import { useMemo as useMemo5 } from "react";
+import { useParams as useParams3 } from "react-router-dom";
+import { Box as Box15, Alert as Alert5, Typography as Typography16 } from "@mui/material";
+import { jsx as jsx22, jsxs as jsxs15 } from "react/jsx-runtime";
+var MenuTablePage = () => {
+  const { menuName } = useParams3();
+  const { clientContext } = useApp();
+  const findMenuItem = (items, nameToFind) => {
+    for (const item of items) {
+      if (item.name === nameToFind && item.menuType === "table") {
+        return item;
+      }
+      if (item.menuType === "menu" && item.menuContent) {
+        const found = findMenuItem(item.menuContent, nameToFind);
+        if (found) return found;
+      }
+    }
+    return void 0;
+  };
+  const { currentTableName, currentFixedFields } = useMemo5(() => {
+    let tableName = void 0;
+    let fixedFields = [];
+    if (menuName && clientContext && clientContext.menu) {
+      const menuItem = findMenuItem(clientContext.menu, menuName);
+      if (menuItem) {
+        tableName = menuItem.table || menuItem.name;
+        if (menuItem.ff) {
+          Object.keys(menuItem.ff || []).forEach((fixedFieldKey) => {
+            fixedFields.push({
+              fieldName: fixedFieldKey,
+              //@ts-ignore
+              value: menuItem.ff[fixedFieldKey]
+            });
+          });
+        }
+      } else {
+        console.warn(`[${menuName}] \xCDtem de men\xFA '${menuName}' no encontrado o no es de tipo 'table' en clientContext.menu.`);
+      }
+    }
+    return {
+      currentTableName: tableName,
+      currentFixedFields: fixedFields
+    };
+  }, [menuName, clientContext]);
+  if (!currentTableName) {
+    return /* @__PURE__ */ jsx22(Box15, { display: "flex", justifyContent: "center", alignItems: "center", minHeight: "200px", children: /* @__PURE__ */ jsxs15(Alert5, { severity: "error", children: [
+      /* @__PURE__ */ jsx22(Typography16, { variant: "h6", children: "Error: No se pudo cargar la informaci\xF3n de la tabla." }),
+      /* @__PURE__ */ jsx22(Typography16, { variant: "body1", children: "Verifique la configuraci\xF3n del men\xFA o el nombre de la tabla en la URL." })
+    ] }) });
+  }
+  return /* @__PURE__ */ jsx22(
+    GenericDataGrid_default,
+    {
+      tableName: currentTableName,
+      fixedFields: currentFixedFields
+    }
+  );
+};
+var MenuTablePage_default = MenuTablePage;
+
+// src/App.tsx
+import { jsx as jsx23, jsxs as jsxs16 } from "react/jsx-runtime";
+var LocationTracker = () => {
+  const location = useLocation4();
+  const dispatch = useAppDispatch();
+  useEffect7(() => {
+    dispatch(setCurrentPath(location.pathname + location.search));
+  }, [location, dispatch]);
+  return null;
+};
+function FrontendPlusReactRoutes({ myRoutes, myWScreens }) {
+  const allWScreens = { ...wScreens, ...myWScreens || {} };
+  return /* @__PURE__ */ jsxs16(Routes, { children: [
+    /* @__PURE__ */ jsx23(Route, { path: "/login", element: /* @__PURE__ */ jsx23(LoginPage_default, {}) }),
+    /* @__PURE__ */ jsx23(Route, { path: "/logout", element: /* @__PURE__ */ jsx23(LogoutPage_default, {}) }),
+    /* @__PURE__ */ jsxs16(Route, { element: /* @__PURE__ */ jsxs16(PrivateRoute_default, { children: [
+      /* @__PURE__ */ jsx23(InitialRedirectHandler_default, {}),
+      /* @__PURE__ */ jsx23(MainLayout_default, {})
+    ] }), children: [
+      /* @__PURE__ */ jsx23(Route, { path: "/", element: /* @__PURE__ */ jsx23(HomePage_default, {}) }),
+      /* @__PURE__ */ jsx23(Route, { path: "/home", element: /* @__PURE__ */ jsx23(HomePage_default, {}) }),
+      /* @__PURE__ */ jsx23(Route, { path: "/table/:tableName", element: /* @__PURE__ */ jsx23(GenericDataGridPage_default, {}) }),
+      /* @__PURE__ */ jsx23(Route, { path: "/menu/:menuName", element: /* @__PURE__ */ jsx23(MenuTablePage_default, {}) }),
+      /* @__PURE__ */ jsx23(Route, { path: "/procedures/:procedureName", element: /* @__PURE__ */ jsx23(ProcedureForm_default, {}) }),
+      Object.keys(allWScreens).map((screenName) => /* @__PURE__ */ jsx23(
+        Route,
+        {
+          path: `/wScreens/${screenName}`,
+          element: React11.createElement(wScreens[screenName], { screenName })
+        },
+        screenName
+      )),
+      /* @__PURE__ */ jsx23(
+        Route,
+        {
+          path: "/wScreens-fallback/:screenName",
+          element: /* @__PURE__ */ jsx23(WScreens_default, { screenName: ":screenName" })
+        }
+      ),
+      /* @__PURE__ */ jsx23(Route, { path: "*", element: /* @__PURE__ */ jsx23("div", { style: { marginTop: "20px", marginLeft: "10px" }, children: "404 - Recurso No Encontrado" }) })
+    ] }),
+    myRoutes,
+    /* @__PURE__ */ jsx23(Route, { path: "*", element: /* @__PURE__ */ jsx23(Navigate2, { to: "/", replace: true }) })
+  ] });
+}
+var App = ({
+  myRoutes,
+  myWScreens,
+  myClientSides,
+  myResultsOk
+}) => {
+  useEffect7(() => {
+    if (myClientSides) {
+      extendClientSides(myClientSides);
+    }
+    if (myResultsOk) {
+      extendResultsOk(myResultsOk);
+    }
+  }, [myClientSides, myResultsOk]);
+  return /* @__PURE__ */ jsx23(Provider, { store, children: /* @__PURE__ */ jsx23(PersistGate, { loading: null, persistor, children: /* @__PURE__ */ jsxs16(BrowserRouter, { children: [
+    /* @__PURE__ */ jsx23(LocationTracker, {}),
+    /* @__PURE__ */ jsx23(AppProvider, { children: /* @__PURE__ */ jsxs16(SnackbarProvider, { children: [
+      /* @__PURE__ */ jsx23(
+        FrontendPlusReactRoutes,
+        {
+          myRoutes,
+          myWScreens
+        }
+      ),
+      /* @__PURE__ */ jsx23(SessionExpiredMessage_default, {})
+    ] }) })
+  ] }) }) });
+};
+var App_default = App;
+export {
+  App_default as App,
+  AppProvider,
+  ConfirmDialog,
+  FrontendPlusReactRoutes,
+  GenericDataGrid_default as GenericDataGrid,
+  MainLayout_default as MainLayout,
+  SnackbarProvider,
+  cambiarGuionesBajosPorEspacios,
+  clientSides,
+  extendClientSides,
+  resultsOk as resultComponents,
+  useApiCall,
+  useApp,
+  useLogout_default as useLogout,
+  useSnackbar,
+  wScreens
+};
+//# sourceMappingURL=index.js.map