@everysk/apps-sdk 0.1.0-beta.0

package/dist/components/ui/Toolbar/index.js

@@ -0,0 +1,32 @@
+import { EveryskIcon } from "../EveryskIcon/index.js";
+import { useTheme } from "@mui/material/styles";
+import { jsx, jsxs } from "react/jsx-runtime";
+import clsx$1 from "clsx";
+import AppBar from "@mui/material/AppBar";
+import MuiToolbar from "@mui/material/Toolbar";
+//#region src/components/ui/Toolbar/index.tsx
+var Toolbar = ({ children, className }) => {
+	const theme = useTheme();
+	return /* @__PURE__ */ jsx(AppBar, {
+		position: "relative",
+		...{
+			light: {
+				color: "transparent",
+				elevation: 0,
+				sx: { border: "1px solid rgba(0, 0, 0, 0.12)" }
+			},
+			dark: {
+				color: "default",
+				elevation: 1
+			}
+		}[theme.palette.mode],
+		children: /* @__PURE__ */ jsx(MuiToolbar, { children: /* @__PURE__ */ jsxs("div", {
+			className: clsx$1("flex items-center gap-4", className),
+			children: [/* @__PURE__ */ jsx(EveryskIcon, {}), children]
+		}) })
+	});
+};
+//#endregion
+export { Toolbar };
+
+//# sourceMappingURL=index.js.map

