@m4l/components 8.2.3 → 9.0.0-beta-1

package/internal_libs/react-splitter-layout.js

@@ -0,0 +1,158 @@
+import { g as getDefaultExportFromCjs } from "../commonjs/index.js";
+import require$$0 from "prop-types";
+import React from "react";
+var lib = { exports: {} };
+(function(module, exports) {
+  !function(e, t) {
+    module.exports = t(require$$0, React);
+  }(window, function(e, t) {
+    return function(e2) {
+      var t2 = {};
+      function n(o) {
+        if (t2[o]) return t2[o].exports;
+        var r = t2[o] = { i: o, l: false, exports: {} };
+        return e2[o].call(r.exports, r, r.exports, n), r.l = true, r.exports;
+      }
+      return n.m = e2, n.c = t2, n.d = function(e3, t3, o) {
+        n.o(e3, t3) || Object.defineProperty(e3, t3, { enumerable: true, get: o });
+      }, n.r = function(e3) {
+        "undefined" != typeof Symbol && Symbol.toStringTag && Object.defineProperty(e3, Symbol.toStringTag, { value: "Module" }), Object.defineProperty(e3, "__esModule", { value: true });
+      }, n.t = function(e3, t3) {
+        if (1 & t3 && (e3 = n(e3)), 8 & t3) return e3;
+        if (4 & t3 && "object" == typeof e3 && e3 && e3.__esModule) return e3;
+        var o = /* @__PURE__ */ Object.create(null);
+        if (n.r(o), Object.defineProperty(o, "default", { enumerable: true, value: e3 }), 2 & t3 && "string" != typeof e3) for (var r in e3) n.d(o, r, function(t4) {
+          return e3[t4];
+        }.bind(null, r));
+        return o;
+      }, n.n = function(e3) {
+        var t3 = e3 && e3.__esModule ? function() {
+          return e3.default;
+        } : function() {
+          return e3;
+        };
+        return n.d(t3, "a", t3), t3;
+      }, n.o = function(e3, t3) {
+        return Object.prototype.hasOwnProperty.call(e3, t3);
+      }, n.p = "", n(n.s = 2);
+    }([function(t2, n) {
+      t2.exports = e;
+    }, function(e2, n) {
+      e2.exports = t;
+    }, function(e2, t2, n) {
+      e2.exports = n(3);
+    }, function(e2, t2, n) {
+      n.r(t2);
+      var o = n(1), r = n.n(o), i = n(0), a = n.n(i);
+      function s(e3) {
+        var t3 = e3.size || 0, n2 = e3.percentage ? "%" : "px", o2 = "layout-pane", i2 = {};
+        return e3.primary ? o2 += " layout-pane-primary" : e3.vertical ? i2.height = "".concat(t3).concat(n2) : i2.width = "".concat(t3).concat(n2), r.a.createElement("div", { className: o2, style: i2 }, e3.children);
+      }
+      s.propTypes = { vertical: a.a.bool, primary: a.a.bool, size: a.a.number, percentage: a.a.bool, children: a.a.oneOfType([a.a.arrayOf(a.a.node), a.a.node]) }, s.defaultProps = { vertical: false, primary: false, size: 0, percentage: false, children: [] };
+      var c = s;
+      function l(e3) {
+        return (l = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(e4) {
+          return typeof e4;
+        } : function(e4) {
+          return e4 && "function" == typeof Symbol && e4.constructor === Symbol && e4 !== Symbol.prototype ? "symbol" : typeof e4;
+        })(e3);
+      }
+      function u(e3, t3) {
+        for (var n2 = 0; n2 < t3.length; n2++) {
+          var o2 = t3[n2];
+          o2.enumerable = o2.enumerable || false, o2.configurable = true, "value" in o2 && (o2.writable = true), Object.defineProperty(e3, o2.key, o2);
+        }
+      }
+      function p(e3) {
+        return (p = Object.setPrototypeOf ? Object.getPrototypeOf : function(e4) {
+          return e4.__proto__ || Object.getPrototypeOf(e4);
+        })(e3);
+      }
+      function d(e3, t3) {
+        return (d = Object.setPrototypeOf || function(e4, t4) {
+          return e4.__proto__ = t4, e4;
+        })(e3, t3);
+      }
+      function h(e3) {
+        if (void 0 === e3) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+        return e3;
+      }
+      function f() {
+        if (document.body.createTextRange) {
+          var e3 = document.body.createTextRange();
+          e3.collapse(), e3.select();
+        } else window.getSelection ? window.getSelection().empty ? window.getSelection().empty() : window.getSelection().removeAllRanges && window.getSelection().removeAllRanges() : document.selection && document.selection.empty();
+      }
+      var y = function(e3) {
+        function t3(e4) {
+          var n3, o3, r2;
+          return function(e5, t4) {
+            if (!(e5 instanceof t4)) throw new TypeError("Cannot call a class as a function");
+          }(this, t3), o3 = this, (n3 = !(r2 = p(t3).call(this, e4)) || "object" !== l(r2) && "function" != typeof r2 ? h(o3) : r2).handleResize = n3.handleResize.bind(h(h(n3))), n3.handleMouseMove = n3.handleMouseMove.bind(h(h(n3))), n3.handleMouseUp = n3.handleMouseUp.bind(h(h(n3))), n3.handleTouchMove = n3.handleTouchMove.bind(h(h(n3))), n3.handleSplitterMouseDown = n3.handleSplitterMouseDown.bind(h(h(n3))), n3.state = { secondaryPaneSize: 0, resizing: false }, n3;
+        }
+        var n2, o2;
+        return function(e4, t4) {
+          if ("function" != typeof t4 && null !== t4) throw new TypeError("Super expression must either be null or a function");
+          e4.prototype = Object.create(t4 && t4.prototype, { constructor: { value: e4, writable: true, configurable: true } }), t4 && d(e4, t4);
+        }(t3, r.a.Component), n2 = t3, (o2 = [{ key: "componentDidMount", value: function() {
+          var e4;
+          if (window.addEventListener("resize", this.handleResize), document.addEventListener("mouseup", this.handleMouseUp), document.addEventListener("mousemove", this.handleMouseMove), document.addEventListener("touchend", this.handleMouseUp), document.addEventListener("touchmove", this.handleTouchMove), void 0 !== this.props.secondaryInitialSize) e4 = this.props.secondaryInitialSize;
+          else {
+            var t4, n3 = this.container.getBoundingClientRect();
+            t4 = this.splitter ? this.splitter.getBoundingClientRect() : { width: 4, height: 4 }, e4 = this.getSecondaryPaneSize(n3, t4, { left: n3.left + (n3.width - t4.width) / 2, top: n3.top + (n3.height - t4.height) / 2 }, false);
+          }
+          this.setState({ secondaryPaneSize: e4 });
+        } }, { key: "componentDidUpdate", value: function(e4, t4) {
+          t4.secondaryPaneSize !== this.state.secondaryPaneSize && this.props.onSecondaryPaneSizeChange && this.props.onSecondaryPaneSizeChange(this.state.secondaryPaneSize), t4.resizing !== this.state.resizing && (this.state.resizing ? this.props.onDragStart && this.props.onDragStart() : this.props.onDragEnd && this.props.onDragEnd());
+        } }, { key: "componentWillUnmount", value: function() {
+          window.removeEventListener("resize", this.handleResize), document.removeEventListener("mouseup", this.handleMouseUp), document.removeEventListener("mousemove", this.handleMouseMove), document.removeEventListener("touchend", this.handleMouseUp), document.removeEventListener("touchmove", this.handleTouchMove);
+        } }, { key: "getSecondaryPaneSize", value: function(e4, t4, n3, o3) {
+          var r2, i2, a2, s2;
+          this.props.vertical ? (r2 = e4.height, i2 = t4.height, a2 = n3.top - e4.top) : (r2 = e4.width, i2 = t4.width, a2 = n3.left - e4.left), o3 && (a2 -= i2 / 2), a2 < 0 ? a2 = 0 : a2 > r2 - i2 && (a2 = r2 - i2);
+          var c2 = r2 - i2 - (s2 = 1 === this.props.primaryIndex ? a2 : r2 - i2 - a2);
+          return this.props.percentage && (s2 = 100 * s2 / r2, c2 = 100 * c2 / r2, i2 = 100 * i2 / r2, r2 = 100), c2 < this.props.primaryMinSize ? s2 = Math.max(s2 - (this.props.primaryMinSize - c2), 0) : s2 < this.props.secondaryMinSize && (s2 = Math.min(r2 - i2 - this.props.primaryMinSize, this.props.secondaryMinSize)), s2;
+        } }, { key: "handleResize", value: function() {
+          if (this.splitter && !this.props.percentage) {
+            var e4 = this.container.getBoundingClientRect(), t4 = this.splitter.getBoundingClientRect(), n3 = this.getSecondaryPaneSize(e4, t4, { left: t4.left, top: t4.top }, false);
+            this.setState({ secondaryPaneSize: n3 });
+          }
+        } }, { key: "handleMouseMove", value: function(e4) {
+          if (this.state.resizing) {
+            var t4 = this.container.getBoundingClientRect(), n3 = this.splitter.getBoundingClientRect(), o3 = this.getSecondaryPaneSize(t4, n3, { left: e4.clientX, top: e4.clientY }, true);
+            f(), this.setState({ secondaryPaneSize: o3 });
+          }
+        } }, { key: "handleTouchMove", value: function(e4) {
+          this.handleMouseMove(e4.changedTouches[0]);
+        } }, { key: "handleSplitterMouseDown", value: function() {
+          f(), this.setState({ resizing: true });
+        } }, { key: "handleMouseUp", value: function() {
+          this.setState(function(e4) {
+            return e4.resizing ? { resizing: false } : null;
+          });
+        } }, { key: "render", value: function() {
+          var e4 = this, t4 = "splitter-layout";
+          this.props.customClassName && (t4 += " ".concat(this.props.customClassName)), this.props.vertical && (t4 += " splitter-layout-vertical"), this.state.resizing && (t4 += " layout-changing");
+          var n3 = r.a.Children.toArray(this.props.children).slice(0, 2);
+          0 === n3.length && n3.push(r.a.createElement("div", null));
+          for (var o3 = [], i2 = 0 !== this.props.primaryIndex && 1 !== this.props.primaryIndex ? 0 : this.props.primaryIndex, a2 = 0; a2 < n3.length; ++a2) {
+            var s2 = true, l2 = null;
+            n3.length > 1 && a2 !== i2 && (s2 = false, l2 = this.state.secondaryPaneSize), o3.push(r.a.createElement(c, { vertical: this.props.vertical, percentage: this.props.percentage, primary: s2, size: l2 }, n3[a2]));
+          }
+          return r.a.createElement("div", { className: t4, ref: function(t5) {
+            e4.container = t5;
+          } }, o3[0], o3.length > 1 && r.a.createElement("div", { role: "separator", className: "layout-splitter", ref: function(t5) {
+            e4.splitter = t5;
+          }, onMouseDown: this.handleSplitterMouseDown, onTouchStart: this.handleSplitterMouseDown }), o3.length > 1 && o3[1]);
+        } }]) && u(n2.prototype, o2), t3;
+      }();
+      y.propTypes = { customClassName: a.a.string, vertical: a.a.bool, percentage: a.a.bool, primaryIndex: a.a.number, primaryMinSize: a.a.number, secondaryInitialSize: a.a.number, secondaryMinSize: a.a.number, onDragStart: a.a.func, onDragEnd: a.a.func, onSecondaryPaneSizeChange: a.a.func, children: a.a.arrayOf(a.a.node) }, y.defaultProps = { customClassName: "", vertical: false, percentage: false, primaryIndex: 0, primaryMinSize: 0, secondaryInitialSize: void 0, secondaryMinSize: 0, onDragStart: null, onDragEnd: null, onSecondaryPaneSizeChange: null, children: [] };
+      var m = y;
+      t2.default = m;
+    }]);
+  });
+})(lib);
+var libExports = lib.exports;
+const SplitterLayout = /* @__PURE__ */ getDefaultExportFromCjs(libExports);
+export {
+  SplitterLayout as S
+};

