umwd-components 0.1.834 → 0.1.836

package/dist/esm/node_modules/xml-js/lib/xml2js.js

@@ -0,0 +1,360 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import '../../sax/lib/sax.js';
+import { o as optionsHelper } from './options-helper.js';
+import { a as arrayHelper } from './array-helper.js';
+import { __exports as sax$1 } from '../../../_virtual/sax.js';
+
+var sax = sax$1;
+var helper = optionsHelper;
+var isArray = arrayHelper.isArray;
+
+var options;
+var currentElement;
+
+function validateOptions(userOptions) {
+  options = helper.copyOptions(userOptions);
+  helper.ensureFlagExists('ignoreDeclaration', options);
+  helper.ensureFlagExists('ignoreInstruction', options);
+  helper.ensureFlagExists('ignoreAttributes', options);
+  helper.ensureFlagExists('ignoreText', options);
+  helper.ensureFlagExists('ignoreComment', options);
+  helper.ensureFlagExists('ignoreCdata', options);
+  helper.ensureFlagExists('ignoreDoctype', options);
+  helper.ensureFlagExists('compact', options);
+  helper.ensureFlagExists('alwaysChildren', options);
+  helper.ensureFlagExists('addParent', options);
+  helper.ensureFlagExists('trim', options);
+  helper.ensureFlagExists('nativeType', options);
+  helper.ensureFlagExists('nativeTypeAttributes', options);
+  helper.ensureFlagExists('sanitize', options);
+  helper.ensureFlagExists('instructionHasAttributes', options);
+  helper.ensureFlagExists('captureSpacesBetweenElements', options);
+  helper.ensureAlwaysArrayExists(options);
+  helper.ensureKeyExists('declaration', options);
+  helper.ensureKeyExists('instruction', options);
+  helper.ensureKeyExists('attributes', options);
+  helper.ensureKeyExists('text', options);
+  helper.ensureKeyExists('comment', options);
+  helper.ensureKeyExists('cdata', options);
+  helper.ensureKeyExists('doctype', options);
+  helper.ensureKeyExists('type', options);
+  helper.ensureKeyExists('name', options);
+  helper.ensureKeyExists('elements', options);
+  helper.ensureKeyExists('parent', options);
+  helper.checkFnExists('doctype', options);
+  helper.checkFnExists('instruction', options);
+  helper.checkFnExists('cdata', options);
+  helper.checkFnExists('comment', options);
+  helper.checkFnExists('text', options);
+  helper.checkFnExists('instructionName', options);
+  helper.checkFnExists('elementName', options);
+  helper.checkFnExists('attributeName', options);
+  helper.checkFnExists('attributeValue', options);
+  helper.checkFnExists('attributes', options);
+  return options;
+}
+
+function nativeType(value) {
+  var nValue = Number(value);
+  if (!isNaN(nValue)) {
+    return nValue;
+  }
+  var bValue = value.toLowerCase();
+  if (bValue === 'true') {
+    return true;
+  } else if (bValue === 'false') {
+    return false;
+  }
+  return value;
+}
+
+function addField(type, value) {
+  var key;
+  if (options.compact) {
+    if (
+      !currentElement[options[type + 'Key']] &&
+      (isArray(options.alwaysArray) ? options.alwaysArray.indexOf(options[type + 'Key']) !== -1 : options.alwaysArray)
+    ) {
+      currentElement[options[type + 'Key']] = [];
+    }
+    if (currentElement[options[type + 'Key']] && !isArray(currentElement[options[type + 'Key']])) {
+      currentElement[options[type + 'Key']] = [currentElement[options[type + 'Key']]];
+    }
+    if (type + 'Fn' in options && typeof value === 'string') {
+      value = options[type + 'Fn'](value, currentElement);
+    }
+    if (type === 'instruction' && ('instructionFn' in options || 'instructionNameFn' in options)) {
+      for (key in value) {
+        if (value.hasOwnProperty(key)) {
+          if ('instructionFn' in options) {
+            value[key] = options.instructionFn(value[key], key, currentElement);
+          } else {
+            var temp = value[key];
+            delete value[key];
+            value[options.instructionNameFn(key, temp, currentElement)] = temp;
+          }
+        }
+      }
+    }
+    if (isArray(currentElement[options[type + 'Key']])) {
+      currentElement[options[type + 'Key']].push(value);
+    } else {
+      currentElement[options[type + 'Key']] = value;
+    }
+  } else {
+    if (!currentElement[options.elementsKey]) {
+      currentElement[options.elementsKey] = [];
+    }
+    var element = {};
+    element[options.typeKey] = type;
+    if (type === 'instruction') {
+      for (key in value) {
+        if (value.hasOwnProperty(key)) {
+          break;
+        }
+      }
+      element[options.nameKey] = 'instructionNameFn' in options ? options.instructionNameFn(key, value, currentElement) : key;
+      if (options.instructionHasAttributes) {
+        element[options.attributesKey] = value[key][options.attributesKey];
+        if ('instructionFn' in options) {
+          element[options.attributesKey] = options.instructionFn(element[options.attributesKey], key, currentElement);
+        }
+      } else {
+        if ('instructionFn' in options) {
+          value[key] = options.instructionFn(value[key], key, currentElement);
+        }
+        element[options.instructionKey] = value[key];
+      }
+    } else {
+      if (type + 'Fn' in options) {
+        value = options[type + 'Fn'](value, currentElement);
+      }
+      element[options[type + 'Key']] = value;
+    }
+    if (options.addParent) {
+      element[options.parentKey] = currentElement;
+    }
+    currentElement[options.elementsKey].push(element);
+  }
+}
+
+function manipulateAttributes(attributes) {
+  if ('attributesFn' in options && attributes) {
+    attributes = options.attributesFn(attributes, currentElement);
+  }
+  if ((options.trim || 'attributeValueFn' in options || 'attributeNameFn' in options || options.nativeTypeAttributes) && attributes) {
+    var key;
+    for (key in attributes) {
+      if (attributes.hasOwnProperty(key)) {
+        if (options.trim) attributes[key] = attributes[key].trim();
+        if (options.nativeTypeAttributes) {
+          attributes[key] = nativeType(attributes[key]);
+        }
+        if ('attributeValueFn' in options) attributes[key] = options.attributeValueFn(attributes[key], key, currentElement);
+        if ('attributeNameFn' in options) {
+          var temp = attributes[key];
+          delete attributes[key];
+          attributes[options.attributeNameFn(key, attributes[key], currentElement)] = temp;
+        }
+      }
+    }
+  }
+  return attributes;
+}
+
+function onInstruction(instruction) {
+  var attributes = {};
+  if (instruction.body && (instruction.name.toLowerCase() === 'xml' || options.instructionHasAttributes)) {
+    var attrsRegExp = /([\w:-]+)\s*=\s*(?:"([^"]*)"|'([^']*)'|(\w+))\s*/g;
+    var match;
+    while ((match = attrsRegExp.exec(instruction.body)) !== null) {
+      attributes[match[1]] = match[2] || match[3] || match[4];
+    }
+    attributes = manipulateAttributes(attributes);
+  }
+  if (instruction.name.toLowerCase() === 'xml') {
+    if (options.ignoreDeclaration) {
+      return;
+    }
+    currentElement[options.declarationKey] = {};
+    if (Object.keys(attributes).length) {
+      currentElement[options.declarationKey][options.attributesKey] = attributes;
+    }
+    if (options.addParent) {
+      currentElement[options.declarationKey][options.parentKey] = currentElement;
+    }
+  } else {
+    if (options.ignoreInstruction) {
+      return;
+    }
+    if (options.trim) {
+      instruction.body = instruction.body.trim();
+    }
+    var value = {};
+    if (options.instructionHasAttributes && Object.keys(attributes).length) {
+      value[instruction.name] = {};
+      value[instruction.name][options.attributesKey] = attributes;
+    } else {
+      value[instruction.name] = instruction.body;
+    }
+    addField('instruction', value);
+  }
+}
+
+function onStartElement(name, attributes) {
+  var element;
+  if (typeof name === 'object') {
+    attributes = name.attributes;
+    name = name.name;
+  }
+  attributes = manipulateAttributes(attributes);
+  if ('elementNameFn' in options) {
+    name = options.elementNameFn(name, currentElement);
+  }
+  if (options.compact) {
+    element = {};
+    if (!options.ignoreAttributes && attributes && Object.keys(attributes).length) {
+      element[options.attributesKey] = {};
+      var key;
+      for (key in attributes) {
+        if (attributes.hasOwnProperty(key)) {
+          element[options.attributesKey][key] = attributes[key];
+        }
+      }
+    }
+    if (
+      !(name in currentElement) &&
+      (isArray(options.alwaysArray) ? options.alwaysArray.indexOf(name) !== -1 : options.alwaysArray)
+    ) {
+      currentElement[name] = [];
+    }
+    if (currentElement[name] && !isArray(currentElement[name])) {
+      currentElement[name] = [currentElement[name]];
+    }
+    if (isArray(currentElement[name])) {
+      currentElement[name].push(element);
+    } else {
+      currentElement[name] = element;
+    }
+  } else {
+    if (!currentElement[options.elementsKey]) {
+      currentElement[options.elementsKey] = [];
+    }
+    element = {};
+    element[options.typeKey] = 'element';
+    element[options.nameKey] = name;
+    if (!options.ignoreAttributes && attributes && Object.keys(attributes).length) {
+      element[options.attributesKey] = attributes;
+    }
+    if (options.alwaysChildren) {
+      element[options.elementsKey] = [];
+    }
+    currentElement[options.elementsKey].push(element);
+  }
+  element[options.parentKey] = currentElement; // will be deleted in onEndElement() if !options.addParent
+  currentElement = element;
+}
+
+function onText(text) {
+  if (options.ignoreText) {
+    return;
+  }
+  if (!text.trim() && !options.captureSpacesBetweenElements) {
+    return;
+  }
+  if (options.trim) {
+    text = text.trim();
+  }
+  if (options.nativeType) {
+    text = nativeType(text);
+  }
+  if (options.sanitize) {
+    text = text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+  }
+  addField('text', text);
+}
+
+function onComment(comment) {
+  if (options.ignoreComment) {
+    return;
+  }
+  if (options.trim) {
+    comment = comment.trim();
+  }
+  addField('comment', comment);
+}
+
+function onEndElement(name) {
+  var parentElement = currentElement[options.parentKey];
+  if (!options.addParent) {
+    delete currentElement[options.parentKey];
+  }
+  currentElement = parentElement;
+}
+
+function onCdata(cdata) {
+  if (options.ignoreCdata) {
+    return;
+  }
+  if (options.trim) {
+    cdata = cdata.trim();
+  }
+  addField('cdata', cdata);
+}
+
+function onDoctype(doctype) {
+  if (options.ignoreDoctype) {
+    return;
+  }
+  doctype = doctype.replace(/^ /, '');
+  if (options.trim) {
+    doctype = doctype.trim();
+  }
+  addField('doctype', doctype);
+}
+
+function onError(error) {
+  error.note = error; //console.error(error);
+}
+
+var xml2js = function (xml, userOptions) {
+
+  var parser = sax.parser(true, {}) ;
+  var result = {};
+  currentElement = result;
+
+  options = validateOptions(userOptions);
+
+  {
+    parser.opt = {strictEntities: true};
+    parser.onopentag = onStartElement;
+    parser.ontext = onText;
+    parser.oncomment = onComment;
+    parser.onclosetag = onEndElement;
+    parser.onerror = onError;
+    parser.oncdata = onCdata;
+    parser.ondoctype = onDoctype;
+    parser.onprocessinginstruction = onInstruction;
+  }
+
+  {
+    parser.write(xml).close();
+  }
+
+  if (result[options.elementsKey]) {
+    var temp = result[options.elementsKey];
+    delete result[options.elementsKey];
+    result[options.elementsKey] = temp;
+    delete result.text;
+  }
+
+  return result;
+
+};
+
+export { xml2js as x };