package/dist/components/ui/Toolbar/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../src/components/ui/Toolbar/index.tsx"],"sourcesContent":["import type { PropsWithChildren } from 'react';\n\nimport AppBar from '@mui/material/AppBar';\nimport { useTheme, type Theme } from '@mui/material/styles';\nimport MuiToolbar from '@mui/material/Toolbar';\n\nimport clsx from 'clsx';\n\nimport { EveryskIcon } from '@/components/ui/EveryskIcon';\n\nimport type { AnyRecord } from '@/types/anyRecord';\n\nexport const Toolbar = ({ children, className }: PropsWithChildren<{ className?: string }>) => {\n    const theme: Theme = useTheme();\n\n    const styles: AnyRecord = {\n        light: {\n            color: 'transparent',\n            elevation: 0,\n            sx: {\n                border: \"1px solid rgba(0, 0, 0, 0.12)\"\n            }\n        },\n        dark: {\n            // 'default', not ''. An empty string is not a value the AppBar API takes — it\n            // produced the class `MuiAppBar-color` with no variant suffix, which rendered the\n            // same only because the brand theme overrides AppBar anyway. This is the explicit\n            // spelling of what already happens, and it survives a theme that does not.\n            color: 'default',\n            elevation: 1\n        }\n    };\n\n    return (\n        <AppBar position='relative' {...styles?.[theme.palette.mode]}>\n            <MuiToolbar >\n                <div className={clsx(\"flex items-center gap-4\", className)}>\n                    <EveryskIcon />\n                    {children}\n                </div>\n            </MuiToolbar>\n        </AppBar>\n    );\n}\n"],"mappings":";;;;;;;AAYA,IAAa,WAAW,EAAE,UAAU,gBAA2D;CAC3F,MAAM,QAAe,SAAS;CAoB9B,OACI,oBAAC,QAAD;EAAQ,UAAS;EAAW,GAAI;GAlBhC,OAAO;IACH,OAAO;IACP,WAAW;IACX,IAAI,EACA,QAAQ,gCACZ;GACJ;GACA,MAAM;IAKF,OAAO;IACP,WAAW;GACf;EAIgC,EAAS,MAAM,QAAQ;EACnD,UAAA,oBAAC,YAAD,EAAA,UACI,qBAAC,OAAD;GAAK,WAAW,OAAK,2BAA2B,SAAS;GAAzD,UAAA,CACI,oBAAC,aAAD,CAAc,CAAA,GACb,QACA;EACG,CAAA,EAAA,CAAA;CACR,CAAA;AAEhB"}

package/dist/contexts/agGridLicenseContext/provider.d.ts

@@ -0,0 +1,51 @@
+import { type PropsWithChildren } from "react";
+/**
+ * setAgGridLicense
+ *
+ * Registers the AG Grid Enterprise license. A no-op when the key is missing or empty, so an
+ * app that has not configured one degrades to the watermark instead of throwing.
+ *
+ * The key is a **parameter**, not something this package reads from the environment. The
+ * template read `import.meta.env.VITE_AG_GRID_LICENSE_KEY` at module scope, which works
+ * inside an app and silently breaks inside a published package: Vite replaces
+ * `import.meta.env.VITE_*` with a literal at the build of whoever compiles the file, so the
+ * value would freeze to whatever the SDK's own CI had — nothing — and the consuming app's
+ * environment would never reach it. No build error, no runtime error, just the watermark.
+ *
+ * The app keeps ownership of its own environment:
+ *
+ * ```ts
+ * // src/main.tsx
+ * setAgGridLicense(import.meta.env.VITE_AG_GRID_LICENSE_KEY);
+ * ```
+ *
+ * @param {string} [licenseKey] - The license key, typically from the app's build environment.
+ */
+export declare const setAgGridLicense: (licenseKey?: string) => void;
+export type AgGridLicenseProviderProps = PropsWithChildren<{
+    /** The license key. Omitted or empty, the provider only renders its children. */
+    licenseKey?: string;
+}>;
+/**
+ * AgGridLicenseProvider
+ *
+ * Provider form of `setAgGridLicense`, for apps that would rather configure the license in
+ * the component tree than at bootstrap. It holds no context — it registers the key and
+ * renders its children.
+ *
+ * The registration happens in the render body rather than in an effect on purpose: AG Grid
+ * reads the license when a grid first renders, and an effect runs *after* that commit, so a
+ * grid mounted in the same commit would flash the watermark. React renders a parent's body
+ * before its children, which is exactly the ordering needed here. `setLicenseKey` is an
+ * idempotent setter on a module global, so StrictMode's double render is harmless.
+ *
+ * ```tsx
+ * <EveryskApp>
+ *   <AgGridLicenseProvider licenseKey={import.meta.env.VITE_AG_GRID_LICENSE_KEY}>
+ *     <Routes />
+ *   </AgGridLicenseProvider>
+ * </EveryskApp>
+ * ```
+ */
+export declare const AgGridLicenseProvider: ({ children, licenseKey }: AgGridLicenseProviderProps) => import("react").JSX.Element;
+//# sourceMappingURL=provider.d.ts.map

package/dist/contexts/agGridLicenseContext/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../src/contexts/agGridLicenseContext/provider.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,OAAO,CAAC;AAI/C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,gBAAgB,GAAI,aAAa,MAAM,KAAG,IAItD,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG,iBAAiB,CAAC;IACvD,iFAAiF;IACjF,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,qBAAqB,GAAI,0BAA0B,0BAA0B,gCAIzF,CAAC"}

package/dist/contexts/agGridLicenseContext/provider.js

@@ -0,0 +1,58 @@
+import "react";
+import { Fragment, jsx } from "react/jsx-runtime";
+import { LicenseManager } from "ag-grid-enterprise";
+//#region src/contexts/agGridLicenseContext/provider.tsx
+/**
+* setAgGridLicense
+*
+* Registers the AG Grid Enterprise license. A no-op when the key is missing or empty, so an
+* app that has not configured one degrades to the watermark instead of throwing.
+*
+* The key is a **parameter**, not something this package reads from the environment. The
+* template read `import.meta.env.VITE_AG_GRID_LICENSE_KEY` at module scope, which works
+* inside an app and silently breaks inside a published package: Vite replaces
+* `import.meta.env.VITE_*` with a literal at the build of whoever compiles the file, so the
+* value would freeze to whatever the SDK's own CI had — nothing — and the consuming app's
+* environment would never reach it. No build error, no runtime error, just the watermark.
+*
+* The app keeps ownership of its own environment:
+*
+* ```ts
+* // src/main.tsx
+* setAgGridLicense(import.meta.env.VITE_AG_GRID_LICENSE_KEY);
+* ```
+*
+* @param {string} [licenseKey] - The license key, typically from the app's build environment.
+*/
+var setAgGridLicense = (licenseKey) => {
+	if (typeof licenseKey === "string" && licenseKey) LicenseManager.setLicenseKey(licenseKey);
+};
+/**
+* AgGridLicenseProvider
+*
+* Provider form of `setAgGridLicense`, for apps that would rather configure the license in
+* the component tree than at bootstrap. It holds no context — it registers the key and
+* renders its children.
+*
+* The registration happens in the render body rather than in an effect on purpose: AG Grid
+* reads the license when a grid first renders, and an effect runs *after* that commit, so a
+* grid mounted in the same commit would flash the watermark. React renders a parent's body
+* before its children, which is exactly the ordering needed here. `setLicenseKey` is an
+* idempotent setter on a module global, so StrictMode's double render is harmless.
+*
+* ```tsx
+* <EveryskApp>
+*   <AgGridLicenseProvider licenseKey={import.meta.env.VITE_AG_GRID_LICENSE_KEY}>
+*     <Routes />
+*   </AgGridLicenseProvider>
+* </EveryskApp>
+* ```
+*/
+var AgGridLicenseProvider = ({ children, licenseKey }) => {
+	setAgGridLicense(licenseKey);
+	return /* @__PURE__ */ jsx(Fragment, { children });
+};
+//#endregion
+export { AgGridLicenseProvider, setAgGridLicense };
+
+//# sourceMappingURL=provider.js.map

package/dist/contexts/agGridLicenseContext/provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.js","names":[],"sources":["../../../src/contexts/agGridLicenseContext/provider.tsx"],"sourcesContent":["import { type PropsWithChildren } from \"react\";\n\nimport { LicenseManager } from \"ag-grid-enterprise\";\n\n/**\n * setAgGridLicense\n *\n * Registers the AG Grid Enterprise license. A no-op when the key is missing or empty, so an\n * app that has not configured one degrades to the watermark instead of throwing.\n *\n * The key is a **parameter**, not something this package reads from the environment. The\n * template read `import.meta.env.VITE_AG_GRID_LICENSE_KEY` at module scope, which works\n * inside an app and silently breaks inside a published package: Vite replaces\n * `import.meta.env.VITE_*` with a literal at the build of whoever compiles the file, so the\n * value would freeze to whatever the SDK's own CI had — nothing — and the consuming app's\n * environment would never reach it. No build error, no runtime error, just the watermark.\n *\n * The app keeps ownership of its own environment:\n *\n * ```ts\n * // src/main.tsx\n * setAgGridLicense(import.meta.env.VITE_AG_GRID_LICENSE_KEY);\n * ```\n *\n * @param {string} [licenseKey] - The license key, typically from the app's build environment.\n */\nexport const setAgGridLicense = (licenseKey?: string): void => {\n    if (typeof licenseKey === \"string\" && licenseKey) {\n        LicenseManager.setLicenseKey(licenseKey);\n    }\n};\n\nexport type AgGridLicenseProviderProps = PropsWithChildren<{\n    /** The license key. Omitted or empty, the provider only renders its children. */\n    licenseKey?: string;\n}>;\n\n/**\n * AgGridLicenseProvider\n *\n * Provider form of `setAgGridLicense`, for apps that would rather configure the license in\n * the component tree than at bootstrap. It holds no context — it registers the key and\n * renders its children.\n *\n * The registration happens in the render body rather than in an effect on purpose: AG Grid\n * reads the license when a grid first renders, and an effect runs *after* that commit, so a\n * grid mounted in the same commit would flash the watermark. React renders a parent's body\n * before its children, which is exactly the ordering needed here. `setLicenseKey` is an\n * idempotent setter on a module global, so StrictMode's double render is harmless.\n *\n * ```tsx\n * <EveryskApp>\n *   <AgGridLicenseProvider licenseKey={import.meta.env.VITE_AG_GRID_LICENSE_KEY}>\n *     <Routes />\n *   </AgGridLicenseProvider>\n * </EveryskApp>\n * ```\n */\nexport const AgGridLicenseProvider = ({ children, licenseKey }: AgGridLicenseProviderProps) => {\n    setAgGridLicense(licenseKey);\n\n    return <>{children}</>;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,IAAa,oBAAoB,eAA8B;CAC3D,IAAI,OAAO,eAAe,YAAY,YAClC,eAAe,cAAc,UAAU;AAE/C;;;;;;;;;;;;;;;;;;;;;;AA4BA,IAAa,yBAAyB,EAAE,UAAU,iBAA6C;CAC3F,iBAAiB,UAAU;CAE3B,OAAO,oBAAA,UAAA,EAAG,SAAW,CAAA;AACzB"}

package/dist/contexts/appAlertContext/index.d.ts

@@ -0,0 +1,3 @@
+import type { AppAlertContextType } from "./types";
+export declare const AppAlertContext: import("react").Context<AppAlertContextType | null>;
+//# sourceMappingURL=index.d.ts.map

package/dist/contexts/appAlertContext/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/contexts/appAlertContext/index.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAEnD,eAAO,MAAM,eAAe,qDAAkD,CAAC"}

package/dist/contexts/appAlertContext/index.js

@@ -0,0 +1,7 @@
+import { createContext } from "react";
+//#region src/contexts/appAlertContext/index.tsx
+var AppAlertContext = createContext(null);
+//#endregion
+export { AppAlertContext };
+
+//# sourceMappingURL=index.js.map

package/dist/contexts/appAlertContext/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/contexts/appAlertContext/index.tsx"],"sourcesContent":["import { createContext } from \"react\";\nimport type { AppAlertContextType } from \"./types\";\n\nexport const AppAlertContext = createContext<AppAlertContextType | null>(null);\n"],"mappings":";;AAGA,IAAa,kBAAkB,cAA0C,IAAI"}