package/mockServiceWorker.js

@@ -0,0 +1,307 @@
+/* eslint-disable */
+/* tslint:disable */
+
+/**
+ * Mock Service Worker.
+ * @see https://github.com/mswjs/msw
+ * - Please do NOT modify this file.
+ * - Please do NOT serve this file on production.
+ */
+
+const PACKAGE_VERSION = '2.7.4'
+const INTEGRITY_CHECKSUM = '00729d72e3b82faf54ca8b9621dbb96f'
+const IS_MOCKED_RESPONSE = Symbol('isMockedResponse')
+const activeClientIds = new Set()
+
+self.addEventListener('install', function () {
+  self.skipWaiting()
+})
+
+self.addEventListener('activate', function (event) {
+  event.waitUntil(self.clients.claim())
+})
+
+self.addEventListener('message', async function (event) {
+  const clientId = event.source.id
+
+  if (!clientId || !self.clients) {
+    return
+  }
+
+  const client = await self.clients.get(clientId)
+
+  if (!client) {
+    return
+  }
+
+  const allClients = await self.clients.matchAll({
+    type: 'window',
+  })
+
+  switch (event.data) {
+    case 'KEEPALIVE_REQUEST': {
+      sendToClient(client, {
+        type: 'KEEPALIVE_RESPONSE',
+      })
+      break
+    }
+
+    case 'INTEGRITY_CHECK_REQUEST': {
+      sendToClient(client, {
+        type: 'INTEGRITY_CHECK_RESPONSE',
+        payload: {
+          packageVersion: PACKAGE_VERSION,
+          checksum: INTEGRITY_CHECKSUM,
+        },
+      })
+      break
+    }
+
+    case 'MOCK_ACTIVATE': {
+      activeClientIds.add(clientId)
+
+      sendToClient(client, {
+        type: 'MOCKING_ENABLED',
+        payload: {
+          client: {
+            id: client.id,
+            frameType: client.frameType,
+          },
+        },
+      })
+      break
+    }
+
+    case 'MOCK_DEACTIVATE': {
+      activeClientIds.delete(clientId)
+      break
+    }
+
+    case 'CLIENT_CLOSED': {
+      activeClientIds.delete(clientId)
+
+      const remainingClients = allClients.filter((client) => {
+        return client.id !== clientId
+      })
+
+      // Unregister itself when there are no more clients
+      if (remainingClients.length === 0) {
+        self.registration.unregister()
+      }
+
+      break
+    }
+  }
+})
+
+self.addEventListener('fetch', function (event) {
+  const { request } = event
+
+  // Bypass navigation requests.
+  if (request.mode === 'navigate') {
+    return
+  }
+
+  // Opening the DevTools triggers the "only-if-cached" request
+  // that cannot be handled by the worker. Bypass such requests.
+  if (request.cache === 'only-if-cached' && request.mode !== 'same-origin') {
+    return
+  }
+
+  // Bypass all requests when there are no active clients.
+  // Prevents the self-unregistered worked from handling requests
+  // after it's been deleted (still remains active until the next reload).
+  if (activeClientIds.size === 0) {
+    return
+  }
+
+  // Generate unique request ID.
+  const requestId = crypto.randomUUID()
+  event.respondWith(handleRequest(event, requestId))
+})
+
+async function handleRequest(event, requestId) {
+  const client = await resolveMainClient(event)
+  const response = await getResponse(event, client, requestId)
+
+  // Send back the response clone for the "response:*" life-cycle events.
+  // Ensure MSW is active and ready to handle the message, otherwise
+  // this message will pend indefinitely.
+  if (client && activeClientIds.has(client.id)) {
+    ;(async function () {
+      const responseClone = response.clone()
+
+      sendToClient(
+        client,
+        {
+          type: 'RESPONSE',
+          payload: {
+            requestId,
+            isMockedResponse: IS_MOCKED_RESPONSE in response,
+            type: responseClone.type,
+            status: responseClone.status,
+            statusText: responseClone.statusText,
+            body: responseClone.body,
+            headers: Object.fromEntries(responseClone.headers.entries()),
+          },
+        },
+        [responseClone.body],
+      )
+    })()
+  }
+
+  return response
+}
+
+// Resolve the main client for the given event.
+// Client that issues a request doesn't necessarily equal the client
+// that registered the worker. It's with the latter the worker should
+// communicate with during the response resolving phase.
+async function resolveMainClient(event) {
+  const client = await self.clients.get(event.clientId)
+
+  if (activeClientIds.has(event.clientId)) {
+    return client
+  }
+
+  if (client?.frameType === 'top-level') {
+    return client
+  }
+
+  const allClients = await self.clients.matchAll({
+    type: 'window',
+  })
+
+  return allClients
+    .filter((client) => {
+      // Get only those clients that are currently visible.
+      return client.visibilityState === 'visible'
+    })
+    .find((client) => {
+      // Find the client ID that's recorded in the
+      // set of clients that have registered the worker.
+      return activeClientIds.has(client.id)
+    })
+}
+
+async function getResponse(event, client, requestId) {
+  const { request } = event
+
+  // Clone the request because it might've been already used
+  // (i.e. its body has been read and sent to the client).
+  const requestClone = request.clone()
+
+  function passthrough() {
+    // Cast the request headers to a new Headers instance
+    // so the headers can be manipulated with.
+    const headers = new Headers(requestClone.headers)
+
+    // Remove the "accept" header value that marked this request as passthrough.
+    // This prevents request alteration and also keeps it compliant with the
+    // user-defined CORS policies.
+    const acceptHeader = headers.get('accept')
+    if (acceptHeader) {
+      const values = acceptHeader.split(',').map((value) => value.trim())
+      const filteredValues = values.filter(
+        (value) => value !== 'msw/passthrough',
+      )
+
+      if (filteredValues.length > 0) {
+        headers.set('accept', filteredValues.join(', '))
+      } else {
+        headers.delete('accept')
+      }
+    }
+
+    return fetch(requestClone, { headers })
+  }
+
+  // Bypass mocking when the client is not active.
+  if (!client) {
+    return passthrough()
+  }
+
+  // Bypass initial page load requests (i.e. static assets).
+  // The absence of the immediate/parent client in the map of the active clients
+  // means that MSW hasn't dispatched the "MOCK_ACTIVATE" event yet
+  // and is not ready to handle requests.
+  if (!activeClientIds.has(client.id)) {
+    return passthrough()
+  }
+
+  // Notify the client that a request has been intercepted.
+  const requestBuffer = await request.arrayBuffer()
+  const clientMessage = await sendToClient(
+    client,
+    {
+      type: 'REQUEST',
+      payload: {
+        id: requestId,
+        url: request.url,
+        mode: request.mode,
+        method: request.method,
+        headers: Object.fromEntries(request.headers.entries()),
+        cache: request.cache,
+        credentials: request.credentials,
+        destination: request.destination,
+        integrity: request.integrity,
+        redirect: request.redirect,
+        referrer: request.referrer,
+        referrerPolicy: request.referrerPolicy,
+        body: requestBuffer,
+        keepalive: request.keepalive,
+      },
+    },
+    [requestBuffer],
+  )
+
+  switch (clientMessage.type) {
+    case 'MOCK_RESPONSE': {
+      return respondWithMock(clientMessage.data)
+    }
+
+    case 'PASSTHROUGH': {
+      return passthrough()
+    }
+  }
+
+  return passthrough()
+}
+
+function sendToClient(client, message, transferrables = []) {
+  return new Promise((resolve, reject) => {
+    const channel = new MessageChannel()
+
+    channel.port1.onmessage = (event) => {
+      if (event.data && event.data.error) {
+        return reject(event.data.error)
+      }
+
+      resolve(event.data)
+    }
+
+    client.postMessage(
+      message,
+      [channel.port2].concat(transferrables.filter(Boolean)),
+    )
+  })
+}
+
+async function respondWithMock(response) {
+  // Setting response status code to 0 is a no-op.
+  // However, when responding with a "Response.error()", the produced Response
+  // instance will have status code set to 0. Since it's not possible to create
+  // a Response instance with status code 0, handle that use-case separately.
+  if (response.status === 0) {
+    return Response.error()
+  }
+
+  const mockedResponse = new Response(response.body, response)
+
+  Reflect.defineProperty(mockedResponse, IS_MOCKED_RESPONSE, {
+    value: true,
+    enumerable: true,
+  })
+
+  return mockedResponse
+}

