@tw1934/mui-material 7.3.7

package/esm/utils/mergeSlotProps.d.ts

@@ -0,0 +1,2 @@
+import { SlotComponentProps } from '@mui/utils/types';
+export default function mergeSlotProps<T extends SlotComponentProps<React.ElementType, {}, {}>, K = T, U = (T extends Function ? T : K extends Function ? K : T extends undefined ? K : T)>(externalSlotProps: T | undefined, defaultSlotProps: K): U;

package/esm/utils/mergeSlotProps.js

@@ -0,0 +1,75 @@
+import clsx from 'clsx';
+
+// Brought from [Base UI](https://github.com/mui/base-ui/blob/master/packages/react/src/merge-props/mergeProps.ts#L119)
+// Use it directly from Base UI once it's a package dependency.
+function isEventHandler(key, value) {
+  // This approach is more efficient than using a regex.
+  const thirdCharCode = key.charCodeAt(2);
+  return key[0] === 'o' && key[1] === 'n' && thirdCharCode >= 65 /* A */ && thirdCharCode <= 90 /* Z */ && typeof value === 'function';
+}
+export default function mergeSlotProps(externalSlotProps, defaultSlotProps) {
+  if (!externalSlotProps) {
+    return defaultSlotProps;
+  }
+  function extractHandlers(externalSlotPropsValue, defaultSlotPropsValue) {
+    const handlers = {};
+    Object.keys(defaultSlotPropsValue).forEach(key => {
+      if (isEventHandler(key, defaultSlotPropsValue[key]) && typeof externalSlotPropsValue[key] === 'function') {
+        // only compose the handlers if both default and external slot props match the event handler
+        handlers[key] = (...args) => {
+          externalSlotPropsValue[key](...args);
+          defaultSlotPropsValue[key](...args);
+        };
+      }
+    });
+    return handlers;
+  }
+  if (typeof externalSlotProps === 'function' || typeof defaultSlotProps === 'function') {
+    return ownerState => {
+      const defaultSlotPropsValue = typeof defaultSlotProps === 'function' ? defaultSlotProps(ownerState) : defaultSlotProps;
+      const externalSlotPropsValue = typeof externalSlotProps === 'function' ? externalSlotProps({
+        ...ownerState,
+        ...defaultSlotPropsValue
+      }) : externalSlotProps;
+      const className = clsx(ownerState?.className, defaultSlotPropsValue?.className, externalSlotPropsValue?.className);
+      const handlers = extractHandlers(externalSlotPropsValue, defaultSlotPropsValue);
+      return {
+        ...defaultSlotPropsValue,
+        ...externalSlotPropsValue,
+        ...handlers,
+        ...(!!className && {
+          className
+        }),
+        ...(defaultSlotPropsValue?.style && externalSlotPropsValue?.style && {
+          style: {
+            ...defaultSlotPropsValue.style,
+            ...externalSlotPropsValue.style
+          }
+        }),
+        ...(defaultSlotPropsValue?.sx && externalSlotPropsValue?.sx && {
+          sx: [...(Array.isArray(defaultSlotPropsValue.sx) ? defaultSlotPropsValue.sx : [defaultSlotPropsValue.sx]), ...(Array.isArray(externalSlotPropsValue.sx) ? externalSlotPropsValue.sx : [externalSlotPropsValue.sx])]
+        })
+      };
+    };
+  }
+  const typedDefaultSlotProps = defaultSlotProps;
+  const handlers = extractHandlers(externalSlotProps, typedDefaultSlotProps);
+  const className = clsx(typedDefaultSlotProps?.className, externalSlotProps?.className);
+  return {
+    ...defaultSlotProps,
+    ...externalSlotProps,
+    ...handlers,
+    ...(!!className && {
+      className
+    }),
+    ...(typedDefaultSlotProps?.style && externalSlotProps?.style && {
+      style: {
+        ...typedDefaultSlotProps.style,
+        ...externalSlotProps.style
+      }
+    }),
+    ...(typedDefaultSlotProps?.sx && externalSlotProps?.sx && {
+      sx: [...(Array.isArray(typedDefaultSlotProps.sx) ? typedDefaultSlotProps.sx : [typedDefaultSlotProps.sx]), ...(Array.isArray(externalSlotProps.sx) ? externalSlotProps.sx : [externalSlotProps.sx])]
+    })
+  };
+}