package/dist/contexts/appAlertContext/provider.d.ts

@@ -0,0 +1,40 @@
+import { type PropsWithChildren } from "react";
+/**
+ * AppAlertProvider
+ *
+ * React context provider responsible for exposing a global application alert API and rendering
+ * a Material UI `Snackbar` + `Alert` pair anchored to the viewport.
+ *
+ * What this provider does:
+ * - Maintains an internal `AppAlertState` that controls:
+ *   - visibility (`open`)
+ *   - displayed text (`message`)
+ *   - alert tone (`severity`)
+ *   - auto-dismiss timing (`autoHideDuration`)
+ *   - screen position (`anchorOrigin`)
+ * - Exposes an imperative API via context:
+ *   - `showAlert(options)` to open/update the alert
+ *   - `hideAlert()` to close the alert
+ * - Renders the `Snackbar`/`Alert` components once (at the provider level), so any descendant can
+ *   trigger alerts without needing to manage UI state locally.
+ *
+ * Behavior:
+ * - `showAlert(options)` performs a shallow merge of the provided options into the current state
+ *   and forces `open: true`.
+ * - `hideAlert()` sets `open: false` (preserving the remaining state).
+ * - Snackbar `onClose` ignores the `"clickaway"` reason to prevent accidental dismissals when the user
+ *   clicks outside the toast.
+ *
+ * Performance / stability:
+ * - `showAlert` and `hideAlert` should be stable (e.g., created with `useCallback`) so the context value
+ *   does not change on every render, avoiding unnecessary re-renders in consumers.
+ *
+ * Usage:
+ * ```ts
+ * <AppAlertProvider>
+ *   <App />
+ * </AppAlertProvider>
+ * ```
+ */
+export declare const AppAlertProvider: ({ children }: PropsWithChildren) => import("react").JSX.Element;
+//# sourceMappingURL=provider.d.ts.map

