@everysk/apps-sdk 0.1.0-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Everysk Technologies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,128 @@
+# @everysk/apps-sdk
+
+(C) Copyright 2026 EVERYSK TECHNOLOGIES
+
+The runtime an Everysk app bundles: the provider tree, the API layer, the entity hooks, the
+shared components and the MUI theme. Declared as a `dependency`.
+
+Part of [everysk/apps-sdk](https://github.com/everysk/apps-sdk), alongside
+[`@everysk/apps-devkit`](../apps-devkit) (build presets) and
+[`@everysk/apps-cli`](../apps-cli) (the `everysk-apps` bin).
+
+## Install
+
+```bash
+npm install @everysk/apps-sdk
+```
+
+`react`, `react-dom`, `@mui/material`, `@mui/x-date-pickers`, `@emotion/*`,
+`@tanstack/react-query` and `axios` are **required** peers — npm installs them with the package,
+and a version outside its range fails the install rather than giving the app a second copy. Two
+Reacts, two MUI theme contexts or two QueryClients break contexts silently: the provider writes
+to one object and the hook reads from the other.
+
+## The provider tree
+
+`EveryskApp` is the whole of an app's `App.tsx`:
+
+```tsx
+import { EveryskApp } from "@everysk/apps-sdk";
+
+import { Routes } from "./pages/routes";
+
+export function App() {
+  return (
+    <EveryskApp>
+      <Routes />
+    </EveryskApp>
+  );
+}
+```
+
+It composes four providers in a fixed order — Theme → AppConfig → QueryClient → AppAlert — and
+takes `providers` for the optional ones, applied innermost so each can read every core context.
+Owning the tree here is what makes adding a module an install and an import, rather than an edit
+to nested JSX in the right slot.
+
+| Prop | |
+|---|---|
+| `theme` | A MUI theme. Omitted, the app mounts the Everysk dark theme |
+| `queryClient` | Defaults to a fresh `createQueryClient()`, created once per mount |
+| `appId`, `appEnvironmentVar` | Override `window.APP_ID` / `window.APP_CONFIG`, for tests and hosts that resolve configuration themselves |
+| `providers` | Optional providers, mounted inside the core tree |
+
+## Entry points
+
+One entry holds everything whose dependencies are required peers — the contexts, the six entity
+slices, the UI components and the theme. A bundler drops what the app never imports: measured,
+importing one function through the root produces the same bytes as importing it from a dedicated
+subpath.
+
+Five subpaths remain, and each exists because what sits behind it carries an **optional** peer,
+which npm does not install for you:
+
+| Subpath | Optional peers |
+|---|---|
+| `/ag-grid` | `ag-grid-community`, `ag-grid-enterprise` |
+| `/socket` | `socket.io-client` |
+| `/test` | `@testing-library/*` |
+| `/test/mocks` | doubles for the optional peers above |
+| `/test/setup` | the vitest setup file to point `setupFiles` at |
+
+A bundler resolves a module before it can tree-shake it, so re-exporting the AG Grid layer from
+the root would fail to build in an app that never installed `ag-grid-*` — even one importing
+nothing but `createQueryClient`. The subpath is what makes the peer genuinely optional.
+
+## The AG Grid licence is a parameter
+
+```ts
+// src/main.tsx
+import { setAgGridLicense } from "@everysk/apps-sdk/ag-grid";
+
+setAgGridLicense(import.meta.env.VITE_AG_GRID_LICENSE_KEY);
+```
+
+This package never reads your environment. Vite replaces `import.meta.env.VITE_*` with a literal
+at the build of whoever compiles the file — for a published package that is this package's own
+CI, where the variable does not exist, so the value would freeze as `undefined` and your
+environment would never reach it. There is no build error and no runtime error; the only symptom
+is the AG Grid watermark.
+
+`getAgGridTheme(theme)` and `useAgGridTheme()` derive the grid's theme from the MUI palette, so
+any theme — including one the app creates — gets a matching grid without a second table of
+colours.
+
+## Testing an app against it
+
+```ts
+// vitest.config.ts — or use @everysk/apps-devkit/vitest, which sets this
+setupFiles: ["@everysk/apps-sdk/test/setup"];
+```
+
+```tsx
+import { renderWithProviders } from "@everysk/apps-sdk/test";
+
+renderWithProviders(<Home />, { appId: "app_42" });
+```
+
+`renderWithProviders` renders through `EveryskApp` itself rather than repeating the tree, so a
+test and the real app cannot see different contexts. Each render gets a fresh QueryClient with
+retries and caching off.
+
+`@everysk/apps-sdk/test/mocks` carries opt-in doubles for the optional peers: `ag-grid-react`
+(renders rows and cells as plain DOM, so assertions about the data still hold),
+`ag-grid-enterprise` (captures the registered licence, readable with `getAgGridLicenseKey()`)
+and `socket.io-client` (a fake socket driven with `getMockSocket()?.fire(event, payload)`).
+
+They are factories a test file hands to `vi.mock`, never applied from the setup file: each
+stands in for an optional peer, and `vi.mock` on a module that cannot be resolved fails the whole
+test file at transform time — so a setup-wide mock would break every suite in an app that never
+installed it.
+
+## Requirements
+
+Node 22 or newer, npm 12 or newer. npm 10 crashes resolving this package's workspace.
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

package/dist/EveryskApp.d.ts

@@ -0,0 +1,73 @@
+import { type ComponentType, type PropsWithChildren } from "react";
+import { type QueryClient } from "@tanstack/react-query";
+import type { AnyRecord } from "./types/anyRecord.d.ts";
+import type { Theme } from "@mui/material/styles";
+/** A provider is any component that renders its children. */
+export type ProviderComponent = ComponentType<PropsWithChildren>;
+export type EveryskAppProps = PropsWithChildren<{
+    /**
+     * The client every `useQuery` in the tree talks to. Defaults to a fresh
+     * `createQueryClient()` created once per mount. Pass one to seed the cache, to share it
+     * with code outside the tree, or to assert on it from a test.
+     */
+    queryClient?: QueryClient;
+    /** Overrides `window.APP_ID`. */
+    appId?: string | null;
+    /**
+     * The MUI theme. Omitted, the app gets the Everysk dark theme — see `ThemeProvider`.
+     */
+    theme?: Theme;
+    /** Overrides `window.APP_CONFIG` wholesale. */
+    appEnvironmentVar?: AnyRecord;
+    /**
+     * Optional providers, applied innermost — inside every core provider and directly around
+     * `children`, in array order, so the first entry is outermost of the group.
+     *
+     * They go innermost rather than into named slots because that is the only position from
+     * which a provider can read every core context (theme, app config, query client, alerts).
+     * `modules.json` kept an explicit `providerOrder` only because the app owned the tree and
+     * each module had to be hand-wired into the right slot; owning the tree here is what
+     * retires that contract.
+     */
+    providers?: ProviderComponent[];
+}>;
+/**
+ * EveryskApp
+ *
+ * The provider tree every Everysk app mounts, composed in one fixed order:
+ *
+ * ```
+ * ThemeProvider
+ *   AppConfigProvider
+ *     QueryClientProvider
+ *       AppAlertProvider
+ *         …providers
+ *           children
+ * ```
+ *
+ * The order is not arbitrary. `AppAlertProvider` renders MUI's `Snackbar`, so it must sit
+ * inside `ThemeProvider`; and `QueryClientProvider` sits inside `AppConfigProvider` because
+ * entity hooks build their Axios instance from `useAppConfig()`.
+ *
+ * `BroadcastChannelProvider` used to sit between theme and app configuration. It is gone: the
+ * optional socket layer supersedes it for cross-tab and server-push messaging (as
+ * `modules.json` already stated), and the one production path that still used it — app
+ * configuration arriving over the channel — was replaced by `window.APP_CONFIG`.
+ *
+ * `src/test/renderWithProviders` renders through this same component, so a test and the real
+ * app can never see different trees.
+ *
+ * @example
+ * ```tsx
+ * // src/App.tsx — the entire file
+ * export function App() {
+ *   return (
+ *     <EveryskApp>
+ *       <Routes />
+ *     </EveryskApp>
+ *   );
+ * }
+ * ```
+ */
+export declare const EveryskApp: ({ children, queryClient, theme, appId, appEnvironmentVar, providers, }: EveryskAppProps) => import("react").JSX.Element;
+//# sourceMappingURL=EveryskApp.d.ts.map

package/dist/EveryskApp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EveryskApp.d.ts","sourceRoot":"","sources":["../src/EveryskApp.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,aAAa,EAAE,KAAK,iBAAiB,EAAkB,MAAM,OAAO,CAAC;AAE5F,OAAO,EAAuB,KAAK,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAM9E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAElD,6DAA6D;AAC7D,MAAM,MAAM,iBAAiB,GAAG,aAAa,CAAC,iBAAiB,CAAC,CAAC;AAEjE,MAAM,MAAM,eAAe,GAAG,iBAAiB,CAAC;IAC5C;;;;OAIG;IACH,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,iCAAiC;IACjC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB;;OAEG;IACH,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,+CAA+C;IAC/C,iBAAiB,CAAC,EAAE,SAAS,CAAC;IAC9B;;;;;;;;;OASG;IACH,SAAS,CAAC,EAAE,iBAAiB,EAAE,CAAC;CACnC,CAAC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,UAAU,GAAI,wEAOxB,eAAe,gCAoBjB,CAAC"}

package/dist/EveryskApp.js

@@ -0,0 +1,66 @@
+import { ThemeProvider } from "./theme/ThemeProvider.js";
+import { AppConfigProvider } from "./contexts/appConfigContext/provider.js";
+import { AppAlertProvider } from "./contexts/appAlertContext/provider.js";
+import { createQueryClient } from "./lib/queryClient.js";
+import { useMemo } from "react";
+import { QueryClientProvider } from "@tanstack/react-query";
+import { jsx } from "react/jsx-runtime";
+//#region src/EveryskApp.tsx
+/**
+* EveryskApp
+*
+* The provider tree every Everysk app mounts, composed in one fixed order:
+*
+* ```
+* ThemeProvider
+*   AppConfigProvider
+*     QueryClientProvider
+*       AppAlertProvider
+*         …providers
+*           children
+* ```
+*
+* The order is not arbitrary. `AppAlertProvider` renders MUI's `Snackbar`, so it must sit
+* inside `ThemeProvider`; and `QueryClientProvider` sits inside `AppConfigProvider` because
+* entity hooks build their Axios instance from `useAppConfig()`.
+*
+* `BroadcastChannelProvider` used to sit between theme and app configuration. It is gone: the
+* optional socket layer supersedes it for cross-tab and server-push messaging (as
+* `modules.json` already stated), and the one production path that still used it — app
+* configuration arriving over the channel — was replaced by `window.APP_CONFIG`.
+*
+* `src/test/renderWithProviders` renders through this same component, so a test and the real
+* app can never see different trees.
+*
+* @example
+* ```tsx
+* // src/App.tsx — the entire file
+* export function App() {
+*   return (
+*     <EveryskApp>
+*       <Routes />
+*     </EveryskApp>
+*   );
+* }
+* ```
+*/
+var EveryskApp = ({ children, queryClient, theme, appId, appEnvironmentVar, providers }) => {
+	const fallbackQueryClient = useMemo(() => createQueryClient(), []);
+	const client = queryClient ?? fallbackQueryClient;
+	const wrapped = (providers ?? []).reduceRight((inner, Provider) => /* @__PURE__ */ jsx(Provider, { children: inner }), children);
+	return /* @__PURE__ */ jsx(ThemeProvider, {
+		theme,
+		children: /* @__PURE__ */ jsx(AppConfigProvider, {
+			appId,
+			appEnvironmentVar,
+			children: /* @__PURE__ */ jsx(QueryClientProvider, {
+				client,
+				children: /* @__PURE__ */ jsx(AppAlertProvider, { children: wrapped })
+			})
+		})
+	});
+};
+//#endregion
+export { EveryskApp };
+
+//# sourceMappingURL=EveryskApp.js.map

package/dist/EveryskApp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EveryskApp.js","names":[],"sources":["../src/EveryskApp.tsx"],"sourcesContent":["import { useMemo, type ComponentType, type PropsWithChildren, type ReactNode } from \"react\";\n\nimport { QueryClientProvider, type QueryClient } from \"@tanstack/react-query\";\n\nimport { ThemeProvider } from \"@/theme/ThemeProvider\";\nimport { AppConfigProvider } from \"@/contexts/appConfigContext/provider\";\nimport { AppAlertProvider } from \"@/contexts/appAlertContext/provider\";\nimport { createQueryClient } from \"@/lib/queryClient\";\nimport type { AnyRecord } from \"@/types/anyRecord\";\nimport type { Theme } from \"@mui/material/styles\";\n\n/** A provider is any component that renders its children. */\nexport type ProviderComponent = ComponentType<PropsWithChildren>;\n\nexport type EveryskAppProps = PropsWithChildren<{\n    /**\n     * The client every `useQuery` in the tree talks to. Defaults to a fresh\n     * `createQueryClient()` created once per mount. Pass one to seed the cache, to share it\n     * with code outside the tree, or to assert on it from a test.\n     */\n    queryClient?: QueryClient;\n    /** Overrides `window.APP_ID`. */\n    appId?: string | null;\n    /**\n     * The MUI theme. Omitted, the app gets the Everysk dark theme — see `ThemeProvider`.\n     */\n    theme?: Theme;\n    /** Overrides `window.APP_CONFIG` wholesale. */\n    appEnvironmentVar?: AnyRecord;\n    /**\n     * Optional providers, applied innermost — inside every core provider and directly around\n     * `children`, in array order, so the first entry is outermost of the group.\n     *\n     * They go innermost rather than into named slots because that is the only position from\n     * which a provider can read every core context (theme, app config, query client, alerts).\n     * `modules.json` kept an explicit `providerOrder` only because the app owned the tree and\n     * each module had to be hand-wired into the right slot; owning the tree here is what\n     * retires that contract.\n     */\n    providers?: ProviderComponent[];\n}>;\n\n/**\n * EveryskApp\n *\n * The provider tree every Everysk app mounts, composed in one fixed order:\n *\n * ```\n * ThemeProvider\n *   AppConfigProvider\n *     QueryClientProvider\n *       AppAlertProvider\n *         …providers\n *           children\n * ```\n *\n * The order is not arbitrary. `AppAlertProvider` renders MUI's `Snackbar`, so it must sit\n * inside `ThemeProvider`; and `QueryClientProvider` sits inside `AppConfigProvider` because\n * entity hooks build their Axios instance from `useAppConfig()`.\n *\n * `BroadcastChannelProvider` used to sit between theme and app configuration. It is gone: the\n * optional socket layer supersedes it for cross-tab and server-push messaging (as\n * `modules.json` already stated), and the one production path that still used it — app\n * configuration arriving over the channel — was replaced by `window.APP_CONFIG`.\n *\n * `src/test/renderWithProviders` renders through this same component, so a test and the real\n * app can never see different trees.\n *\n * @example\n * ```tsx\n * // src/App.tsx — the entire file\n * export function App() {\n *   return (\n *     <EveryskApp>\n *       <Routes />\n *     </EveryskApp>\n *   );\n * }\n * ```\n */\nexport const EveryskApp = ({\n    children,\n    queryClient,\n    theme,\n    appId,\n    appEnvironmentVar,\n    providers,\n}: EveryskAppProps) => {\n    // Only used when the caller passes no client. Created once per mount so a re-render\n    // never swaps the cache out from under the tree.\n    const fallbackQueryClient = useMemo(() => createQueryClient(), []);\n    const client = queryClient ?? fallbackQueryClient;\n\n    const wrapped = (providers ?? []).reduceRight<ReactNode>(\n        (inner, Provider) => <Provider>{inner}</Provider>,\n        children,\n    );\n\n    return (\n        <ThemeProvider theme={theme}>\n            <AppConfigProvider appId={appId} appEnvironmentVar={appEnvironmentVar}>\n                <QueryClientProvider client={client}>\n                    <AppAlertProvider>{wrapped}</AppAlertProvider>\n                </QueryClientProvider>\n            </AppConfigProvider>\n        </ThemeProvider>\n    );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgFA,IAAa,cAAc,EACvB,UACA,aACA,OACA,OACA,mBACA,gBACmB;CAGnB,MAAM,sBAAsB,cAAc,kBAAkB,GAAG,CAAC,CAAC;CACjE,MAAM,SAAS,eAAe;CAE9B,MAAM,WAAW,aAAa,CAAC,EAAA,CAAG,aAC7B,OAAO,aAAa,oBAAC,UAAD,EAAA,UAAW,MAAgB,CAAA,GAChD,QACJ;CAEA,OACI,oBAAC,eAAD;EAAsB;EAClB,UAAA,oBAAC,mBAAD;GAA0B;GAA0B;GAChD,UAAA,oBAAC,qBAAD;IAA6B;IACzB,UAAA,oBAAC,kBAAD,EAAA,UAAmB,QAA0B,CAAA;GAC5B,CAAA;EACN,CAAA;CACR,CAAA;AAEvB"}