package/dist/esm/node_modules/xml-js/lib/xml2json.js

@@ -0,0 +1,33 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { o as optionsHelper } from './options-helper.js';
+import { x as xml2js$1 } from './xml2js.js';
+
+var helper = optionsHelper;
+var xml2js = xml2js$1;
+
+function validateOptions (userOptions) {
+  var options = helper.copyOptions(userOptions);
+  helper.ensureSpacesExists(options);
+  return options;
+}
+
+var xml2json = function(xml, userOptions) {
+  var options, js, json, parentKey;
+  options = validateOptions(userOptions);
+  js = xml2js(xml, options);
+  parentKey = 'compact' in options && options.compact ? '_parent' : 'parent';
+  // parentKey = ptions.compact ? '_parent' : 'parent'; // consider this
+  if ('addParent' in options && options.addParent) {
+    json = JSON.stringify(js, function (k, v) { return k === parentKey? '_' : v; }, options.spaces);
+  } else {
+    json = JSON.stringify(js, null, options.spaces);
+  }
+  return json.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
+};
+
+export { xml2json as x };

package/dist/esm/src/components/ExplanatoryFoldOut.js

@@ -0,0 +1,25 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { jsxs, jsx } from 'react/jsx-runtime';
+import Typography from '@mui/material/Typography';
+import Divider from '@mui/material/Divider';
+import Box from '@mui/material/Box';
+import Collapse from '@mui/material/Collapse';
+import Chip from '@mui/material/Chip';
+import KeyboardArrowDownIcon from '@mui/icons-material/KeyboardArrowDown';
+import KeyboardArrowUpIcon from '@mui/icons-material/KeyboardArrowUp';
+import { useState } from 'react';
+
+function ExplanatoryFoldOut({ title, description, sx = [], children, }) {
+    const [open, setOpen] = useState(false);
+    return (jsxs(Box, { sx: [
+            // You cannot spread `sx` directly because `SxProps` (typeof sx) can be an array.
+            ...(Array.isArray(sx) ? sx : [sx]),
+        ], children: [jsx(Divider, { textAlign: "left", children: jsx(Chip, { label: title, size: "small", color: "primary", onClick: () => setOpen(!open), icon: open ? jsx(KeyboardArrowUpIcon, {}) : jsx(KeyboardArrowDownIcon, {}) }) }), jsxs(Collapse, { in: open, children: [description && (jsx(Typography, { variant: "body2", color: "primary", sx: { mt: 1 }, children: description })), children && jsx(Box, { sx: { mt: 1 }, children: children })] })] }));
+}
+
+export { ExplanatoryFoldOut };