package/package.json

@@ -1,15 +1,21 @@
 {
   "name": "@m4l/components",
-  "version": "8.2.3",
+  "version": "9.0.0-beta-1",
   "license": "UNLICENSED",
   "lint-staged": {
-    "*.{js,ts,tsx}": "eslint --fix --max-warnings 0"
+    "*.{js,ts,tsx}": "eslint --fix --max-warnings 0  --no-warn-ignored"
   },
   "dependencies": {
     "@geoman-io/leaflet-geoman-free": "^2.14.2",
     "@googlemaps/js-api-loader": "^1.16.6",
     "@hookform/resolvers": "^2.9.5",
+    "@m4l/core": "^2.0.0",
+    "@m4l/graphics": "^7.0.0",
+    "@m4l/styles": "^7.0.0",
     "@microlink/react-json-view": "^1.23.3",
+    "@mui/lab": "5.0.0-alpha.173",
+    "@mui/material": "5.16.7",
+    "@mui/x-date-pickers": "6.20.2",
     "atmosphere.js": "^4.0.0",
     "chart.js": "^4.4.0",
     "chartjs-chart-error-bars": "^4.3.3",
@@ -24,7 +30,7 @@
     "leaflet": "^1.9.4",
     "leaflet-polylinedecorator": "^1.6.0",
     "leaflet.markercluster": "^1.5.3",
-    "lodash-es": "^4.0.0",
+    "lodash-es": "^4.17.21",
     "nprogress": "^0.2.0",
     "qrcode.react": "^3.1.0",
     "qs": "^6.0.0",
@@ -42,23 +48,18 @@
     "react-intersection-observer": "^9.4.0",
     "react-leaflet": "^4.2.1",
     "react-resizable": "^3.0.4",
+    "react-rnd": "^10.5.2",
     "react-router-dom": "6.3.0",
     "react-spinners": "^0.13.8",
-    "react-splitter-layout": "^4.0.0",
     "react-toastify": "10.0.5",
     "react-transition-group": "^4.4.5",
+    "react-virtualized-auto-sizer": "^1.0.25",
+    "react-window": "^1.8.11",
     "simplebar-react": "3.2.6",
+    "storybook-multilevel-sort": "^2.0.1",
     "yup": "^0.32.11",
     "zustand": "4.3.6"
   },
-  "peerDependencies": {
-    "@m4l/core": "^2.0.12",
-    "@m4l/graphics": "^7.0.2",
-    "@m4l/styles": "^7.0.1",
-    "@mui/lab": "5.0.0-alpha.173",
-    "@mui/material": "^5.15.19",
-    "@mui/x-date-pickers": "^6.11.1"
-  },
   "resolutions": {
     "react": "^18.0.0",
     "@types/react": "^18.0.0",
@@ -66,7 +67,7 @@
     "react-dom": "^18.0.0",
     "storybook": "^8.3.4",
     "attr-accept": "2.2.2",
-    "@vitejs/plugin-react": "^4.0.0"
+    "@vitejs/plugin-react": "4.3.4"
   },
   "overrides": {
     "glob": "^10.4.5",
@@ -81,7 +82,7 @@
     "*"
   ],
   "source": "./index.js",
-  "main": "./index.js",
+  "main": "./dist/index.js",
   "module": "./index.js",
   "type": "module",
   "types": "./index.d.ts",
@@ -93,5 +94,15 @@
     "node": ">=12.0.0"
   },
   "packageManager": "yarn@4.5.0",