package/dist/agGrid/agGridTheme.d.ts

@@ -0,0 +1,77 @@
+import { type Theme as AgGridTheme } from "ag-grid-community";
+import { type Theme as MuiTheme } from "@mui/material/styles";
+/**
+ * The grid parameters derived from the MUI palette.
+ *
+ * Exported on its own so the mapping is testable and so an app can spread it into a theme of
+ * its own (`themeQuartz.withParams({ ...agGridThemeParams(theme), rowHeight: 48 })`).
+ *
+ * Every value comes from the theme — there is no colour here. That is the whole point: the
+ * grid and the surrounding MUI components read the same palette, so a change to the brand
+ * theme moves both.
+ */
+export declare const agGridThemeParams: (theme: MuiTheme) => {
+    backgroundColor: string;
+    chromeBackgroundColor: string;
+    oddRowBackgroundColor: string;
+    headerBackgroundColor: string;
+    menuBackgroundColor: string;
+    panelBackgroundColor: string;
+    foregroundColor: string;
+    headerTextColor: string;
+    menuTextColor: string;
+    subtleTextColor: string;
+    iconColor: string;
+    accentColor: string;
+    borderColor: string;
+    rowHoverColor: string;
+    selectedRowBackgroundColor: string;
+    fontFamily: import("csstype").Property.FontFamily | undefined;
+    fontSize: import("csstype").Property.FontSize<string | number> | undefined;
+    headerFontFamily: import("csstype").Property.FontFamily | undefined;
+    headerFontSize: import("csstype").Property.FontSize<string | number> | undefined;
+    headerFontWeight: number;
+    borderRadius: string | number;
+    wrapperBorderRadius: string | number;
+    browserColorScheme: import("@mui/material/styles").PaletteMode;
+};
+/**
+ * getAgGridTheme
+ *
+ * The AG Grid theme that matches a MUI theme, built with AG Grid's Theming API:
+ *
+ * ```tsx
+ * <AgGridReact theme={getAgGridTheme(muiTheme)} rowData={rows} columnDefs={columns} />
+ * ```
+ *
+ * This replaces the CSS-variable block the template carried as `agGridStyles`, removed rather
+ * than deprecated because it never worked on the version the apps run. That block targeted `.ag-theme-alpine-dark.ag-custom-app-theme`, a legacy CSS theme which AG Grid v33+
+ * only honours when the grid opts in with `theme="legacy"` and the app imports the grid's CSS
+ * files — so on the version the apps actually run (v35) it styled nothing, and the grid fell
+ * back to the stock Quartz look. The Theming API needs no CSS import, no class on the wrapper
+ * and no `legacy` opt-in.
+ *
+ * Alpine is the base part because it is the look the apps already had; everything the brand
+ * cares about is overridden by {@link agGridThemeParams} anyway. The colour scheme follows
+ * `palette.mode`, so the light theme is covered by the same call — which the CSS block never
+ * was.
+ *
+ * @param theme - The MUI theme to derive from, typically from `useTheme()`.
+ */
+export declare const getAgGridTheme: (theme: MuiTheme) => AgGridTheme;
+/**
+ * useAgGridTheme
+ *
+ * `getAgGridTheme` for the theme currently mounted — the form a component wants:
+ *
+ * ```tsx
+ * const gridTheme = useAgGridTheme();
+ *
+ * return <AgGridReact theme={gridTheme} rowData={rows} columnDefs={columns} />;
+ * ```
+ *
+ * Safe to call on every render: the result is cached per MUI theme, so the grid sees the same
+ * object each time.
+ */
+export declare const useAgGridTheme: () => AgGridTheme;
+//# sourceMappingURL=agGridTheme.d.ts.map