package/dist/contexts/appAlertContext/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../src/contexts/appAlertContext/provider.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAkC,KAAK,iBAAiB,EAAE,MAAM,OAAO,CAAC;AAO/E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,eAAO,MAAM,gBAAgB,GAAI,cAAc,iBAAiB,gCA8C/D,CAAC"}

package/dist/contexts/appAlertContext/provider.js

@@ -0,0 +1,96 @@
+import { AppAlertContext } from "./index.js";
+import { useCallback, useMemo, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import Alert from "@mui/material/Alert";
+import Snackbar from "@mui/material/Snackbar";
+//#region src/contexts/appAlertContext/provider.tsx
+/**
+* AppAlertProvider
+*
+* React context provider responsible for exposing a global application alert API and rendering
+* a Material UI `Snackbar` + `Alert` pair anchored to the viewport.
+*
+* What this provider does:
+* - Maintains an internal `AppAlertState` that controls:
+*   - visibility (`open`)
+*   - displayed text (`message`)
+*   - alert tone (`severity`)
+*   - auto-dismiss timing (`autoHideDuration`)
+*   - screen position (`anchorOrigin`)
+* - Exposes an imperative API via context:
+*   - `showAlert(options)` to open/update the alert
+*   - `hideAlert()` to close the alert
+* - Renders the `Snackbar`/`Alert` components once (at the provider level), so any descendant can
+*   trigger alerts without needing to manage UI state locally.
+*
+* Behavior:
+* - `showAlert(options)` performs a shallow merge of the provided options into the current state
+*   and forces `open: true`.
+* - `hideAlert()` sets `open: false` (preserving the remaining state).
+* - Snackbar `onClose` ignores the `"clickaway"` reason to prevent accidental dismissals when the user
+*   clicks outside the toast.
+*
+* Performance / stability:
+* - `showAlert` and `hideAlert` should be stable (e.g., created with `useCallback`) so the context value
+*   does not change on every render, avoiding unnecessary re-renders in consumers.
+*
+* Usage:
+* ```ts
+* <AppAlertProvider>
+*   <App />
+* </AppAlertProvider>
+* ```
+*/
+var AppAlertProvider = ({ children }) => {
+	const [state, setState] = useState({
+		open: false,
+		message: "",
+		severity: "info",
+		autoHideDuration: 4e3,
+		anchorOrigin: {
+			vertical: "bottom",
+			horizontal: "right"
+		}
+	});
+	const hideAlert = useCallback(() => {
+		setState((prev) => ({
+			...prev,
+			open: false
+		}));
+	}, []);
+	const showAlert = useCallback((options) => {
+		setState((prev) => ({
+			...prev,
+			...options,
+			open: true
+		}));
+	}, []);
+	const value = useMemo(() => ({
+		showAlert,
+		hideAlert
+	}), [showAlert, hideAlert]);
+	return /* @__PURE__ */ jsxs(AppAlertContext.Provider, {
+		value,
+		children: [children, /* @__PURE__ */ jsx(Snackbar, {
+			open: state.open,
+			message: state.message,
+			autoHideDuration: state.autoHideDuration,
+			anchorOrigin: state.anchorOrigin,
+			onClose: (_, reason) => {
+				if (reason === "clickaway") return;
+				hideAlert();
+			},
+			children: /* @__PURE__ */ jsx(Alert, {
+				onClose: hideAlert,
+				severity: state.severity,
+				variant: "filled",
+				elevation: 6,
+				children: state.message
+			})
+		})]
+	});
+};
+//#endregion
+export { AppAlertProvider };
+
+//# sourceMappingURL=provider.js.map

package/dist/contexts/appAlertContext/provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.js","names":[],"sources":["../../../src/contexts/appAlertContext/provider.tsx"],"sourcesContent":["import { useCallback, useMemo, useState, type PropsWithChildren } from \"react\";\nimport Alert from \"@mui/material/Alert\";\nimport Snackbar, { type SnackbarCloseReason } from \"@mui/material/Snackbar\";\n\nimport { AppAlertContext } from \".\";\nimport type { AppAlertContextType, AppAlertState, ShowAlertOptions } from \"./types\";\n\n/**\n * AppAlertProvider\n *\n * React context provider responsible for exposing a global application alert API and rendering\n * a Material UI `Snackbar` + `Alert` pair anchored to the viewport.\n *\n * What this provider does:\n * - Maintains an internal `AppAlertState` that controls:\n *   - visibility (`open`)\n *   - displayed text (`message`)\n *   - alert tone (`severity`)\n *   - auto-dismiss timing (`autoHideDuration`)\n *   - screen position (`anchorOrigin`)\n * - Exposes an imperative API via context:\n *   - `showAlert(options)` to open/update the alert\n *   - `hideAlert()` to close the alert\n * - Renders the `Snackbar`/`Alert` components once (at the provider level), so any descendant can\n *   trigger alerts without needing to manage UI state locally.\n *\n * Behavior:\n * - `showAlert(options)` performs a shallow merge of the provided options into the current state\n *   and forces `open: true`.\n * - `hideAlert()` sets `open: false` (preserving the remaining state).\n * - Snackbar `onClose` ignores the `\"clickaway\"` reason to prevent accidental dismissals when the user\n *   clicks outside the toast.\n *\n * Performance / stability:\n * - `showAlert` and `hideAlert` should be stable (e.g., created with `useCallback`) so the context value\n *   does not change on every render, avoiding unnecessary re-renders in consumers.\n *\n * Usage:\n * ```ts\n * <AppAlertProvider>\n *   <App />\n * </AppAlertProvider>\n * ```\n */\n\nexport const AppAlertProvider = ({ children }: PropsWithChildren) => {\n    const [state, setState] = useState<AppAlertState>({\n        open: false,\n        message: \"\",\n        severity: \"info\",\n        autoHideDuration: 4000,\n        anchorOrigin: { vertical: \"bottom\", horizontal: \"right\" },\n    });\n\n    const hideAlert = useCallback(() => {\n        setState((prev) => ({ ...prev, open: false }));\n    }, []);\n\n    const showAlert = useCallback((options: ShowAlertOptions) => {\n        setState((prev) => ({\n            ...prev,\n            ...options,\n            open: true,\n        }));\n    }, []);\n\n    const value: AppAlertContextType = useMemo(\n        () => ({ showAlert, hideAlert }),\n        [showAlert, hideAlert]\n    );\n\n    return (\n        <AppAlertContext.Provider value={value}>\n            {children}\n\n            <Snackbar\n                open={state.open}\n                message={state.message}\n                autoHideDuration={state.autoHideDuration}\n                anchorOrigin={state.anchorOrigin}\n                onClose={(_, reason: SnackbarCloseReason) => {\n                    if (reason === \"clickaway\") return;\n                    hideAlert();\n                }}\n            >\n                <Alert onClose={hideAlert} severity={state.severity} variant=\"filled\" elevation={6}>\n                    {state.message}\n                </Alert>\n            </Snackbar>\n        </AppAlertContext.Provider>\n    );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CA,IAAa,oBAAoB,EAAE,eAAkC;CACjE,MAAM,CAAC,OAAO,YAAY,SAAwB;EAC9C,MAAM;EACN,SAAS;EACT,UAAU;EACV,kBAAkB;EAClB,cAAc;GAAE,UAAU;GAAU,YAAY;EAAQ;CAC5D,CAAC;CAED,MAAM,YAAY,kBAAkB;EAChC,UAAU,UAAU;GAAE,GAAG;GAAM,MAAM;EAAM,EAAE;CACjD,GAAG,CAAC,CAAC;CAEL,MAAM,YAAY,aAAa,YAA8B;EACzD,UAAU,UAAU;GAChB,GAAG;GACH,GAAG;GACH,MAAM;EACV,EAAE;CACN,GAAG,CAAC,CAAC;CAEL,MAAM,QAA6B,eACxB;EAAE;EAAW;CAAU,IAC9B,CAAC,WAAW,SAAS,CACzB;CAEA,OACI,qBAAC,gBAAgB,UAAjB;EAAiC;EAAjC,UAAA,CACK,UAED,oBAAC,UAAD;GACI,MAAM,MAAM;GACZ,SAAS,MAAM;GACf,kBAAkB,MAAM;GACxB,cAAc,MAAM;GACpB,UAAU,GAAG,WAAgC;IACzC,IAAI,WAAW,aAAa;IAC5B,UAAU;GACd;GAEA,UAAA,oBAAC,OAAD;IAAO,SAAS;IAAW,UAAU,MAAM;IAAU,SAAQ;IAAS,WAAW;IAC5E,UAAA,MAAM;GACJ,CAAA;EACD,CAAA,CACY;;AAElC"}