-  "private": false
+  "msw": {
+    "workerDirectory": [
+      "public"
+    ]
+  },
+  "private": false,
+  "exports": {
+    ".": {
+      "import": "./index.js"
+    }
+  }
 }

package/patchLibErrors/index.d.ts

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

package/patchLibErrors/index.js

@@ -0,0 +1 @@
+

package/patchLibErrors/patchErrors.d.ts

@@ -0,0 +1,5 @@
+/**
+ * TODO: Documentar
+ */
+declare const _default: {};
+export default _default;

package/patchLibErrors/patchErrors.js

@@ -0,0 +1 @@
+

package/storybook/components/AccountPopover/AccountPopover.stories.d.ts

@@ -0,0 +1,11 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { SideBar } from '../../../src/components/SideBar';
+import { AccountPopover } from '../../../src/components/AccountPopover';
+declare const meta: Meta<typeof AccountPopover>;
+type Story = StoryObj<typeof SideBar>;
+/**
+ * Componente AccountPopover por defecto.
+ * Muestra el avatar del usuario, la versión de la aplicación, el nombre del usuario y las opciones de menú.
+ */
+export declare const Default: Story;
+export default meta;

package/storybook/components/Areas/AreasAdmin/AreasAdmin.stories.d.ts

@@ -0,0 +1,8 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { PaperForm } from '../../../../src/components/PaperForm';
+import { AreasAdmin } from '../../../../src/components/areas/components/AreasAdmin/AreasAdmin';
+declare const meta: Meta<typeof AreasAdmin>;
+type Story = StoryObj<typeof PaperForm>;
+export declare const Default: Story;
+export declare const Skeleton: Story;
+export default meta;