package/dist/agGrid/agGridTheme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agGridTheme.d.ts","sourceRoot":"","sources":["../../src/agGrid/agGridTheme.ts"],"names":[],"mappings":"AAAA,OAAO,EAIH,KAAK,KAAK,IAAI,WAAW,EAC5B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAY,KAAK,KAAK,IAAI,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAExE;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;CAqC/C,CAAC;AAOH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,cAAc,GAAI,OAAO,QAAQ,KAAG,WAWhD,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,cAAc,QAAO,WAAyC,CAAC"}

package/dist/agGrid/agGridTheme.js

@@ -0,0 +1,88 @@
+import { useTheme } from "@mui/material/styles";
+import { colorSchemeDark, colorSchemeLight, themeAlpine } from "ag-grid-community";
+//#region src/agGrid/agGridTheme.ts
+/**
+* The grid parameters derived from the MUI palette.
+*
+* Exported on its own so the mapping is testable and so an app can spread it into a theme of
+* its own (`themeQuartz.withParams({ ...agGridThemeParams(theme), rowHeight: 48 })`).
+*
+* Every value comes from the theme — there is no colour here. That is the whole point: the
+* grid and the surrounding MUI components read the same palette, so a change to the brand
+* theme moves both.
+*/
+var agGridThemeParams = (theme) => ({
+	backgroundColor: theme.palette.background.default,
+	chromeBackgroundColor: theme.palette.background.default,
+	oddRowBackgroundColor: theme.palette.background.paper,
+	headerBackgroundColor: theme.palette.background.paper,
+	menuBackgroundColor: theme.palette.background.paper,
+	panelBackgroundColor: theme.palette.background.paper,
+	foregroundColor: theme.palette.text.primary,
+	headerTextColor: theme.palette.text.primary,
+	menuTextColor: theme.palette.text.primary,
+	subtleTextColor: theme.palette.text.secondary,
+	iconColor: theme.palette.text.secondary,
+	accentColor: theme.palette.primary.main,
+	borderColor: theme.palette.divider,
+	rowHoverColor: theme.palette.action.hover,
+	selectedRowBackgroundColor: theme.palette.action.selected,
+	fontFamily: theme.typography.fontFamily,
+	fontSize: theme.typography.body2.fontSize,
+	headerFontFamily: theme.typography.fontFamily,
+	headerFontSize: theme.typography.body2.fontSize,
+	headerFontWeight: 600,
+	borderRadius: theme.shape.borderRadius,
+	wrapperBorderRadius: theme.shape.borderRadius,
+	browserColorScheme: theme.palette.mode
+});
+var cache = /* @__PURE__ */ new WeakMap();
+/**
+* getAgGridTheme
+*
+* The AG Grid theme that matches a MUI theme, built with AG Grid's Theming API:
+*
+* ```tsx
+* <AgGridReact theme={getAgGridTheme(muiTheme)} rowData={rows} columnDefs={columns} />
+* ```
+*
+* This replaces the CSS-variable block the template carried as `agGridStyles`, removed rather
+* than deprecated because it never worked on the version the apps run. That block targeted `.ag-theme-alpine-dark.ag-custom-app-theme`, a legacy CSS theme which AG Grid v33+
+* only honours when the grid opts in with `theme="legacy"` and the app imports the grid's CSS
+* files — so on the version the apps actually run (v35) it styled nothing, and the grid fell
+* back to the stock Quartz look. The Theming API needs no CSS import, no class on the wrapper
+* and no `legacy` opt-in.
+*
+* Alpine is the base part because it is the look the apps already had; everything the brand
+* cares about is overridden by {@link agGridThemeParams} anyway. The colour scheme follows
+* `palette.mode`, so the light theme is covered by the same call — which the CSS block never
+* was.
+*
+* @param theme - The MUI theme to derive from, typically from `useTheme()`.
+*/
+var getAgGridTheme = (theme) => {
+	const cached = cache.get(theme);
+	if (cached) return cached;
+	const agGridTheme = themeAlpine.withPart(theme.palette.mode === "dark" ? colorSchemeDark : colorSchemeLight).withParams(agGridThemeParams(theme));
+	cache.set(theme, agGridTheme);
+	return agGridTheme;
+};
+/**
+* useAgGridTheme
+*
+* `getAgGridTheme` for the theme currently mounted — the form a component wants:
+*
+* ```tsx
+* const gridTheme = useAgGridTheme();
+*
+* return <AgGridReact theme={gridTheme} rowData={rows} columnDefs={columns} />;
+* ```
+*
+* Safe to call on every render: the result is cached per MUI theme, so the grid sees the same
+* object each time.
+*/
+var useAgGridTheme = () => getAgGridTheme(useTheme());
+//#endregion
+export { agGridThemeParams, getAgGridTheme, useAgGridTheme };
+
+//# sourceMappingURL=agGridTheme.js.map

