@iowas/toolpad 1.0.0

package/dist/nextjs.js

@@ -0,0 +1,858 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/nextjs.ts
+var nextjs_exports = {};
+__export(nextjs_exports, {
+  NextAppProvider: () => NextAppProvider
+});
+module.exports = __toCommonJS(nextjs_exports);
+
+// src/toolpad-core/nextjs/NextAppProvider.tsx
+var import_router2 = require("next/compat/router.js");
+
+// src/toolpad-core/nextjs/NextAppProviderApp.tsx
+var React11 = __toESM(require("react"));
+var import_link = __toESM(require("next/link.js"));
+var import_navigation = require("next/navigation.js");
+
+// src/toolpad-core/AppProvider/AppProvider.tsx
+var React10 = __toESM(require("react"));
+var import_prop_types2 = __toESM(require("prop-types"));
+var import_styles3 = require("@mui/material/styles");
+
+// src/toolpad-core/useNotifications/NotificationsContext.ts
+var React = __toESM(require("react"));
+var NotificationsContext = React.createContext(null);
+
+// src/toolpad-core/useNotifications/NotificationsProvider.tsx
+var React4 = __toESM(require("react"));
+var import_material = require("@mui/material");
+var import_Close = __toESM(require("@mui/icons-material/Close"));
+var import_useSlotProps = __toESM(require("@mui/utils/useSlotProps"));
+
+// src/toolpad-core/AppProvider/LocalizationProvider.tsx
+var React2 = __toESM(require("react"));
+var import_prop_types = __toESM(require("prop-types"));
+var import_styles = require("@mui/material/styles");
+
+// src/toolpad-core/locales/getLocalization.ts
+var getLocalization = (translations) => {
+  return {
+    components: {
+      MuiLocalizationProvider: {
+        defaultProps: {
+          localeText: __spreadValues({}, translations)
+        }
+      }
+    }
+  };
+};
+
+// src/toolpad-core/locales/en.tsx
+var enLabels = {
+  // Account
+  accountSignInLabel: "Sign In",
+  accountSignOutLabel: "Sign Out",
+  // AccountPreview
+  accountPreviewTitle: "Account",
+  accountPreviewIconButtonLabel: "Current User",
+  // SignInPage
+  signInTitle: (brandingTitle) => brandingTitle ? `Sign in to ${brandingTitle}` : "Sign in",
+  signInSubtitle: "Welcome user, please sign in to continue",
+  signInRememberMe: "Remember Me",
+  providerSignInTitle: (provider) => `Sign in with ${provider}`,
+  // Common authentication labels
+  email: "Email",
+  password: "Password",
+  username: "Username",
+  passkey: "Passkey",
+  // Common action labels
+  save: "Save",
+  cancel: "Cancel",
+  ok: "Ok",
+  or: "Or",
+  to: "To",
+  with: "With",
+  close: "Close",
+  delete: "Delete",
+  alert: "Alert",
+  confirm: "Confirm",
+  loading: "Loading...",
+  // CRUD
+  createNewButtonLabel: "Create new",
+  reloadButtonLabel: "Reload data",
+  createLabel: "Create",
+  createSuccessMessage: "Item created successfully.",
+  createErrorMessage: "Failed to create item. Reason:",
+  editLabel: "Edit",
+  editSuccessMessage: "Item edited successfully.",
+  editErrorMessage: "Failed to edit item. Reason:",
+  deleteLabel: "Delete",
+  deleteConfirmTitle: "Delete item?",
+  deleteConfirmMessage: "Do you wish to delete this item?",
+  deleteConfirmLabel: "Delete",
+  deleteCancelLabel: "Cancel",
+  deleteSuccessMessage: "Item deleted successfully.",
+  deleteErrorMessage: "Failed to delete item. Reason:",
+  deletedItemMessage: "This item has been deleted."
+};
+var en_default = getLocalization(enLabels);
+
+// src/toolpad-core/AppProvider/LocalizationProvider.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var LocalizationContext = React2.createContext({});
+var LocalizationProvider = function LocalizationProvider2(props) {
+  var _a, _b, _c;
+  const { localeText: propsLocaleText, children } = props;
+  const theme = (0, import_styles.useTheme)();
+  const themeLocaleText = (_c = (_b = (_a = theme == null ? void 0 : theme.components) == null ? void 0 : _a.MuiLocalizationProvider) == null ? void 0 : _b.defaultProps) == null ? void 0 : _c.localeText;
+  const defaultLocaleText2 = en_default.components.MuiLocalizationProvider.defaultProps.localeText;
+  const localeText = React2.useMemo(
+    () => __spreadValues(__spreadValues(__spreadValues({}, defaultLocaleText2), themeLocaleText), propsLocaleText),
+    [defaultLocaleText2, themeLocaleText, propsLocaleText]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(LocalizationContext.Provider, { value: localeText, children });
+};
+LocalizationProvider.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * @ignore
+   */
+  children: import_prop_types.default.node,
+  /**
+   * Locale for components texts
+   */
+  localeText: import_prop_types.default.object
+};
+function useLocaleText() {
+  return React2.useContext(LocalizationContext);
+}
+
+// src/toolpad-utils/react.tsx
+var React3 = __toESM(require("react"));
+var ReactIs = __toESM(require("react-is"));
+var import_jsx_runtime2 = require("react/jsx-runtime");
+function useNonNullableContext(context, name) {
+  const maybeContext = React3.useContext(context);
+  if (maybeContext === null || maybeContext === void 0) {
+    throw new Error(`context "${name}" was used without a Provider`);
+  }
+  return maybeContext;
+}
+
+// src/toolpad-core/useNotifications/NotificationsProvider.tsx
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var RootPropsContext = React4.createContext(null);
+var defaultLocaleText = {
+  close: "Close"
+};
+function Notification({ notificationKey, open, message, options, badge }) {
+  var _a, _b, _c;
+  const globalLocaleText = useLocaleText();
+  const localeText = __spreadValues(__spreadValues({}, defaultLocaleText), globalLocaleText);
+  const { close } = useNonNullableContext(NotificationsContext);
+  const { severity, actionText, onAction, autoHideDuration } = options;
+  const handleClose = React4.useCallback(
+    (event, reason) => {
+      if (reason === "clickaway") {
+        return;
+      }
+      close(notificationKey);
+    },
+    [notificationKey, close]
+  );
+  const action = /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(React4.Fragment, { children: [
+    onAction ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_material.Button, { color: "inherit", size: "small", onClick: onAction, children: actionText != null ? actionText : "Action" }) : null,
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      import_material.IconButton,
+      {
+        size: "small",
+        "aria-label": localeText == null ? void 0 : localeText.close,
+        title: localeText == null ? void 0 : localeText.close,
+        color: "inherit",
+        onClick: handleClose,
+        children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_Close.default, { fontSize: "small" })
+      }
+    )
+  ] });
+  const props = React4.useContext(RootPropsContext);
+  const SnackbarComponent = (_b = (_a = props == null ? void 0 : props.slots) == null ? void 0 : _a.snackbar) != null ? _b : import_material.Snackbar;
+  const snackbarSlotProps = (0, import_useSlotProps.default)({
+    elementType: SnackbarComponent,
+    ownerState: props,
+    externalSlotProps: (_c = props == null ? void 0 : props.slotProps) == null ? void 0 : _c.snackbar,
+    additionalProps: {
+      open,
+      autoHideDuration,
+      onClose: handleClose,
+      action
+    }
+  });
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(SnackbarComponent, __spreadProps(__spreadValues({}, snackbarSlotProps), { children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_material.Badge, { badgeContent: badge, color: "primary", sx: { width: "100%" }, children: severity ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_material.Alert, { severity, sx: { width: "100%" }, action, children: message }) : /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_material.SnackbarContent, { message, action }) }) }), notificationKey);
+}
+function Notifications({ state }) {
+  var _a;
+  const currentNotification = (_a = state.queue[0]) != null ? _a : null;
+  return currentNotification ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+    Notification,
+    __spreadProps(__spreadValues({}, currentNotification), {
+      badge: state.queue.length > 1 ? String(state.queue.length) : null
+    })
+  ) : null;
+}
+var nextId = 0;
+var generateId = () => {
+  const id = nextId;
+  nextId += 1;
+  return id;
+};
+function NotificationsProvider(props) {
+  const { children } = props;
+  const [state, setState] = React4.useState({ queue: [] });
+  const show = React4.useCallback((message, options = {}) => {
+    var _a;
+    const notificationKey = (_a = options.key) != null ? _a : `::toolpad-internal::notification::${generateId()}`;
+    setState((prev) => {
+      if (prev.queue.some((n) => n.notificationKey === notificationKey)) {
+        return prev;
+      }
+      return __spreadProps(__spreadValues({}, prev), {
+        queue: [...prev.queue, { message, options, notificationKey, open: true }]
+      });
+    });
+    return notificationKey;
+  }, []);
+  const close = React4.useCallback((key) => {
+    setState((prev) => __spreadProps(__spreadValues({}, prev), {
+      queue: prev.queue.filter((n) => n.notificationKey !== key)
+    }));
+  }, []);
+  const contextValue = React4.useMemo(() => ({ show, close }), [show, close]);
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(RootPropsContext.Provider, { value: props, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(NotificationsContext.Provider, { value: contextValue, children: [
+    children,
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Notifications, { state })
+  ] }) });
+}
+
+// src/toolpad-core/useDialogs/DialogsContext.tsx
+var React5 = __toESM(require("react"));
+var DialogsContext = React5.createContext(null);
+
+// src/toolpad-core/shared/context.ts
+var React6 = __toESM(require("react"));
+var BrandingContext = React6.createContext(null);
+var NavigationContext = React6.createContext([]);
+var PaletteModeContext = React6.createContext({
+  paletteMode: "light",
+  setPaletteMode: () => {
+  },
+  isDualTheme: false
+});
+var RouterContext = React6.createContext(null);
+var DashboardSidebarPageItemContext = React6.createContext(null);
+var WindowContext = React6.createContext(void 0);
+
+// src/toolpad-core/useDialogs/DialogsProvider.tsx
+var import_invariant = __toESM(require("invariant"));
+var React7 = __toESM(require("react"));
+var import_useEventCallback = __toESM(require("@mui/utils/useEventCallback"));
+var import_jsx_runtime4 = require("react/jsx-runtime");
+function DialogsProvider(props) {
+  const { children, unmountAfter = 1e3 } = props;
+  const [stack, setStack] = React7.useState([]);
+  const keyPrefix = React7.useId();
+  const nextId2 = React7.useRef(0);
+  const dialogMetadata = React7.useRef(/* @__PURE__ */ new WeakMap());
+  const requestDialog = (0, import_useEventCallback.default)(function open(Component, payload, options = {}) {
+    const { onClose = async () => {
+    } } = options;
+    let resolve;
+    const promise = new Promise((resolveImpl) => {
+      resolve = resolveImpl;
+    });
+    (0, import_invariant.default)(resolve, "resolve not set");
+    const key = `${keyPrefix}-${nextId2.current}`;
+    nextId2.current += 1;
+    const newEntry = {
+      key,
+      open: true,
+      promise,
+      Component,
+      payload,
+      onClose,
+      resolve
+    };
+    dialogMetadata.current.set(promise, newEntry);
+    setStack((prevStack) => [...prevStack, newEntry]);
+    return promise;
+  });
+  const closeDialogUi = (0, import_useEventCallback.default)(function closeDialogUi2(dialog) {
+    setStack(
+      (prevStack) => prevStack.map((entry) => entry.promise === dialog ? __spreadProps(__spreadValues({}, entry), { open: false }) : entry)
+    );
+    setTimeout(() => {
+      setStack((prevStack) => prevStack.filter((entry) => entry.promise !== dialog));
+    }, unmountAfter);
+  });
+  const closeDialog = (0, import_useEventCallback.default)(async function closeDialog2(dialog, result) {
+    const entryToClose = dialogMetadata.current.get(dialog);
+    (0, import_invariant.default)(entryToClose, "dialog not found");
+    try {
+      await entryToClose.onClose(result);
+    } finally {
+      entryToClose.resolve(result);
+      closeDialogUi(dialog);
+    }
+    return dialog;
+  });
+  const contextValue = React7.useMemo(
+    () => ({ open: requestDialog, close: closeDialog }),
+    [requestDialog, closeDialog]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(DialogsContext.Provider, { value: contextValue, children: [
+    children,
+    stack.map(({ key, open, Component, payload, promise }) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+      Component,
+      {
+        payload,
+        open,
+        onClose: async (result) => {
+          await closeDialog(promise, result);
+        }
+      },
+      key
+    ))
+  ] });
+}
+
+// src/toolpad-core/AppProvider/AppThemeProvider.tsx
+var React9 = __toESM(require("react"));
+var import_material2 = require("@mui/material");
+var import_styles2 = require("@mui/material/styles");
+var import_InitColorSchemeScript = __toESM(require("@mui/material/InitColorSchemeScript"));
+var import_CssBaseline = __toESM(require("@mui/material/CssBaseline"));
+var import_invariant2 = __toESM(require("invariant"));
+
+// src/toolpad-core/persistence/useStorageState.tsx
+var React8 = __toESM(require("react"));
+
+// src/toolpad-core/persistence/codec.tsx
+var CODEC_STRING = {
+  parse: (value) => value,
+  stringify: (value) => value
+};
+
+// src/toolpad-core/persistence/useStorageState.tsx
+var currentTabChangeListeners = /* @__PURE__ */ new Map();
+function onCurrentTabStorageChange(key, handler) {
+  let listeners = currentTabChangeListeners.get(key);
+  if (!listeners) {
+    listeners = /* @__PURE__ */ new Set();
+    currentTabChangeListeners.set(key, listeners);
+  }
+  listeners.add(handler);
+}
+function offCurrentTabStorageChange(key, handler) {
+  const listeners = currentTabChangeListeners.get(key);
+  if (!listeners) {
+    return;
+  }
+  listeners.delete(handler);
+  if (listeners.size === 0) {
+    currentTabChangeListeners.delete(key);
+  }
+}
+function emitCurrentTabStorageChange(key) {
+  const listeners = currentTabChangeListeners.get(key);
+  if (listeners) {
+    listeners.forEach((listener) => listener());
+  }
+}
+if (typeof window !== "undefined") {
+  const origSetItem = window.localStorage.setItem;
+  window.localStorage.setItem = function setItem(key, value) {
+    const result = origSetItem.call(this, key, value);
+    emitCurrentTabStorageChange(key);
+    return result;
+  };
+}
+function subscribe(area, key, callback) {
+  if (!key) {
+    return () => {
+    };
+  }
+  const storageHandler = (event) => {
+    if (event.storageArea === area && event.key === key) {
+      callback();
+    }
+  };
+  window.addEventListener("storage", storageHandler);
+  onCurrentTabStorageChange(key, callback);
+  return () => {
+    window.removeEventListener("storage", storageHandler);
+    offCurrentTabStorageChange(key, callback);
+  };
+}
+function getSnapshot(area, key) {
+  if (!key) {
+    return null;
+  }
+  try {
+    return area.getItem(key);
+  } catch (e) {
+    return null;
+  }
+}
+function setValue(area, key, value) {
+  if (!key) {
+    return;
+  }
+  try {
+    if (value === null) {
+      area.removeItem(key);
+    } else {
+      area.setItem(key, String(value));
+    }
+  } catch (e) {
+    return;
+  }
+  emitCurrentTabStorageChange(key);
+}
+var serverValue = [null, () => {
+}];
+function useStorageStateServer() {
+  return serverValue;
+}
+function encode(codec, value) {
+  return value === null ? null : codec.stringify(value);
+}
+function decode(codec, value) {
+  return value === null ? null : codec.parse(value);
+}
+var getKeyServerSnapshot = () => null;
+function useStorageState(area, key, initializer = null, options) {
+  var _a;
+  const codec = (_a = options == null ? void 0 : options.codec) != null ? _a : CODEC_STRING;
+  const [initialValue] = React8.useState(initializer);
+  const encodedInitialValue = React8.useMemo(
+    () => encode(codec, initialValue),
+    [codec, initialValue]
+  );
+  const subscribeKey = React8.useCallback(
+    (callback) => subscribe(area, key, callback),
+    [area, key]
+  );
+  const getKeySnapshot = React8.useCallback(
+    () => {
+      var _a2;
+      return (_a2 = getSnapshot(area, key)) != null ? _a2 : encodedInitialValue;
+    },
+    [area, encodedInitialValue, key]
+  );
+  const encodedStoredValue = React8.useSyncExternalStore(
+    subscribeKey,
+    getKeySnapshot,
+    getKeyServerSnapshot
+  );
+  const storedValue = React8.useMemo(
+    () => decode(codec, encodedStoredValue),
+    [codec, encodedStoredValue]
+  );
+  const setStoredValue = React8.useCallback(
+    (value) => {
+      const valueToStore = value instanceof Function ? value(storedValue) : value;
+      const encodedValueToStore = encode(codec, valueToStore);
+      setValue(area, key, encodedValueToStore);
+    },
+    [area, codec, storedValue, key]
+  );
+  const [nonStoredValue, setNonStoredValue] = React8.useState(initialValue);
+  if (!key) {
+    return [nonStoredValue, setNonStoredValue];
+  }
+  return [storedValue, setStoredValue];
+}
+
+// src/toolpad-core/useLocalStorageState/useLocalStorageState.tsx
+var useLocalStorageStateBrowser = (...args) => useStorageState(window.localStorage, ...args);
+var useLocalStorageState = typeof window === "undefined" ? useStorageStateServer : useLocalStorageStateBrowser;
+
+// src/toolpad-core/AppProvider/AppThemeProvider.tsx
+var import_jsx_runtime5 = require("react/jsx-runtime");
+var COLOR_SCHEME_STORAGE_KEY = "toolpad-color-scheme";
+var MODE_STORAGE_KEY = "toolpad-mode";
+function usePreferredMode(window2) {
+  const prefersDarkMode = (0, import_material2.useMediaQuery)(
+    "(prefers-color-scheme: dark)",
+    window2 && {
+      matchMedia: window2.matchMedia
+    }
+  );
+  return prefersDarkMode ? "dark" : "light";
+}
+function isCssVarsTheme(theme) {
+  return "vars" in theme;
+}
+function LegacyThemeProvider(props) {
+  const { children, theme, window: appWindow } = props;
+  (0, import_invariant2.default)(!isCssVarsTheme(theme), "This provider only accepts legacy themes.");
+  const isDualTheme = "light" in theme || "dark" in theme;
+  const preferredMode = usePreferredMode(appWindow);
+  const [userMode, setUserMode] = useLocalStorageState(MODE_STORAGE_KEY, "system");
+  const paletteMode = !userMode || userMode === "system" ? preferredMode : userMode;
+  const dualAwareTheme = React9.useMemo(
+    () => {
+      var _a;
+      return isDualTheme ? (_a = theme[paletteMode === "dark" ? "dark" : "light"]) != null ? _a : theme[paletteMode === "dark" ? "light" : "dark"] : theme;
+    },
+    [isDualTheme, paletteMode, theme]
+  );
+  const paletteModeContextValue = React9.useMemo(
+    () => ({
+      paletteMode,
+      setPaletteMode: setUserMode,
+      isDualTheme
+    }),
+    [isDualTheme, paletteMode, setUserMode]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_styles2.ThemeProvider, { theme: dualAwareTheme, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(PaletteModeContext.Provider, { value: paletteModeContextValue, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_CssBaseline.default, { enableColorScheme: true }),
+    children
+  ] }) });
+}
+function CssVarsPaletteModeProvider(props) {
+  const { children, window: appWindow } = props;
+  const preferredMode = usePreferredMode(appWindow);
+  const { mode, setMode, allColorSchemes } = (0, import_styles2.useColorScheme)();
+  const paletteModeContextValue = React9.useMemo(() => {
+    return {
+      paletteMode: !mode || mode === "system" ? preferredMode : mode,
+      setPaletteMode: setMode,
+      isDualTheme: allColorSchemes.length > 1
+    };
+  }, [allColorSchemes, mode, preferredMode, setMode]);
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(PaletteModeContext.Provider, { value: paletteModeContextValue, children });
+}
+function CssVarsThemeProvider(props) {
+  const { children, theme, window: appWindow, nonce } = props;
+  (0, import_invariant2.default)(isCssVarsTheme(theme), "This provider only accepts CSS vars themes.");
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(
+    import_styles2.ThemeProvider,
+    {
+      theme,
+      documentNode: appWindow == null ? void 0 : appWindow.document,
+      colorSchemeNode: appWindow == null ? void 0 : appWindow.document.documentElement,
+      disableNestedContext: true,
+      colorSchemeStorageKey: COLOR_SCHEME_STORAGE_KEY,
+      modeStorageKey: MODE_STORAGE_KEY,
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+          import_InitColorSchemeScript.default,
+          {
+            attribute: theme.colorSchemeSelector,
+            colorSchemeStorageKey: COLOR_SCHEME_STORAGE_KEY,
+            modeStorageKey: MODE_STORAGE_KEY,
+            nonce
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(CssVarsPaletteModeProvider, { window: appWindow, children: [
+          /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_CssBaseline.default, { enableColorScheme: true }),
+          children
+        ] })
+      ]
+    }
+  );
+}
+function AppThemeProvider(props) {
+  const _a = props, { children, theme } = _a, rest = __objRest(_a, ["children", "theme"]);
+  const useCssVarsProvider = isCssVarsTheme(theme);
+  return useCssVarsProvider ? /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(CssVarsThemeProvider, __spreadProps(__spreadValues({ theme }, rest), { children })) : /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(LegacyThemeProvider, __spreadProps(__spreadValues({ theme }, rest), { children }));
+}
+
+// src/toolpad-core/AppProvider/AppProvider.tsx
+var import_jsx_runtime6 = require("react/jsx-runtime");
+var AuthenticationContext = React10.createContext(null);
+var SessionContext = React10.createContext(null);
+function createDefaultTheme() {
+  return (0, import_styles3.createTheme)({
+    cssVariables: {
+      colorSchemeSelector: "data-toolpad-color-scheme"
+    },
+    colorSchemes: { dark: true }
+  });
+}
+function AppProvider(props) {
+  const {
+    children,
+    theme = createDefaultTheme(),
+    branding = null,
+    navigation = [],
+    localeText,
+    router = null,
+    authentication = null,
+    session = null,
+    window: appWindow,
+    nonce
+  } = props;
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(WindowContext.Provider, { value: appWindow, children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(AuthenticationContext.Provider, { value: authentication, children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(SessionContext.Provider, { value: session, children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(RouterContext.Provider, { value: router, children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(AppThemeProvider, { theme, window: appWindow, nonce, children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(LocalizationProvider, { localeText, children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(NotificationsProvider, { children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(DialogsProvider, { children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(BrandingContext.Provider, { value: branding, children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(NavigationContext.Provider, { value: navigation, children }) }) }) }) }) }) }) }) }) });
+}
+AppProvider.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * Authentication methods.
+   * @default null
+   */
+  authentication: import_prop_types2.default.shape({
+    signIn: import_prop_types2.default.func.isRequired,
+    signOut: import_prop_types2.default.func.isRequired
+  }),
+  /**
+   * Branding options for the app.
+   * @default null
+   */
+  branding: import_prop_types2.default.shape({
+    homeUrl: import_prop_types2.default.string,
+    logo: import_prop_types2.default.node,
+    title: import_prop_types2.default.string
+  }),
+  /**
+   * The content of the app provider.
+   */
+  children: import_prop_types2.default.node,
+  /**
+   * Locale text for components
+   */
+  localeText: import_prop_types2.default.object,
+  /**
+   * Navigation definition for the app. [Find out more](https://mui.com/toolpad/core/react-app-provider/#navigation).
+   * @default []
+   */
+  navigation: import_prop_types2.default.arrayOf(
+    import_prop_types2.default.oneOfType([
+      import_prop_types2.default.shape({
+        action: import_prop_types2.default.node,
+        children: import_prop_types2.default.arrayOf(
+          import_prop_types2.default.oneOfType([
+            import_prop_types2.default.object,
+            import_prop_types2.default.shape({
+              kind: import_prop_types2.default.oneOf(["header"]).isRequired,
+              title: import_prop_types2.default.string.isRequired
+            }),
+            import_prop_types2.default.shape({
+              kind: import_prop_types2.default.oneOf(["divider"]).isRequired
+            })
+          ]).isRequired
+        ),
+        icon: import_prop_types2.default.node,
+        kind: import_prop_types2.default.oneOf(["page"]),
+        pattern: import_prop_types2.default.string,
+        segment: import_prop_types2.default.string,
+        title: import_prop_types2.default.string
+      }),
+      import_prop_types2.default.shape({
+        kind: import_prop_types2.default.oneOf(["header"]).isRequired,
+        title: import_prop_types2.default.string.isRequired
+      }),
+      import_prop_types2.default.shape({
+        kind: import_prop_types2.default.oneOf(["divider"]).isRequired
+      })
+    ]).isRequired
+  ),
+  /**
+   * The nonce to be used for inline scripts.
+   */
+  nonce: import_prop_types2.default.string,
+  /**
+   * Router implementation used inside Toolpad components.
+   * @default null
+   */
+  router: import_prop_types2.default.shape({
+    Link: import_prop_types2.default.elementType,
+    navigate: import_prop_types2.default.func.isRequired,
+    pathname: import_prop_types2.default.string.isRequired,
+    searchParams: import_prop_types2.default.instanceOf(URLSearchParams).isRequired
+  }),
+  /**
+   * Session info about the current user.
+   * @default null
+   */
+  session: import_prop_types2.default.shape({
+    user: import_prop_types2.default.shape({
+      email: import_prop_types2.default.string,
+      id: import_prop_types2.default.string,
+      image: import_prop_types2.default.string,
+      name: import_prop_types2.default.string
+    })
+  }),
+  /**
+   * [Theme or themes](https://mui.com/toolpad/core/react-app-provider/#theming) to be used by the app in light/dark mode. A [CSS variables theme](https://mui.com/material-ui/customization/css-theme-variables/overview/) is recommended.
+   * @default createDefaultTheme()
+   */
+  theme: import_prop_types2.default.object,
+  /**
+   * The window where the application is rendered.
+   * This is needed when rendering the app inside an iframe, for example.
+   * @default window
+   */
+  window: import_prop_types2.default.object
+};
+
+// src/toolpad-core/nextjs/NextAppProviderApp.tsx
+var import_jsx_runtime7 = require("react/jsx-runtime");
+var Link = React11.forwardRef((props, ref) => {
+  const _a = props, { href, history } = _a, rest = __objRest(_a, ["href", "history"]);
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_link.default, __spreadValues({ ref, href, replace: history === "replace" }, rest));
+});
+function NextAppProviderApp(props) {
+  const pathname = (0, import_navigation.usePathname)();
+  const searchParams = (0, import_navigation.useSearchParams)();
+  const { push, replace } = (0, import_navigation.useRouter)();
+  const navigate = React11.useCallback(
+    (url, { history = "auto" } = {}) => {
+      if (history === "auto" || history === "push") {
+        return push(String(url));
+      }
+      if (history === "replace") {
+        return replace(String(url));
+      }
+      throw new Error(`Invalid history option: ${history}`);
+    },
+    [push, replace]
+  );
+  const routerImpl = React11.useMemo(
+    () => ({
+      pathname,
+      searchParams,
+      navigate,
+      Link
+    }),
+    [pathname, navigate, searchParams]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(AppProvider, __spreadValues({ router: routerImpl }, props));
+}
+
+// src/toolpad-core/nextjs/NextAppProviderPages.tsx
+var React12 = __toESM(require("react"));
+var import_link2 = __toESM(require("next/link.js"));
+var import_router = require("next/router.js");
+
+// src/toolpad-utils/collections.ts
+function asArray(maybeArray) {
+  return Array.isArray(maybeArray) ? maybeArray : [maybeArray];
+}
+
+// src/toolpad-core/nextjs/NextAppProviderPages.tsx
+var import_jsx_runtime8 = require("react/jsx-runtime");
+var Link2 = React12.forwardRef((props, ref) => {
+  const _a = props, { href, history } = _a, rest = __objRest(_a, ["href", "history"]);
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_link2.default, __spreadValues({ ref, href, replace: history === "replace" }, rest));
+});
+function NextAppProviderPages(props) {
+  const { push, replace, asPath, query } = (0, import_router.useRouter)();
+  const search = React12.useMemo(() => {
+    const params = new URLSearchParams();
+    Object.entries(query != null ? query : {}).forEach(([key, value]) => {
+      asArray(value != null ? value : []).forEach((v) => {
+        params.append(key, v);
+      });
+    });
+    return params.toString();
+  }, [query]);
+  const searchParams = React12.useMemo(() => new URLSearchParams(search), [search]);
+  const navigate = React12.useCallback(
+    (url, { history = "auto" } = {}) => {
+      if (history === "auto" || history === "push") {
+        return push(String(url));
+      }
+      if (history === "replace") {
+        return replace(String(url));
+      }
+      throw new Error(`Invalid history option: ${history}`);
+    },
+    [push, replace]
+  );
+  const routerImpl = React12.useMemo(
+    () => ({
+      pathname: asPath.split("?")[0],
+      searchParams,
+      navigate,
+      Link: Link2
+    }),
+    [asPath, navigate, searchParams]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(AppProvider, __spreadValues({ router: routerImpl }, props));
+}
+
+// src/toolpad-core/nextjs/NextAppProvider.tsx
+var import_jsx_runtime9 = require("react/jsx-runtime");
+function NextAppProvider(props) {
+  const router = (0, import_router2.useRouter)();
+  const AppProvider2 = router ? NextAppProviderPages : NextAppProviderApp;
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(AppProvider2, __spreadValues({}, props));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NextAppProvider
+});