package/storybook/components/Areas/AreasViewer/AreasViewer.stories.d.ts

@@ -0,0 +1,7 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { PaperForm } from '../../../../src/components/PaperForm';
+import { AreasViewer } from '../../../../src/components/areas/components/AreasViewer/AreasViewer';
+declare const meta: Meta<typeof AreasViewer>;
+type Story = StoryObj<typeof PaperForm>;
+export declare const Default: Story;
+export default meta;

package/storybook/components/Areas/AreasViewer/hooks/useWindowsActions.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Componente que define las acciones del header para "clientes"
+ */
+export declare function useWindowsActions(moduleId: string): null;

package/storybook/components/Areas/AreasViewer/moks/mokData.d.ts

@@ -0,0 +1,14 @@
+export declare const MOCK_CLIENTS: {
+    nombre: string;
+    correo: string;
+    telefono: string;
+    direccion: string;
+    ciudad: string;
+}[];
+export declare const MOCK_USERS: {
+    nombre: string;
+    apellido: string;
+    email: string;
+    telefono: string;
+    activo: boolean;
+}[];

package/storybook/components/Areas/AreasViewer/subcomponents/AreasViewerRender.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Render AreasViewer
+ */
+export declare const AreasViewerRender: () => import("react/jsx-runtime").JSX.Element;