package/dist/agGrid/agGridTheme.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agGridTheme.js","names":[],"sources":["../../src/agGrid/agGridTheme.ts"],"sourcesContent":["import {\n    colorSchemeDark,\n    colorSchemeLight,\n    themeAlpine,\n    type Theme as AgGridTheme,\n} from \"ag-grid-community\";\nimport { useTheme, type Theme as MuiTheme } from \"@mui/material/styles\";\n\n/**\n * The grid parameters derived from the MUI palette.\n *\n * Exported on its own so the mapping is testable and so an app can spread it into a theme of\n * its own (`themeQuartz.withParams({ ...agGridThemeParams(theme), rowHeight: 48 })`).\n *\n * Every value comes from the theme — there is no colour here. That is the whole point: the\n * grid and the surrounding MUI components read the same palette, so a change to the brand\n * theme moves both.\n */\nexport const agGridThemeParams = (theme: MuiTheme) => ({\n    // Surfaces. `chromeBackgroundColor` covers the grid's own chrome (tool panels, status bar).\n    backgroundColor: theme.palette.background.default,\n    chromeBackgroundColor: theme.palette.background.default,\n    oddRowBackgroundColor: theme.palette.background.paper,\n    headerBackgroundColor: theme.palette.background.paper,\n    menuBackgroundColor: theme.palette.background.paper,\n    panelBackgroundColor: theme.palette.background.paper,\n\n    // Text and icons.\n    foregroundColor: theme.palette.text.primary,\n    headerTextColor: theme.palette.text.primary,\n    menuTextColor: theme.palette.text.primary,\n    subtleTextColor: theme.palette.text.secondary,\n    iconColor: theme.palette.text.secondary,\n\n    // Accent and lines. `accentColor` is what AG Grid paints selection, focus rings, sort\n    // indicators and range borders with — the same role `primary.main` has in MUI.\n    accentColor: theme.palette.primary.main,\n    borderColor: theme.palette.divider,\n    rowHoverColor: theme.palette.action.hover,\n    selectedRowBackgroundColor: theme.palette.action.selected,\n\n    // Typography. `body2` is the size every table in the design standard uses, and 600 is the\n    // header weight the MUI tables carry.\n    fontFamily: theme.typography.fontFamily,\n    fontSize: theme.typography.body2.fontSize,\n    headerFontFamily: theme.typography.fontFamily,\n    headerFontSize: theme.typography.body2.fontSize,\n    headerFontWeight: 600,\n\n    // Shape, from the single `shape.borderRadius` every surface in the theme uses.\n    borderRadius: theme.shape.borderRadius,\n    wrapperBorderRadius: theme.shape.borderRadius,\n\n    // Tells the browser which scrollbars and form controls to render inside the grid.\n    browserColorScheme: theme.palette.mode,\n});\n\n// One grid theme per MUI theme. AG Grid re-applies the theme whenever the object identity\n// changes, so returning a fresh one on every render would restyle the grid on every render.\n// Keyed on the MUI theme, which is itself a stable module-level object.\nconst cache = new WeakMap<MuiTheme, AgGridTheme>();\n\n/**\n * getAgGridTheme\n *\n * The AG Grid theme that matches a MUI theme, built with AG Grid's Theming API:\n *\n * ```tsx\n * <AgGridReact theme={getAgGridTheme(muiTheme)} rowData={rows} columnDefs={columns} />\n * ```\n *\n * This replaces the CSS-variable block the template carried as `agGridStyles`, removed rather\n * than deprecated because it never worked on the version the apps run. That block targeted `.ag-theme-alpine-dark.ag-custom-app-theme`, a legacy CSS theme which AG Grid v33+\n * only honours when the grid opts in with `theme=\"legacy\"` and the app imports the grid's CSS\n * files — so on the version the apps actually run (v35) it styled nothing, and the grid fell\n * back to the stock Quartz look. The Theming API needs no CSS import, no class on the wrapper\n * and no `legacy` opt-in.\n *\n * Alpine is the base part because it is the look the apps already had; everything the brand\n * cares about is overridden by {@link agGridThemeParams} anyway. The colour scheme follows\n * `palette.mode`, so the light theme is covered by the same call — which the CSS block never\n * was.\n *\n * @param theme - The MUI theme to derive from, typically from `useTheme()`.\n */\nexport const getAgGridTheme = (theme: MuiTheme): AgGridTheme => {\n    const cached = cache.get(theme);\n    if (cached) return cached;\n\n    const agGridTheme = themeAlpine\n        .withPart(theme.palette.mode === \"dark\" ? colorSchemeDark : colorSchemeLight)\n        .withParams(agGridThemeParams(theme));\n\n    cache.set(theme, agGridTheme);\n\n    return agGridTheme;\n};\n\n/**\n * useAgGridTheme\n *\n * `getAgGridTheme` for the theme currently mounted — the form a component wants:\n *\n * ```tsx\n * const gridTheme = useAgGridTheme();\n *\n * return <AgGridReact theme={gridTheme} rowData={rows} columnDefs={columns} />;\n * ```\n *\n * Safe to call on every render: the result is cached per MUI theme, so the grid sees the same\n * object each time.\n */\nexport const useAgGridTheme = (): AgGridTheme => getAgGridTheme(useTheme());\n"],"mappings":";;;;;;;;;;;;;AAkBA,IAAa,qBAAqB,WAAqB;CAEnD,iBAAiB,MAAM,QAAQ,WAAW;CAC1C,uBAAuB,MAAM,QAAQ,WAAW;CAChD,uBAAuB,MAAM,QAAQ,WAAW;CAChD,uBAAuB,MAAM,QAAQ,WAAW;CAChD,qBAAqB,MAAM,QAAQ,WAAW;CAC9C,sBAAsB,MAAM,QAAQ,WAAW;CAG/C,iBAAiB,MAAM,QAAQ,KAAK;CACpC,iBAAiB,MAAM,QAAQ,KAAK;CACpC,eAAe,MAAM,QAAQ,KAAK;CAClC,iBAAiB,MAAM,QAAQ,KAAK;CACpC,WAAW,MAAM,QAAQ,KAAK;CAI9B,aAAa,MAAM,QAAQ,QAAQ;CACnC,aAAa,MAAM,QAAQ;CAC3B,eAAe,MAAM,QAAQ,OAAO;CACpC,4BAA4B,MAAM,QAAQ,OAAO;CAIjD,YAAY,MAAM,WAAW;CAC7B,UAAU,MAAM,WAAW,MAAM;CACjC,kBAAkB,MAAM,WAAW;CACnC,gBAAgB,MAAM,WAAW,MAAM;CACvC,kBAAkB;CAGlB,cAAc,MAAM,MAAM;CAC1B,qBAAqB,MAAM,MAAM;CAGjC,oBAAoB,MAAM,QAAQ;AACtC;AAKA,IAAM,wBAAQ,IAAI,QAA+B;;;;;;;;;;;;;;;;;;;;;;;;AAyBjD,IAAa,kBAAkB,UAAiC;CAC5D,MAAM,SAAS,MAAM,IAAI,KAAK;CAC9B,IAAI,QAAQ,OAAO;CAEnB,MAAM,cAAc,YACf,SAAS,MAAM,QAAQ,SAAS,SAAS,kBAAkB,gBAAgB,CAAC,CAC5E,WAAW,kBAAkB,KAAK,CAAC;CAExC,MAAM,IAAI,OAAO,WAAW;CAE5B,OAAO;AACX;;;;;;;;;;;;;;;AAgBA,IAAa,uBAAoC,eAAe,SAAS,CAAC"}