package/dist/esm/src/components/FluidBackground.js

@@ -0,0 +1,84 @@
+"use client";
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { useState, useEffect, useRef } from 'react';
+import { useTheme } from '@mui/material/styles';
+
+function MovingObject({ ObjectSize = 300 }) {
+    const [mousePosition, setMousePosition] = useState({ x: 0, y: 0 });
+    const followerRef = useRef(null);
+    const theme = useTheme();
+    // Function to handle mouse movement
+    const handleMouseMove = (event) => {
+        const { clientX, clientY } = event;
+        setMousePosition({ x: clientX, y: clientY });
+    };
+    // Function to update the animation frame
+    const updateFollowerPosition = () => {
+        if (followerRef.current) {
+            followerRef.current.style.position = "absolute";
+            followerRef.current.style.top = `${mousePosition.y}px`;
+            followerRef.current.style.left = `${mousePosition.x}px`;
+            // followerRef.current.style.transform = `translate(${mousePosition.x}px, ${mousePosition.y}px)`;
+        }
+        requestAnimationFrame(updateFollowerPosition);
+    };
+    useEffect(() => {
+        // Attach the mouse move listener
+        window.addEventListener("mousemove", handleMouseMove);
+        // Start the animation
+        requestAnimationFrame(updateFollowerPosition);
+        // Cleanup on component unmount
+        return () => {
+            window.removeEventListener("mousemove", handleMouseMove);
+        };
+    }, [mousePosition]);
+    return (jsxs("svg", { id: "object", ref: followerRef, width: `${ObjectSize}px`, height: `${ObjectSize}px`, style: {
+            position: "absolute",
+            // top: `${objectY}px`,
+            // left: `${objectX}px`,
+            transform: "translate(-50%, -50%)",
+        }, children: [jsx("defs", { children: jsxs("mask", { id: "radial-gradient-mask", children: [jsxs("radialGradient", { id: "gradient", cx: "50%", cy: "50%", r: "50%", fx: "50%", fy: "50%", children: [jsx("stop", { offset: "0%", stopColor: "white" }), jsx("stop", { offset: "100%", stopColor: "black" })] }), jsx("rect", { width: "100%", height: "100%", fill: "url(#gradient)" })] }) }), jsx("rect", { width: "100%", height: "100%", fill: theme.palette.primary.main, mask: "url(#radial-gradient-mask)", style: { filter: `opacity(.5)` } })] }));
+}
+function FluidBackground() {
+    const [ObjectSize, setObjectSize] = useState(300);
+    const theme = useTheme();
+    // setting up all the initial values
+    useEffect(() => {
+        setObjectSize(Math.sqrt(window.innerWidth ** 2 + window.innerHeight ** 2) / 1.3);
+    }, []);
+    return (jsxs("div", { style: {
+            position: "fixed",
+            top: 0,
+            left: 0,
+            width: "100vw",
+            height: "100vh",
+            zIndex: -1,
+            pointerEvents: "none",
+            isolation: "isolate",
+        }, children: [jsx("div", { id: "background", style: {
+                    position: "absolute",
+                    top: 0,
+                    left: 0,
+                    display: "Block",
+                    width: "100%",
+                    height: "100%",
+                    background: theme.palette.background.paper,
+                    zIndex: -1,
+                } }), jsx(MovingObject, { ObjectSize: ObjectSize }), jsxs("svg", { id: "foreground", style: {
+                    position: "absolute",
+                }, preserveAspectRatio: "xMidYMid slice", width: "100%", height: "100%", viewBox: "0 0 7680 4320 ", children: [jsx("defs", { children: jsxs("mask", { id: "mask", children: [jsx("rect", { width: "100%", height: "100%", fill: "white" }), jsxs("text", { transform: "translate(-1000 200) rotate(-15)", style: {
+                                        fill: "#000",
+                                        fontFamily: "Merriweather-Bold, Merriweather",
+                                        fontSize: "360px",
+                                        fontWeight: 700,
+                                        letterSpacing: ".055em",
+                                    }, children: [jsxs("tspan", { x: "0", y: "0", children: ["JELLE PAULUS IS A TALENTED WEB DEVELOPER AND", " "] }), jsxs("tspan", { x: "0", y: "432", children: ["DESIGNER WITH A PASSION FOR CREATING VISUALLY", " "] }), jsxs("tspan", { x: "0", y: "864", children: ["STUNNING AND USER-FRIENDLY WEBSITES. WITH A", " "] }), jsxs("tspan", { x: "0", y: "1296", children: ["KEEN EYE FOR DETAIL AND A FOCUS ON CREATING", " "] }), jsxs("tspan", { x: "0", y: "1728", children: ["CLEAN, FUNCTIONAL DESIGNS, JELLE HAS A", " "] }), jsxs("tspan", { x: "0", y: "2160", children: ["REPUTATION FOR DELIVERING HIGH-QUALITY WORK", " "] }), jsxs("tspan", { x: "0", y: "2592", children: ["THAT EXCEEDS HIS CLIENTS' EXPECTATIONS. HE HAS A", " "] }), jsxs("tspan", { x: "0", y: "3024", children: ["DEEP UNDERSTANDING OF THE LATEST WEB", " "] }), jsxs("tspan", { x: "0", y: "3456", children: ["DEVELOPMENT TECHNOLOGIES, AND IS ABLE TO", " "] }), jsxs("tspan", { x: "0", y: "3888", children: ["SEAMLESSLY INTEGRATE FUNCTIONALITY AND", " "] }), jsxs("tspan", { x: "0", y: "4320", children: ["AESTHETICS TO CREATE WEBSITES THAT ARE BOTH", " "] }), jsxs("tspan", { x: "0", y: "4752", children: ["FUNCTIONAL AND VISUALLY APPEALING. WHETHER", " "] }), jsxs("tspan", { x: "0", y: "5184", children: ["YOU'RE LOOKING TO ESTABLISH AN ONLINE PRESENCE", " "] }), jsxs("tspan", { x: "0", y: "5616", children: ["OR REVAMP AN EXISTING WEBSITE, JELLE HAS THE", " "] }), jsx("tspan", { x: "0", y: "6048", children: "SKILLS AND EXPERTISE TO BRING YOUR VISION TO LIFE." })] })] }) }), jsx("rect", { width: "100%", height: "100%", fill: theme.palette.background.default, mask: "url(#mask)" })] })] }));
+}
+
+export { FluidBackground as default };