package/dist/contexts/appAlertContext/types.d.ts

@@ -0,0 +1,15 @@
+import type { AlertColor } from "@mui/material/Alert";
+import type { SnackbarProps } from "@mui/material/Snackbar";
+export type AppAlertState = Omit<SnackbarProps, "open" | "onClose" | "message"> & {
+    open: boolean;
+    message: string;
+    severity: AlertColor;
+};
+export type ShowAlertOptions = Partial<Omit<AppAlertState, "open">> & {
+    message: string;
+};
+export type AppAlertContextType = {
+    showAlert: (options: ShowAlertOptions) => void;
+    hideAlert: () => void;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/contexts/appAlertContext/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/contexts/appAlertContext/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAE5D,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC,aAAa,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAAC,GAAG;IAC9E,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,UAAU,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC,GAAG;IAClE,OAAO,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,SAAS,EAAE,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAC/C,SAAS,EAAE,MAAM,IAAI,CAAC;CACvB,CAAC"}

package/dist/contexts/appAlertContext/useAppAlert.d.ts

@@ -0,0 +1,30 @@
+/**
+ * useAppAlert
+ *
+ * Convenience hook that reads the alert API from `AppAlertContext`.
+ *
+ * Behavior:
+ * - Returns the functions exposed by `<AppAlertProvider>`, typically:
+ *   - `showAlert(options)` to display an alert
+ *   - `hideAlert()` to close the current alert
+ *
+ * Error handling:
+ * - Throws a descriptive error if called outside of an `<AppAlertProvider>` scope, to fail fast
+ *   and prevent silent no-op alert calls.
+ *
+ * Usage:
+ * ```ts
+ * const { showAlert } = useAppAlert();
+ *
+ * showAlert({
+ *   message: "Saved successfully.",
+ *   severity: "success",
+ *   autoHideDuration: 3000,
+ * });
+ * ```
+ *
+ * @throws {Error}
+ *  Throws if the hook is used outside of `<AppAlertProvider>`.
+ */
+export declare const useAppAlert: () => import("./types").AppAlertContextType;
+//# sourceMappingURL=useAppAlert.d.ts.map

package/dist/contexts/appAlertContext/useAppAlert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAppAlert.d.ts","sourceRoot":"","sources":["../../../src/contexts/appAlertContext/useAppAlert.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,eAAO,MAAM,WAAW,6CAMvB,CAAC"}

package/dist/contexts/appAlertContext/useAppAlert.js

@@ -0,0 +1,40 @@
+import { AppAlertContext } from "./index.js";
+import { useContext } from "react";
+//#region src/contexts/appAlertContext/useAppAlert.ts
+/**
+* useAppAlert
+*
+* Convenience hook that reads the alert API from `AppAlertContext`.
+*
+* Behavior:
+* - Returns the functions exposed by `<AppAlertProvider>`, typically:
+*   - `showAlert(options)` to display an alert
+*   - `hideAlert()` to close the current alert
+*
+* Error handling:
+* - Throws a descriptive error if called outside of an `<AppAlertProvider>` scope, to fail fast
+*   and prevent silent no-op alert calls.
+*
+* Usage:
+* ```ts
+* const { showAlert } = useAppAlert();
+*
+* showAlert({
+*   message: "Saved successfully.",
+*   severity: "success",
+*   autoHideDuration: 3000,
+* });
+* ```
+*
+* @throws {Error}
+*  Throws if the hook is used outside of `<AppAlertProvider>`.
+*/
+var useAppAlert = () => {
+	const ctx = useContext(AppAlertContext);
+	if (!ctx) throw new Error("useAppAlert must be used within <AppAlertProvider>.");
+	return ctx;
+};
+//#endregion
+export { useAppAlert };
+
+//# sourceMappingURL=useAppAlert.js.map

package/dist/contexts/appAlertContext/useAppAlert.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAppAlert.js","names":[],"sources":["../../../src/contexts/appAlertContext/useAppAlert.ts"],"sourcesContent":["import { useContext } from \"react\";\nimport { AppAlertContext } from \".\";\n\n/**\n * useAppAlert\n *\n * Convenience hook that reads the alert API from `AppAlertContext`.\n *\n * Behavior:\n * - Returns the functions exposed by `<AppAlertProvider>`, typically:\n *   - `showAlert(options)` to display an alert\n *   - `hideAlert()` to close the current alert\n *\n * Error handling:\n * - Throws a descriptive error if called outside of an `<AppAlertProvider>` scope, to fail fast\n *   and prevent silent no-op alert calls.\n *\n * Usage:\n * ```ts\n * const { showAlert } = useAppAlert();\n *\n * showAlert({\n *   message: \"Saved successfully.\",\n *   severity: \"success\",\n *   autoHideDuration: 3000,\n * });\n * ```\n *\n * @throws {Error}\n *  Throws if the hook is used outside of `<AppAlertProvider>`.\n */\n\nexport const useAppAlert = () => {\n    const ctx = useContext(AppAlertContext);\n    if (!ctx) {\n        throw new Error(\"useAppAlert must be used within <AppAlertProvider>.\");\n    }\n    return ctx;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,IAAa,oBAAoB;CAC7B,MAAM,MAAM,WAAW,eAAe;CACtC,IAAI,CAAC,KACD,MAAM,IAAI,MAAM,qDAAqD;CAEzE,OAAO;AACX"}