package/dist/agGrid/index.d.ts

@@ -0,0 +1,4 @@
+export { setAgGridLicense, AgGridLicenseProvider } from "../contexts/agGridLicenseContext/provider.js";
+export type { AgGridLicenseProviderProps } from "../contexts/agGridLicenseContext/provider.js";
+export { getAgGridTheme, useAgGridTheme, agGridThemeParams } from "./agGridTheme";
+//# sourceMappingURL=index.d.ts.map

package/dist/agGrid/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agGrid/index.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,0CAA0C,CAAC;AACnG,YAAY,EAAE,0BAA0B,EAAE,MAAM,0CAA0C,CAAC;AAE3F,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC"}

package/dist/agGrid/index.js

@@ -0,0 +1,3 @@
+import { AgGridLicenseProvider, setAgGridLicense } from "../contexts/agGridLicenseContext/provider.js";
+import { agGridThemeParams, getAgGridTheme, useAgGridTheme } from "./agGridTheme.js";
+export { AgGridLicenseProvider, agGridThemeParams, getAgGridTheme, setAgGridLicense, useAgGridTheme };

package/dist/api/datastore.d.ts

@@ -0,0 +1,68 @@
+import { type AxiosInstance } from "axios";
+import type { DeleteEntityDefaultResponse, QueryObject } from "../types/entityQuery.d.ts";
+import type { Datastore, DatastoreListResponse } from "../types/datastore.d.ts";
+/**
+ * getDatastore
+ *
+ * Fetches a single datastore by ID.
+ *
+ * @param {AxiosInstance} api - Axios instance.
+ * @param {string} id - Datastore identifier.
+ * @param {string} workspace - Workspace the datastore belongs to.
+ * @returns {Promise<Datastore>} The fetched datastore.
+ *
+ * @throws {Error} If the request fails.
+ */
+export declare const getDatastore: (api: AxiosInstance, id: string, workspace: string) => Promise<Datastore>;
+/**
+ * listDatastores
+ *
+ * Fetches a list of datastores using a query object (filters, order, pagination, etc.).
+ *
+ * @param {AxiosInstance} api - Axios instance.
+ * @param {AnyRecord} query - Query object built via `buildQueryObject`.
+ * @returns {Promise<DatastoreListResponse>} Paginated list of datastores.
+ *
+ * @throws {Error} If workspace filter is missing.
+ * @throws {Error} If the request fails.
+ */
+export declare const listDatastores: (api: AxiosInstance, query: QueryObject) => Promise<DatastoreListResponse>;
+/**
+ * createDatastore
+ *
+ * Creates a new datastore.
+ *
+ * @param {AxiosInstance} api - Axios instance.
+ * @param {Partial<Datastore>} data - Datastore payload.
+ * @returns {Promise<Datastore>} The created datastore.
+ *
+ * @throws {Error} If the request fails.
+ */
+export declare const createDatastore: (api: AxiosInstance, data: Partial<Datastore>) => Promise<Datastore>;
+/**
+ * updateDatastore
+ *
+ * Updates an existing datastore by ID.
+ *
+ * @param {AxiosInstance} api - Axios instance.
+ * @param {string} id - Datastore identifier.
+ * @param {Partial<Datastore>} data - Fields to update.
+ * @returns {Promise<Datastore>} The updated datastore.
+ *
+ * @throws {Error} If the request fails.
+ */
+export declare const updateDatastore: (api: AxiosInstance, id: string, data: Partial<Datastore>) => Promise<Datastore>;
+/**
+ * deleteDatastore
+ *
+ * Deletes a datastore by ID.
+ *
+ * @param {AxiosInstance} api - Axios instance.
+ * @param {string} id - Datastore identifier.
+ * @param {string} workspace - Workspace the datastore belongs to.
+ * @returns {Promise<DeleteEntityDefaultResponse[]>} List of deleted entity records.
+ *
+ * @throws {Error} If the request fails.
+ */
+export declare const deleteDatastore: (api: AxiosInstance, id: string, workspace: string) => Promise<DeleteEntityDefaultResponse[]>;
+//# sourceMappingURL=datastore.d.ts.map