package/esm/utils/omitEventHandlers.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Removes event handlers from the given object.
+ * A field is considered an event handler if it is a function with a name beginning with `on`.
+ *
+ * @param object Object to remove event handlers from.
+ * @returns Object with event handlers removed.
+ */
+declare function omitEventHandlers<Props extends Record<string, unknown>>(object: Props | undefined): {};
+export default omitEventHandlers;

package/esm/utils/omitEventHandlers.js

@@ -0,0 +1,18 @@
+/**
+ * Removes event handlers from the given object.
+ * A field is considered an event handler if it is a function with a name beginning with `on`.
+ *
+ * @param object Object to remove event handlers from.
+ * @returns Object with event handlers removed.
+ */
+function omitEventHandlers(object) {
+  if (object === undefined) {
+    return {};
+  }
+  const result = {};
+  Object.keys(object).filter(prop => !(prop.match(/^on[A-Z]/) && typeof object[prop] === 'function')).forEach(prop => {
+    result[prop] = object[prop];
+  });
+  return result;
+}
+export default omitEventHandlers;

package/esm/utils/ownerDocument.d.ts

@@ -0,0 +1,2 @@
+import ownerDocument from '@mui/utils/ownerDocument';
+export default ownerDocument;

package/esm/utils/ownerDocument.js

@@ -0,0 +1,2 @@
+import ownerDocument from '@mui/utils/ownerDocument';
+export default ownerDocument;

package/esm/utils/ownerWindow.d.ts

@@ -0,0 +1,2 @@
+import ownerWindow from '@mui/utils/ownerWindow';
+export default ownerWindow;

package/esm/utils/ownerWindow.js

@@ -0,0 +1,2 @@
+import ownerWindow from '@mui/utils/ownerWindow';
+export default ownerWindow;

package/esm/utils/requirePropFactory.d.ts

@@ -0,0 +1,2 @@
+import requirePropFactory from '@mui/utils/requirePropFactory';
+export default requirePropFactory;

package/esm/utils/requirePropFactory.js

@@ -0,0 +1,2 @@
+import requirePropFactory from '@mui/utils/requirePropFactory';
+export default requirePropFactory;

package/esm/utils/setRef.d.ts

@@ -0,0 +1,2 @@
+import setRef from '@mui/utils/setRef';
+export default setRef;

package/esm/utils/setRef.js

@@ -0,0 +1,2 @@
+import setRef from '@mui/utils/setRef';
+export default setRef;

package/esm/utils/shouldSpreadAdditionalProps.js

@@ -0,0 +1,5 @@
+import isHostComponent from '@mui/utils/isHostComponent';
+const shouldSpreadAdditionalProps = Slot => {
+  return !Slot || !isHostComponent(Slot);
+};
+export default shouldSpreadAdditionalProps;

package/esm/utils/types.d.ts

@@ -0,0 +1,26 @@
+import { SxProps } from '@mui/system';
+import { SlotComponentProps } from '@mui/utils/types';
+import { Theme } from "../styles/index.js";
+export type { EventHandlers, WithOptionalOwnerState, SlotComponentProps, SlotComponentPropsWithSlotState } from '@mui/utils/types';
+export type SlotCommonProps = {
+  component?: React.ElementType;
+  sx?: SxProps<Theme>;
+};
+export type SlotProps<TSlotComponent extends React.ElementType, TOverrides, TOwnerState> = SlotComponentProps<TSlotComponent, SlotCommonProps & TOverrides, TOwnerState>;
+/**
+ * Use the keys of `Slots` to make sure that K contains all of the keys
+ *
+ * @example CreateSlotsAndSlotProps<{ root: React.ElementType, decorator: React.ElementType }, { root: ..., decorator: ... }>
+ */
+export type CreateSlotsAndSlotProps<Slots, K extends Record<keyof Slots, any>> = {
+  /**
+   * The components used for each slot inside.
+   * @default {}
+   */
+  slots?: Partial<Slots>;
+  /**
+   * The props used for each slot inside.
+   * @default {}
+   */
+  slotProps?: { [P in keyof K]?: K[P] };
+};