package/dist/contexts/appConfigContext/index.d.ts

@@ -0,0 +1,3 @@
+import type { AppConfigContextType } from "./types";
+export declare const AppConfigContext: import("react").Context<AppConfigContextType | null>;
+//# sourceMappingURL=index.d.ts.map

package/dist/contexts/appConfigContext/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/contexts/appConfigContext/index.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEpD,eAAO,MAAM,gBAAgB,sDAAmD,CAAA"}

package/dist/contexts/appConfigContext/index.js

@@ -0,0 +1,7 @@
+import { createContext } from "react";
+//#region src/contexts/appConfigContext/index.tsx
+var AppConfigContext = createContext(null);
+//#endregion
+export { AppConfigContext };
+
+//# sourceMappingURL=index.js.map

package/dist/contexts/appConfigContext/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/contexts/appConfigContext/index.tsx"],"sourcesContent":["import { createContext } from \"react\";\nimport type { AppConfigContextType } from \"./types\";\n\nexport const AppConfigContext = createContext<AppConfigContextType | null>(null)\n"],"mappings":";;AAGA,IAAa,mBAAmB,cAA2C,IAAI"}

package/dist/contexts/appConfigContext/provider.d.ts

@@ -0,0 +1,45 @@
+import type { AppConfigProviderProps } from "./types";
+/**
+ * AppConfigProvider
+ *
+ * React context provider responsible for exposing the application's runtime configuration
+ * (`AppConfigContextType`) to the component tree.
+ *
+ * Configuration sources, in order of precedence:
+ *
+ * 1. The `appId` / `appEnvironmentVar` props.
+ *    Explicit injection, for tests and for hosts that resolve configuration themselves rather
+ *    than through the page globals. A prop wins over the corresponding global; passing
+ *    `appId={null}` forces "no app id" instead of falling through to `window.APP_ID`.
+ *
+ * 2. `window.APP_ID` and `window.APP_CONFIG`.
+ *    Injected into the page by the platform (from the app's `config.json` `env_vars`) before
+ *    the bundle executes.
+ *
+ * In dev there is no platform to inject them, so the app's dev server serves the `env_vars` at
+ * `/app-config.json` and the app merges them into `window.APP_CONFIG` during bootstrap, before
+ * React mounts. That merge is shallow and belongs to the app, not to this provider: nested
+ * objects are replaced whole, not deep-merged.
+ *
+ * Lifecycle notes:
+ * - This provider performs no network request and does not update its value after mount.
+ * - Because configuration is resolved before `createRoot(...).render(...)`, the tree receives a
+ *   consistent configuration from the first render.
+ *
+ * Example:
+ * ```tsx
+ * <AppConfigProvider>
+ *   <App />
+ * </AppConfigProvider>
+ *
+ * // In a test, with no page globals:
+ * <AppConfigProvider appId="app_42" appEnvironmentVar={{ API_URL: "/api" }}>
+ *   <ComponentUnderTest />
+ * </AppConfigProvider>
+ *
+ * // Consumer hook usage
+ * const { appId, appEnvironmentVar } = useAppConfig();
+ * ```
+ */
+export declare const AppConfigProvider: ({ children, appId, appEnvironmentVar, }: AppConfigProviderProps) => import("react").JSX.Element;
+//# sourceMappingURL=provider.d.ts.map