package/dist/api/datastore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datastore.d.ts","sourceRoot":"","sources":["../../src/api/datastore.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,aAAa,EAAsB,MAAM,OAAO,CAAC;AAG7E,OAAO,KAAK,EAAE,2BAA2B,EAAoB,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACtG,OAAO,KAAK,EAAE,SAAS,EAA2B,qBAAqB,EAA2B,MAAM,mBAAmB,CAAC;AAI5H;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,YAAY,GAAU,KAAK,aAAa,EAAE,IAAI,MAAM,EAAE,WAAW,MAAM,KAAG,OAAO,CAAC,SAAS,CAmBvG,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc,GAAU,KAAK,aAAa,EAAE,OAAO,WAAW,KAAG,OAAO,CAAC,qBAAqB,CAyB1G,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,GAAU,KAAK,aAAa,EAAE,MAAM,OAAO,CAAC,SAAS,CAAC,KAAG,OAAO,CAAC,SAAS,CAmBrG,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,GAAU,KAAK,aAAa,EAAE,IAAI,MAAM,EAAE,MAAM,OAAO,CAAC,SAAS,CAAC,KAAG,OAAO,CAAC,SAAS,CAmBjH,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,GAAU,KAAK,aAAa,EAAE,IAAI,MAAM,EAAE,WAAW,MAAM,KAAG,OAAO,CAAC,2BAA2B,EAAE,CAiB9H,CAAC"}