package/esm/utils/types.js

@@ -0,0 +1 @@
+export {};

package/esm/utils/unsupportedProp.d.ts

@@ -0,0 +1,2 @@
+import unsupportedProp from '@mui/utils/unsupportedProp';
+export default unsupportedProp;

package/esm/utils/unsupportedProp.js

@@ -0,0 +1,2 @@
+import unsupportedProp from '@mui/utils/unsupportedProp';
+export default unsupportedProp;

package/esm/utils/useControlled.d.ts

@@ -0,0 +1,2 @@
+import useControlled from '@mui/utils/useControlled';
+export default useControlled;

package/esm/utils/useControlled.js

@@ -0,0 +1,4 @@
+'use client';
+
+import useControlled from '@mui/utils/useControlled';
+export default useControlled;

package/esm/utils/useEnhancedEffect.d.ts

@@ -0,0 +1,2 @@
+import useEnhancedEffect from '@mui/utils/useEnhancedEffect';
+export default useEnhancedEffect;

package/esm/utils/useEnhancedEffect.js

@@ -0,0 +1,4 @@
+'use client';
+
+import useEnhancedEffect from '@mui/utils/useEnhancedEffect';
+export default useEnhancedEffect;

package/esm/utils/useEventCallback.d.ts

@@ -0,0 +1,2 @@
+import useEventCallback from '@mui/utils/useEventCallback';
+export default useEventCallback;

package/esm/utils/useEventCallback.js

@@ -0,0 +1,4 @@
+'use client';
+
+import useEventCallback from '@mui/utils/useEventCallback';
+export default useEventCallback;

package/esm/utils/useForkRef.d.ts

@@ -0,0 +1,2 @@
+import useForkRef from '@mui/utils/useForkRef';
+export default useForkRef;

package/esm/utils/useForkRef.js

@@ -0,0 +1,4 @@
+'use client';
+
+import useForkRef from '@mui/utils/useForkRef';
+export default useForkRef;

package/esm/utils/useId.d.ts

@@ -0,0 +1,2 @@
+import useId from '@mui/utils/useId';
+export default useId;

package/esm/utils/useId.js

@@ -0,0 +1,4 @@
+'use client';
+
+import useId from '@mui/utils/useId';
+export default useId;

package/esm/utils/useSlot.d.ts