package/dist/esm/src/components/LogoutButton.js

@@ -0,0 +1,21 @@
+"use client";
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { logoutAction } from '../data/actions/auth-actions.js';
+import Button from '@mui/material/Button';
+import LogoutIcon from '@mui/icons-material/Logout';
+
+//
+function LogoutButton({ text = "Log out", variant = "text", }) {
+    return (jsx("form", { action: logoutAction, children: jsxs(Button, { type: "submit", 
+            // aria-disabled={status.pending || loading}
+            // disabled={status.pending || loading}
+            startIcon: jsx(LogoutIcon, {}), variant: variant, children: [" ", text] }) }));
+}
+
+export { LogoutButton as default };

package/dist/esm/src/components/ScrollLink.js

@@ -0,0 +1,35 @@
+"use client";
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { jsx } from 'react/jsx-runtime';
+import Link from 'next/link';
+import { useTheme } from '@mui/material/styles';
+
+// component definition
+const ScrollLink = ({ children, ...props }) => {
+    const handleScroll = (e) => {
+        //e.preventDefault();
+        // remove everything before the hash
+        const targetId = e.currentTarget.href.replace(/.*\#/, "");
+        const elem = document.getElementById(targetId);
+        const scrollDistance = elem
+            ? window.scrollY + elem?.getBoundingClientRect().top
+            : 0;
+        window.scrollTo({
+            top: scrollDistance,
+            behavior: "smooth",
+        });
+    };
+    const theme = useTheme();
+    return (jsx(Link, { ...props, onClick: handleScroll, style: {
+            color: theme.palette.primary.contrastText,
+            textDecoration: "none",
+            cursor: "pointer",
+        }, children: children }));
+};
+
+export { ScrollLink as default };

package/dist/esm/src/components/StrapiErrors.js

@@ -0,0 +1,16 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { jsx } from 'react/jsx-runtime';
+import Alert from '@mui/material/Alert';
+
+function StrapiErrors({ error, }) {
+    if (!error?.message)
+        return null;
+    return jsx(Alert, { severity: "error", children: error.message });
+}
+
+export { StrapiErrors };

package/dist/esm/src/components/StrapiImage.js

@@ -0,0 +1,19 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { jsx } from 'react/jsx-runtime';
+import Image from 'next/image';
+import { getStrapiMedia } from '../lib/utils.js';
+
+function StrapiImage({ id, url, alternativeText = "", height, width, fill = false, style = {}, }) {
+    if (!url)
+        return null;
+    const imageUrl = getStrapiMedia(url);
+    const imageFallback = `https://placehold.co/${width}x${height}`;
+    return (jsx(Image, { id: id, src: imageUrl ?? imageFallback, alt: alternativeText, fill: fill, height: height, width: width, style: style }));
+}
+
+export { StrapiImage };

package/dist/esm/src/components/StyledLink.js

@@ -0,0 +1,18 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { jsx } from 'react/jsx-runtime';
+import Link$1 from 'next/link';
+import Link from '@mui/material/Link';
+
+function StyledLink({ href, sx = [], children, target, }) {
+    return (jsx(Link, { component: Link$1, href: href, target: target || "_blank", sx: [
+            // You cannot spread `sx` directly because `SxProps` (typeof sx) can be an array.
+            ...(Array.isArray(sx) ? sx : [sx]),
+        ], children: children }));
+}
+
+export { StyledLink };

package/dist/esm/src/components/SubmitButton.js

@@ -0,0 +1,21 @@
+"use client";
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { jsx } from 'react/jsx-runtime';
+import { useFormStatus } from 'react-dom';
+import Button from '@mui/material/Button';
+
+// TODO at props so disabled can be set from the outside
+function SubmitButton({ text, loadingText, loading, sx = {}, ...props }) {
+    const status = useFormStatus();
+    return (jsx(Button, { type: "submit", "aria-disabled": status.pending || loading, disabled: status.pending || loading, variant: "outlined", sx: [
+            // You cannot spread `sx` directly because `SxProps` (typeof sx) can be an array.
+            ...(Array.isArray(sx) ? sx : [sx]),
+        ], ...props, children: status.pending || loading ? loadingText : text }));
+}
+
+export { SubmitButton };