package/dist/contexts/appConfigContext/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../src/contexts/appConfigContext/provider.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAwB,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAE5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,iBAAiB,GAAI,yCAI/B,sBAAsB,gCAexB,CAAC"}

package/dist/contexts/appConfigContext/provider.js

@@ -0,0 +1,63 @@
+import { AppConfigContext } from "./index.js";
+import { useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/contexts/appConfigContext/provider.tsx
+/**
+* AppConfigProvider
+*
+* React context provider responsible for exposing the application's runtime configuration
+* (`AppConfigContextType`) to the component tree.
+*
+* Configuration sources, in order of precedence:
+*
+* 1. The `appId` / `appEnvironmentVar` props.
+*    Explicit injection, for tests and for hosts that resolve configuration themselves rather
+*    than through the page globals. A prop wins over the corresponding global; passing
+*    `appId={null}` forces "no app id" instead of falling through to `window.APP_ID`.
+*
+* 2. `window.APP_ID` and `window.APP_CONFIG`.
+*    Injected into the page by the platform (from the app's `config.json` `env_vars`) before
+*    the bundle executes.
+*
+* In dev there is no platform to inject them, so the app's dev server serves the `env_vars` at
+* `/app-config.json` and the app merges them into `window.APP_CONFIG` during bootstrap, before
+* React mounts. That merge is shallow and belongs to the app, not to this provider: nested
+* objects are replaced whole, not deep-merged.
+*
+* Lifecycle notes:
+* - This provider performs no network request and does not update its value after mount.
+* - Because configuration is resolved before `createRoot(...).render(...)`, the tree receives a
+*   consistent configuration from the first render.
+*
+* Example:
+* ```tsx
+* <AppConfigProvider>
+*   <App />
+* </AppConfigProvider>
+*
+* // In a test, with no page globals:
+* <AppConfigProvider appId="app_42" appEnvironmentVar={{ API_URL: "/api" }}>
+*   <ComponentUnderTest />
+* </AppConfigProvider>
+*
+* // Consumer hook usage
+* const { appId, appEnvironmentVar } = useAppConfig();
+* ```
+*/
+var AppConfigProvider = ({ children, appId, appEnvironmentVar }) => {
+	const value = useMemo(() => {
+		const globalConfig = globalThis.window?.APP_CONFIG ?? {};
+		return {
+			appId: appId !== void 0 ? appId : globalThis.window?.APP_ID ?? null,
+			appEnvironmentVar: appEnvironmentVar ?? globalConfig
+		};
+	}, [appId, appEnvironmentVar]);
+	return /* @__PURE__ */ jsx(AppConfigContext.Provider, {
+		value,
+		children
+	});
+};
+//#endregion
+export { AppConfigProvider };
+
+//# sourceMappingURL=provider.js.map

package/dist/contexts/appConfigContext/provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.js","names":[],"sources":["../../../src/contexts/appConfigContext/provider.tsx"],"sourcesContent":["import { useMemo } from \"react\";\n\nimport { AppConfigContext } from \".\";\nimport type { AppConfigContextType, AppConfigProviderProps } from \"./types\";\n\n/**\n * AppConfigProvider\n *\n * React context provider responsible for exposing the application's runtime configuration\n * (`AppConfigContextType`) to the component tree.\n *\n * Configuration sources, in order of precedence:\n *\n * 1. The `appId` / `appEnvironmentVar` props.\n *    Explicit injection, for tests and for hosts that resolve configuration themselves rather\n *    than through the page globals. A prop wins over the corresponding global; passing\n *    `appId={null}` forces \"no app id\" instead of falling through to `window.APP_ID`.\n *\n * 2. `window.APP_ID` and `window.APP_CONFIG`.\n *    Injected into the page by the platform (from the app's `config.json` `env_vars`) before\n *    the bundle executes.\n *\n * In dev there is no platform to inject them, so the app's dev server serves the `env_vars` at\n * `/app-config.json` and the app merges them into `window.APP_CONFIG` during bootstrap, before\n * React mounts. That merge is shallow and belongs to the app, not to this provider: nested\n * objects are replaced whole, not deep-merged.\n *\n * Lifecycle notes:\n * - This provider performs no network request and does not update its value after mount.\n * - Because configuration is resolved before `createRoot(...).render(...)`, the tree receives a\n *   consistent configuration from the first render.\n *\n * Example:\n * ```tsx\n * <AppConfigProvider>\n *   <App />\n * </AppConfigProvider>\n *\n * // In a test, with no page globals:\n * <AppConfigProvider appId=\"app_42\" appEnvironmentVar={{ API_URL: \"/api\" }}>\n *   <ComponentUnderTest />\n * </AppConfigProvider>\n *\n * // Consumer hook usage\n * const { appId, appEnvironmentVar } = useAppConfig();\n * ```\n */\nexport const AppConfigProvider = ({\n    children,\n    appId,\n    appEnvironmentVar,\n}: AppConfigProviderProps) => {\n    const value: AppConfigContextType = useMemo(() => {\n        const globalConfig = (globalThis.window?.APP_CONFIG ?? {}) as Record<string, unknown>;\n\n        return {\n            appId: appId !== undefined ? appId : (globalThis.window?.APP_ID ?? null),\n            appEnvironmentVar: appEnvironmentVar ?? globalConfig,\n        };\n    }, [appId, appEnvironmentVar]);\n\n    return (\n        <AppConfigContext.Provider value={value}>\n            {children}\n        </AppConfigContext.Provider>\n    );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA,IAAa,qBAAqB,EAC9B,UACA,OACA,wBAC0B;CAC1B,MAAM,QAA8B,cAAc;EAC9C,MAAM,eAAgB,WAAW,QAAQ,cAAc,CAAC;EAExD,OAAO;GACH,OAAO,UAAU,KAAA,IAAY,QAAS,WAAW,QAAQ,UAAU;GACnE,mBAAmB,qBAAqB;EAC5C;CACJ,GAAG,CAAC,OAAO,iBAAiB,CAAC;CAE7B,OACI,oBAAC,iBAAiB,UAAlB;EAAkC;EAC7B;CACsB,CAAA;AAEnC"}