@@ -0,0 +1,81 @@
+import * as React from 'react';
+import { ClassValue } from 'clsx';
+export type WithCommonProps<T> = T & {
+  className?: string;
+  style?: React.CSSProperties;
+  ref?: React.Ref<any>;
+};
+type EventHandlers = Record<string, React.EventHandler<any>>;
+type ExtractComponentProps<P> = P extends infer T | ((ownerState: any) => infer T) ? T : never;
+/**
+ * An internal function to create a Material UI slot.
+ *
+ * This is an advanced version of Base UI `useSlotProps` because Material UI allows leaf component to be customized via `component` prop
+ * while Base UI does not need to support leaf component customization.
+ *
+ * @param {string} name: name of the slot
+ * @param {object} parameters
+ * @returns {[Slot, slotProps]} The slot's React component and the slot's props
+ *
+ * Note: the returned slot's props
+ * - will never contain `component` prop.
+ * - might contain `as` prop.
+ */
+export default function useSlot<T extends string, ElementType extends React.ElementType, SlotProps, OwnerState extends {}, ExternalSlotProps extends {
+  component?: React.ElementType;
+  ref?: React.Ref<any>;
+}, ExternalForwardedProps extends {
+  component?: React.ElementType;
+  slots?: { [k in T]?: React.ElementType };
+  slotProps?: { [k in T]?: ExternalSlotProps | ((ownerState: OwnerState) => ExternalSlotProps) };
+}, AdditionalProps, SlotOwnerState extends {}>(
+/**
+ * The slot's name. All Material UI components should have `root` slot.
+ *
+ * If the name is `root`, the logic behaves differently from other slots,
+ * e.g. the `externalForwardedProps` are spread to `root` slot but not other slots.
+ */
+name: T, parameters: (T extends 'root' ? {
+  ref: React.ForwardedRef<any>;
+} : {
+  ref?: React.ForwardedRef<any>;
+}) & {
+  /**
+   * The slot's className
+   */
+  className: ClassValue | ClassValue[];
+  /**
+   * The slot's default styled-component
+   */
+  elementType: ElementType;
+  /**
+   * The component's ownerState
+   */
+  ownerState: OwnerState;
+  /**
+   * The `other` props from the consumer. It has to contain `component`, `slots`, and `slotProps`.
+   * The function will use those props to calculate the final rendered element and the returned props.
+   *
+   * If the slot is not `root`, the rest of the `externalForwardedProps` are neglected.
+   */
+  externalForwardedProps: ExternalForwardedProps;
+  getSlotProps?: (other: EventHandlers) => WithCommonProps<SlotProps>;
+  additionalProps?: WithCommonProps<AdditionalProps>;
+  /**
+   * props forward to `T` only if the `slotProps.*.component` is not provided.
+   * e.g. Autocomplete's listbox uses Popper + StyledComponent
+   */
+  internalForwardedProps?: any;
+  /**
+   * Set to true if the `elementType` is a styled component of another Material UI component.
+   *
+   * For example, the AlertRoot is a styled component of the Paper component.
+   * This flag is used to forward the `component` and `slotProps.root.component` to the Paper component.
+   * Otherwise, the `component` prop will be converted to `as` prop which replaces the Paper component (the paper styles are gone).
+   */
+  shouldForwardComponentProp?: boolean;
+}): [ElementType, {
+  className: string;
+  ownerState: OwnerState & SlotOwnerState;
+} & AdditionalProps & SlotProps & ExternalSlotProps & ExtractComponentProps<Exclude<Exclude<ExternalForwardedProps["slotProps"], undefined>[T], undefined>>];
+export {};

package/esm/utils/useSlot.js

@@ -0,0 +1,80 @@
+'use client';
+
+import useForkRef from '@mui/utils/useForkRef';
+import appendOwnerState from '@mui/utils/appendOwnerState';
+import resolveComponentProps from '@mui/utils/resolveComponentProps';
+import mergeSlotProps from '@mui/utils/mergeSlotProps';
+/**
+ * An internal function to create a Material UI slot.
+ *
+ * This is an advanced version of Base UI `useSlotProps` because Material UI allows leaf component to be customized via `component` prop
+ * while Base UI does not need to support leaf component customization.
+ *
+ * @param {string} name: name of the slot
+ * @param {object} parameters
+ * @returns {[Slot, slotProps]} The slot's React component and the slot's props
+ *
+ * Note: the returned slot's props
+ * - will never contain `component` prop.
+ * - might contain `as` prop.
+ */
+export default function useSlot(
+/**
+ * The slot's name. All Material UI components should have `root` slot.
+ *
+ * If the name is `root`, the logic behaves differently from other slots,
+ * e.g. the `externalForwardedProps` are spread to `root` slot but not other slots.
+ */
+name, parameters) {
+  const {
+    className,
+    elementType: initialElementType,
+    ownerState,
+    externalForwardedProps,
+    internalForwardedProps,
+    shouldForwardComponentProp = false,
+    ...useSlotPropsParams
+  } = parameters;
+  const {
+    component: rootComponent,
+    slots = {
+      [name]: undefined
+    },
+    slotProps = {
+      [name]: undefined
+    },
+    ...other
+  } = externalForwardedProps;
+  const elementType = slots[name] || initialElementType;
+
+  // `slotProps[name]` can be a callback that receives the component's ownerState.
+  // `resolvedComponentsProps` is always a plain object.
+  const resolvedComponentsProps = resolveComponentProps(slotProps[name], ownerState);
+  const {
+    props: {
+      component: slotComponent,
+      ...mergedProps
+    },
+    internalRef
+  } = mergeSlotProps({
+    className,
+    ...useSlotPropsParams,
+    externalForwardedProps: name === 'root' ? other : undefined,
+    externalSlotProps: resolvedComponentsProps
+  });
+  const ref = useForkRef(internalRef, resolvedComponentsProps?.ref, parameters.ref);
+  const LeafComponent = name === 'root' ? slotComponent || rootComponent : slotComponent;
+  const props = appendOwnerState(elementType, {
+    ...(name === 'root' && !rootComponent && !slots[name] && internalForwardedProps),
+    ...(name !== 'root' && !slots[name] && internalForwardedProps),
+    ...mergedProps,
+    ...(LeafComponent && !shouldForwardComponentProp && {
+      as: LeafComponent
+    }),
+    ...(LeafComponent && shouldForwardComponentProp && {
+      component: LeafComponent
+    }),
+    ref
+  }, ownerState);
+  return [elementType, props];
+}