package/storybook/components/Areas/AreasViewer/subcomponents/Launcher/Launcher.d.ts

@@ -0,0 +1,5 @@
+import { default as React } from 'react';
+/**
+ * Layout de prueba para lanzar popups con replaceMeId.
+ */
+export declare const Launcher: React.FC;

package/storybook/components/Areas/AreasViewer/subcomponents/Launcher/PopupButton.d.ts

@@ -0,0 +1,21 @@
+import { default as React } from 'react';
+interface PopupButtonProps {
+    title: string;
+    iconUrl: string;
+    dynamicParams: Record<string, any>;
+    /** Si se pasa este id, se intentará reemplazar el popup existente */
+    windowType?: 'simple_popup' | 'microfrontend_userd_add_edit_popup' | 'microfrontend_users_list_layout';
+    replaceMeId?: string;
+    onClick?: () => void;
+    /** Callback para notificar que se ha generado un id, en caso de no recibir uno por props */
+    onPopupCreated?: (id: string) => void;
+}
+export declare const heightWindow = 180;
+export declare const widthWindow = 460;
+export declare const marginWindow = 10;
+/**
+ * Botón que lanza un popup. Si se proporciona un replaceMeId, se usará ese id para reemplazar el popup existente;
+ * si no, se genera uno nuevo (incluyendo el currentAreaId) y se notifica al padre mediante onPopupCreated.
+ */
+export declare const PopupButton: React.FC<PopupButtonProps>;
+export {};

package/storybook/components/Areas/AreasViewer/subcomponents/Launcher/PopupContentExample.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Componente de ejemplo para el contenido de un popup.
+ */
+export declare const PopupContentExample: () => import("react/jsx-runtime").JSX.Element;

package/storybook/components/Areas/AreasViewer/subcomponents/layouts/ClientsLayout.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Componente que define las acciones del header para "clientes"
+ */
+export declare function CustomersLayout(): import("react/jsx-runtime").JSX.Element;