package/dist/contexts/appConfigContext/types.d.ts

@@ -0,0 +1,28 @@
+import type { ReactNode } from "react";
+import type { AnyRecord } from "../../types/anyRecord.d.ts";
+/**
+ * The platform injects these into the host page before the bundle runs. Both are optional:
+ * this augmentation reaches every consumer of the package, and declaring them as required
+ * would be a lie in dev, where nothing injects them — `AppConfigProvider` itself has always
+ * read `window.APP_ID ?? null`.
+ */
+declare global {
+    interface Window {
+        APP_ID?: string;
+        APP_CONFIG?: {
+            [key: string]: unknown;
+        };
+    }
+}
+export type AppConfigContextType = {
+    appId: string | null;
+    appEnvironmentVar: AnyRecord;
+};
+export type AppConfigProviderProps = {
+    children?: ReactNode;
+    /** Overrides `window.APP_ID`. Pass `null` to force "no app id". */
+    appId?: string | null;
+    /** Overrides `window.APP_CONFIG` wholesale (not merged into it). */
+    appEnvironmentVar?: AnyRecord;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/contexts/appConfigContext/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/contexts/appConfigContext/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD;;;;;GAKG;AACH,OAAO,CAAC,MAAM,CAAC;IACX,UAAU,MAAM;QACZ,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,UAAU,CAAC,EAAE;YAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;SAAE,CAAC;KAC3C;CACJ;AAED,MAAM,MAAM,oBAAoB,GAAG;IAC/B,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,iBAAiB,EAAE,SAAS,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACjC,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,mEAAmE;IACnE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,oEAAoE;IACpE,iBAAiB,CAAC,EAAE,SAAS,CAAC;CACjC,CAAC"}

package/dist/contexts/appConfigContext/useAppConfig.d.ts

@@ -0,0 +1,20 @@
+/**
+ * useAppConfig
+ *
+ * Convenience hook that reads the current application configuration from `AppConfigContext`.
+ *
+ * Behavior:
+ * - Returns the `AppConfigContextType` value provided by `<AppConfigProvider>`.
+ * - Throws a descriptive error if called outside of an `<AppConfigProvider>` scope, to fail fast and
+ *   avoid undefined configuration usage throughout the app.
+ *
+ * Usage:
+ * ```ts
+ * const { appId, appEnvironmentVar } = useAppConfig();
+ * ```
+ *
+ * @throws {Error}
+ *  Throws if the hook is used outside of `<AppConfigProvider>`.
+ */
+export declare const useAppConfig: () => import("./types").AppConfigContextType;
+//# sourceMappingURL=useAppConfig.d.ts.map

package/dist/contexts/appConfigContext/useAppConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAppConfig.d.ts","sourceRoot":"","sources":["../../../src/contexts/appConfigContext/useAppConfig.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;GAiBG;AAEH,eAAO,MAAM,YAAY,8CAMxB,CAAC"}