package/esm/version/index.d.ts

@@ -0,0 +1,6 @@
+export declare const version: string | undefined;
+export declare const major: number;
+export declare const minor: number;
+export declare const patch: number;
+export declare const prerelease: string | undefined;
+export default version;

package/esm/version/index.js

@@ -0,0 +1,6 @@
+export const version = "7.3.7";
+export const major = Number("7");
+export const minor = Number("3");
+export const patch = Number("7");
+export const prerelease = undefined;
+export default version;

package/esm/zero-styled/index.d.ts

@@ -0,0 +1,11 @@
+import { Interpolation } from '@mui/system';
+import { extendSxProp } from '@mui/system/styleFunctionSx';
+import { Theme } from "../styles/createTheme.js";
+import useTheme from "../styles/useTheme.js";
+export { css, keyframes } from '@mui/system';
+export { default as styled } from "../styles/styled.js";
+export declare function globalCss(styles: Interpolation<{
+  theme: Theme;
+}>): (props: Record<string, any>) => import("react/jsx-runtime").JSX.Element;
+export declare function internal_createExtendSxProp(): typeof extendSxProp;
+export { useTheme };

package/esm/zero-styled/index.js

@@ -0,0 +1,26 @@
+import { extendSxProp } from '@mui/system/styleFunctionSx';
+import useTheme from "../styles/useTheme.js";
+import GlobalStyles from "../GlobalStyles/index.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+export { css, keyframes } from '@mui/system';
+export { default as styled } from "../styles/styled.js";
+export function globalCss(styles) {
+  return function GlobalStylesWrapper(props) {
+    return (
+      /*#__PURE__*/
+      // Pigment CSS `globalCss` support callback with theme inside an object but `GlobalStyles` support theme as a callback value.
+      _jsx(GlobalStyles, {
+        styles: typeof styles === 'function' ? theme => styles({
+          theme,
+          ...props
+        }) : styles
+      })
+    );
+  };
+}
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export function internal_createExtendSxProp() {
+  return extendSxProp;
+}
+export { useTheme };

package/generateUtilityClass/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from '@mui/utils/generateUtilityClass';
+export type { GlobalStateSlot } from '@mui/utils/generateUtilityClass';

package/generateUtilityClass/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _generateUtilityClass.default;
+  }
+});
+var _generateUtilityClass = _interopRequireDefault(require("@mui/utils/generateUtilityClass"));

package/generateUtilityClasses/index.d.ts

@@ -0,0 +1 @@
+export { default } from '@mui/utils/generateUtilityClasses';

package/generateUtilityClasses/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _generateUtilityClasses.default;
+  }
+});
+var _generateUtilityClasses = _interopRequireDefault(require("@mui/utils/generateUtilityClasses"));