@everysk/apps-sdk 0.1.0-beta.0

package/dist/lib/datastoreTable.d.ts

@@ -0,0 +1,126 @@
+import type { Datastore } from "../types/datastore.d.ts";
+import type { AnyRecord } from "../types/anyRecord.d.ts";
+type Cell = string | number | null;
+type DatastoreData = Cell[][];
+/**
+ * Converts a datastore table (2D array) into an array of objects.
+ *
+ * The input `data` is expected to be a 2D array where:
+ * - Row 0 typically contains the headers (but headers are provided explicitly via `headers`)
+ * - Rows 1..N contain the data values
+ *
+ * Key behaviors:
+ * - Skips the first row of `data` (starts at index 1), assuming it is the header row.
+ * - Adds a `datastoreId` field to every generated object so each record can be traced
+ *   back to its source datastore.
+ * - Maps each header to the corresponding cell value by column index.
+ *
+ * @template T A record type whose values are compatible with `Cell` (string | number | null).
+ *
+ * @param datastoreId The id of the datastore to attach to each row as `datastoreId`.
+ * @param headers The column names used as object keys (positionally aligned with row cells).
+ * @param data The datastore matrix (rows x columns). Row 0 is assumed to be headers.
+ *
+ * @returns An array of objects (one per data row), each containing:
+ * - `datastoreId`
+ * - one property per header (with the corresponding cell value)
+ *
+ * @example
+ * const headers = ["name", "age"];
+ * const data = [
+ *   ["name", "age"],
+ *   ["Alice", 30],
+ *   ["Bob", null],
+ * ];
+ * const rows = tableToObjects("ds_123", headers, data);
+ * // [
+ * //   { datastoreId: "ds_123", name: "Alice", age: 30 },
+ * //   { datastoreId: "ds_123", name: "Bob", age: null }
+ * // ]
+ */
+export declare const tableToObjects: <T extends Record<string, Cell>>(datastoreId: string, headers: string[], data: DatastoreData) => T[];
+/**
+ * Converts an array of objects into a datastore table (2D array).
+ *
+ * Key behaviors:
+ * - Produces a 2D array where the first row is the provided `headers`.
+ * - For each object in `data`, creates a row by mapping `headers` to values in the object.
+ * - If a header is missing in an object, the corresponding cell is set to `null`.
+ *
+ * @template T A record type whose values are compatible with `Cell` (string | number | null).
+ *
+ * @param headers Column names (and output table header row).
+ * @param data Array of objects to convert into rows.
+ *
+ * @returns A datastore matrix where:
+ * - Row 0 is `headers`
+ * - Rows 1..N contain cell values aligned with `headers`
+ *
+ * @example
+ * const headers = ["name", "age"];
+ * const rows = objectsToTable(headers, [
+ *   { name: "Alice", age: 30 },
+ *   { name: "Bob" }, // age missing -> null
+ * ]);
+ * // [
+ * //   ["name", "age"],
+ * //   ["Alice", 30],
+ * //   ["Bob", null]
+ * // ]
+ */
+export declare const objectsToTable: <T extends Record<string, Cell>>(headers: string[], data: T[]) => DatastoreData;
+/**
+ * Flattens multiple datastore row arrays into a single array.
+ *
+ * This is typically used after fetching multiple datastores, where each datastore is
+ * represented as `AnyRecord[]` (i.e., an array of row objects).
+ *
+ * @param datastores A list of datastores, each represented as an array of row objects.
+ *
+ * @returns A single array containing all rows from all datastores, in the same order.
+ *
+ * @example
+ * const merged = mergeDatastores([
+ *   [{ datastoreId: "a", x: 1 }],
+ *   [{ datastoreId: "b", x: 2 }, { datastoreId: "b", x: 3 }],
+ * ]);
+ * // [{...}, {...}, {...}]
+ */
+export declare const mergeDatastores: (datastores: AnyRecord[][]) => AnyRecord[];
+/**
+ * buildDatastoreProps
+ *
+ * Extracts and maps the metadata properties of a `Datastore` into a plain object
+ * for UI usage, discarding raw data rows.
+ *
+ * - `header` is derived from `datastore.data?.[0]` (the first row of the data matrix),
+ *   which is expected to contain the column names. Falls back to `[]` if not present.
+ *
+ * @param {Datastore} datastore - The source datastore object.
+ * @returns Metadata object with the datastore's descriptive properties and header.
+ *
+ * @example
+ * const meta = buildDatastoreProps(datastore);
+ * // {
+ * //   name: "my-datastore",
+ * //   workspace: "ws-1",
+ * //   header: ["col1", "col2"],
+ * //   ...
+ * // }
+ */
+export declare const buildDatastoreProps: (datastore: Datastore) => {
+    name: string;
+    date: string | undefined;
+    version: string | undefined;
+    description: string | undefined;
+    tags: string[] | undefined;
+    link_uid: string | undefined;
+    workspace: string;
+    date_time: string;
+    created: number | undefined;
+    updated: number | undefined;
+    level: string | undefined;
+    header: import("../types/datastore.d.ts").DatastoreRow[];
+};
+export {};
+//# sourceMappingURL=datastoreTable.d.ts.map

package/dist/lib/datastoreTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datastoreTable.d.ts","sourceRoot":"","sources":["../../src/lib/datastoreTable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD,KAAK,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;AACnC,KAAK,aAAa,GAAG,IAAI,EAAE,EAAE,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,aAAa,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,MAAM,aAAa,KAAG,CAAC,EAgB7H,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,EAAE,MAAM,CAAC,EAAE,KAAG,aAI7F,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,eAAe,GAAI,YAAY,SAAS,EAAE,EAAE,KAAG,SAAS,EAQpE,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,mBAAmB,GAAI,WAAW,SAAS;;;;;;;;;;;;;CAevD,CAAC"}

package/dist/lib/datastoreTable.js

@@ -0,0 +1,146 @@
+//#region src/lib/datastoreTable.ts
+/**
+* Converts a datastore table (2D array) into an array of objects.
+*
+* The input `data` is expected to be a 2D array where:
+* - Row 0 typically contains the headers (but headers are provided explicitly via `headers`)
+* - Rows 1..N contain the data values
+*
+* Key behaviors:
+* - Skips the first row of `data` (starts at index 1), assuming it is the header row.
+* - Adds a `datastoreId` field to every generated object so each record can be traced
+*   back to its source datastore.
+* - Maps each header to the corresponding cell value by column index.
+*
+* @template T A record type whose values are compatible with `Cell` (string | number | null).
+*
+* @param datastoreId The id of the datastore to attach to each row as `datastoreId`.
+* @param headers The column names used as object keys (positionally aligned with row cells).
+* @param data The datastore matrix (rows x columns). Row 0 is assumed to be headers.
+*
+* @returns An array of objects (one per data row), each containing:
+* - `datastoreId`
+* - one property per header (with the corresponding cell value)
+*
+* @example
+* const headers = ["name", "age"];
+* const data = [
+*   ["name", "age"],
+*   ["Alice", 30],
+*   ["Bob", null],
+* ];
+* const rows = tableToObjects("ds_123", headers, data);
+* // [
+* //   { datastoreId: "ds_123", name: "Alice", age: 30 },
+* //   { datastoreId: "ds_123", name: "Bob", age: null }
+* // ]
+*/
+var tableToObjects = (datastoreId, headers, data) => {
+	const result = [];
+	for (let i = 1; i < data?.length; i++) {
+		const item = {};
+		item.datastoreId = datastoreId;
+		headers.forEach((header, index) => {
+			item[header] = data[i][index];
+		});
+		result.push(item);
+	}
+	return result;
+};
+/**
+* Converts an array of objects into a datastore table (2D array).
+*
+* Key behaviors:
+* - Produces a 2D array where the first row is the provided `headers`.
+* - For each object in `data`, creates a row by mapping `headers` to values in the object.
+* - If a header is missing in an object, the corresponding cell is set to `null`.
+*
+* @template T A record type whose values are compatible with `Cell` (string | number | null).
+*
+* @param headers Column names (and output table header row).
+* @param data Array of objects to convert into rows.
+*
+* @returns A datastore matrix where:
+* - Row 0 is `headers`
+* - Rows 1..N contain cell values aligned with `headers`
+*
+* @example
+* const headers = ["name", "age"];
+* const rows = objectsToTable(headers, [
+*   { name: "Alice", age: 30 },
+*   { name: "Bob" }, // age missing -> null
+* ]);
+* // [
+* //   ["name", "age"],
+* //   ["Alice", 30],
+* //   ["Bob", null]
+* // ]
+*/
+var objectsToTable = (headers, data) => {
+	return [headers, ...data.map((d) => headers.map((h) => d[h] ?? null))];
+};
+/**
+* Flattens multiple datastore row arrays into a single array.
+*
+* This is typically used after fetching multiple datastores, where each datastore is
+* represented as `AnyRecord[]` (i.e., an array of row objects).
+*
+* @param datastores A list of datastores, each represented as an array of row objects.
+*
+* @returns A single array containing all rows from all datastores, in the same order.
+*
+* @example
+* const merged = mergeDatastores([
+*   [{ datastoreId: "a", x: 1 }],
+*   [{ datastoreId: "b", x: 2 }, { datastoreId: "b", x: 3 }],
+* ]);
+* // [{...}, {...}, {...}]
+*/
+var mergeDatastores = (datastores) => {
+	const result = [];
+	datastores.forEach((datastore) => {
+		result.push(...datastore);
+	});
+	return result;
+};
+/**
+* buildDatastoreProps
+*
+* Extracts and maps the metadata properties of a `Datastore` into a plain object
+* for UI usage, discarding raw data rows.
+*
+* - `header` is derived from `datastore.data?.[0]` (the first row of the data matrix),
+*   which is expected to contain the column names. Falls back to `[]` if not present.
+*
+* @param {Datastore} datastore - The source datastore object.
+* @returns Metadata object with the datastore's descriptive properties and header.
+*
+* @example
+* const meta = buildDatastoreProps(datastore);
+* // {
+* //   name: "my-datastore",
+* //   workspace: "ws-1",
+* //   header: ["col1", "col2"],
+* //   ...
+* // }
+*/
+var buildDatastoreProps = (datastore) => {
+	return {
+		name: datastore.name,
+		date: datastore.date,
+		version: datastore.version,
+		description: datastore.description,
+		tags: datastore.tags,
+		link_uid: datastore.link_uid,
+		workspace: datastore.workspace,
+		date_time: datastore.date_time,
+		created: datastore.created,
+		updated: datastore.updated,
+		level: datastore.level,
+		header: datastore.data?.[0] || []
+	};
+};
+//#endregion
+export { buildDatastoreProps, mergeDatastores, objectsToTable, tableToObjects };
+
+//# sourceMappingURL=datastoreTable.js.map

package/dist/lib/datastoreTable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"datastoreTable.js","names":[],"sources":["../../src/lib/datastoreTable.ts"],"sourcesContent":["import type { Datastore } from \"@/types/datastore\";\nimport type { AnyRecord } from \"@/types/anyRecord\";\n\ntype Cell = string | number | null;\ntype DatastoreData = Cell[][];\n\n/**\n * Converts a datastore table (2D array) into an array of objects.\n *\n * The input `data` is expected to be a 2D array where:\n * - Row 0 typically contains the headers (but headers are provided explicitly via `headers`)\n * - Rows 1..N contain the data values\n *\n * Key behaviors:\n * - Skips the first row of `data` (starts at index 1), assuming it is the header row.\n * - Adds a `datastoreId` field to every generated object so each record can be traced\n *   back to its source datastore.\n * - Maps each header to the corresponding cell value by column index.\n *\n * @template T A record type whose values are compatible with `Cell` (string | number | null).\n *\n * @param datastoreId The id of the datastore to attach to each row as `datastoreId`.\n * @param headers The column names used as object keys (positionally aligned with row cells).\n * @param data The datastore matrix (rows x columns). Row 0 is assumed to be headers.\n *\n * @returns An array of objects (one per data row), each containing:\n * - `datastoreId`\n * - one property per header (with the corresponding cell value)\n *\n * @example\n * const headers = [\"name\", \"age\"];\n * const data = [\n *   [\"name\", \"age\"],\n *   [\"Alice\", 30],\n *   [\"Bob\", null],\n * ];\n * const rows = tableToObjects(\"ds_123\", headers, data);\n * // [\n * //   { datastoreId: \"ds_123\", name: \"Alice\", age: 30 },\n * //   { datastoreId: \"ds_123\", name: \"Bob\", age: null }\n * // ]\n */\nexport const tableToObjects = <T extends Record<string, Cell>>(datastoreId: string, headers: string[], data: DatastoreData): T[] => {\n  const result: T[] = [];\n\n  for (let i = 1; i < data?.length; i++) {\n    const item: Record<string, Cell> = {};\n\n    item.datastoreId = datastoreId;\n\n    headers.forEach((header: string, index: number) => {\n      item[header] = data[i][index];\n    });\n\n    result.push(item as T);\n  }\n\n  return result;\n};\n\n/**\n * Converts an array of objects into a datastore table (2D array).\n *\n * Key behaviors:\n * - Produces a 2D array where the first row is the provided `headers`.\n * - For each object in `data`, creates a row by mapping `headers` to values in the object.\n * - If a header is missing in an object, the corresponding cell is set to `null`.\n *\n * @template T A record type whose values are compatible with `Cell` (string | number | null).\n *\n * @param headers Column names (and output table header row).\n * @param data Array of objects to convert into rows.\n *\n * @returns A datastore matrix where:\n * - Row 0 is `headers`\n * - Rows 1..N contain cell values aligned with `headers`\n *\n * @example\n * const headers = [\"name\", \"age\"];\n * const rows = objectsToTable(headers, [\n *   { name: \"Alice\", age: 30 },\n *   { name: \"Bob\" }, // age missing -> null\n * ]);\n * // [\n * //   [\"name\", \"age\"],\n * //   [\"Alice\", 30],\n * //   [\"Bob\", null]\n * // ]\n */\nexport const objectsToTable = <T extends Record<string, Cell>>(headers: string[] ,data: T[]): DatastoreData => {\n  const rows: DatastoreData = data.map((d) => headers.map<Cell>((h) => d[h as string] ?? null));\n\n  return [headers, ...rows];\n};\n\n/**\n * Flattens multiple datastore row arrays into a single array.\n *\n * This is typically used after fetching multiple datastores, where each datastore is\n * represented as `AnyRecord[]` (i.e., an array of row objects).\n *\n * @param datastores A list of datastores, each represented as an array of row objects.\n *\n * @returns A single array containing all rows from all datastores, in the same order.\n *\n * @example\n * const merged = mergeDatastores([\n *   [{ datastoreId: \"a\", x: 1 }],\n *   [{ datastoreId: \"b\", x: 2 }, { datastoreId: \"b\", x: 3 }],\n * ]);\n * // [{...}, {...}, {...}]\n */\nexport const mergeDatastores = (datastores: AnyRecord[][]): AnyRecord[] => {\n  const result: AnyRecord[] = [];\n\n  datastores.forEach((datastore: AnyRecord[]) => {\n    result.push(...datastore);\n  });\n\n  return result;\n};\n\n/**\n * buildDatastoreProps\n *\n * Extracts and maps the metadata properties of a `Datastore` into a plain object\n * for UI usage, discarding raw data rows.\n *\n * - `header` is derived from `datastore.data?.[0]` (the first row of the data matrix),\n *   which is expected to contain the column names. Falls back to `[]` if not present.\n *\n * @param {Datastore} datastore - The source datastore object.\n * @returns Metadata object with the datastore's descriptive properties and header.\n *\n * @example\n * const meta = buildDatastoreProps(datastore);\n * // {\n * //   name: \"my-datastore\",\n * //   workspace: \"ws-1\",\n * //   header: [\"col1\", \"col2\"],\n * //   ...\n * // }\n */\nexport const buildDatastoreProps = (datastore: Datastore) => {\n    return {\n        name: datastore.name,\n        date: datastore.date,\n        version: datastore.version,\n        description: datastore.description,\n        tags: datastore.tags,\n        link_uid: datastore.link_uid,\n        workspace: datastore.workspace,\n        date_time: datastore.date_time,\n        created: datastore.created,\n        updated: datastore.updated,\n        level: datastore.level,\n        header: datastore.data?.[0] || [],\n    };\n};"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,IAAa,kBAAkD,aAAqB,SAAmB,SAA6B;CAClI,MAAM,SAAc,CAAC;CAErB,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;EACrC,MAAM,OAA6B,CAAC;EAEpC,KAAK,cAAc;EAEnB,QAAQ,SAAS,QAAgB,UAAkB;GACjD,KAAK,UAAU,KAAK,EAAE,CAAC;EACzB,CAAC;EAED,OAAO,KAAK,IAAS;CACvB;CAEA,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,IAAa,kBAAkD,SAAmB,SAA6B;CAG7G,OAAO,CAAC,SAAS,GAFW,KAAK,KAAK,MAAM,QAAQ,KAAW,MAAM,EAAE,MAAgB,IAAI,CAEvE,CAAI;AAC1B;;;;;;;;;;;;;;;;;;AAmBA,IAAa,mBAAmB,eAA2C;CACzE,MAAM,SAAsB,CAAC;CAE7B,WAAW,SAAS,cAA2B;EAC7C,OAAO,KAAK,GAAG,SAAS;CAC1B,CAAC;CAED,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;AAuBA,IAAa,uBAAuB,cAAyB;CACzD,OAAO;EACH,MAAM,UAAU;EAChB,MAAM,UAAU;EAChB,SAAS,UAAU;EACnB,aAAa,UAAU;EACvB,MAAM,UAAU;EAChB,UAAU,UAAU;EACpB,WAAW,UAAU;EACrB,WAAW,UAAU;EACrB,SAAS,UAAU;EACnB,SAAS,UAAU;EACnB,OAAO,UAAU;EACjB,QAAQ,UAAU,OAAO,MAAM,CAAC;CACpC;AACJ"}

package/dist/lib/queryClient.d.ts

@@ -0,0 +1,24 @@
+import { QueryClient, type QueryClientConfig, type QueryFunction } from "@tanstack/react-query";
+type UnauthorizedBehavior = "returnNull" | "throw";
+export declare const getQueryFn: <T>(options: {
+    on401: UnauthorizedBehavior;
+}) => QueryFunction<T>;
+/**
+ * createQueryClient
+ *
+ * Builds a `QueryClient` carrying the defaults every Everysk app shares: the fetch-based
+ * `queryFn` above, no retries, no refetch on focus or interval, and `staleTime: Infinity`.
+ *
+ * This is a factory rather than the shared instance the template exported. A module-level
+ * `new QueryClient()` inside a published package is a single cache shared by every consumer
+ * of that copy of the module: it cannot be configured per app, it cannot be reset, and in
+ * tests it leaks state from one case into the next. The app owns the instance and passes it
+ * to `QueryClientProvider` — `EveryskApp` does this for you when you don't pass one.
+ *
+ * @param {QueryClientConfig} [config] - Merged over the defaults, one level deep, so passing
+ *  `defaultOptions.queries` replaces the whole `queries` object rather than merging into it.
+ * @returns {QueryClient} A fresh client.
+ */
+export declare const createQueryClient: (config?: QueryClientConfig) => QueryClient;
+export {};
+//# sourceMappingURL=queryClient.d.ts.map

package/dist/lib/queryClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryClient.d.ts","sourceRoot":"","sources":["../../src/lib/queryClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,KAAK,iBAAiB,EAAE,KAAK,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAShG,KAAK,oBAAoB,GAAG,YAAY,GAAG,OAAO,CAAC;AACnD,eAAO,MAAM,UAAU,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE;IAClC,KAAK,EAAE,oBAAoB,CAAC;CAC/B,KAAK,aAAa,CAAC,CAAC,CAaZ,CAAC;AAEV;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,iBAAiB,GAAI,SAAS,iBAAiB,KAAG,WAgBzD,CAAC"}

package/dist/lib/queryClient.js

@@ -0,0 +1,48 @@
+import { QueryClient } from "@tanstack/react-query";
+//#region src/lib/queryClient.ts
+async function throwIfResNotOk(res) {
+	if (!res.ok) {
+		const text = await res.text() || res.statusText;
+		throw new Error(`${res.status}: ${text}`);
+	}
+}
+var getQueryFn = ({ on401: unauthorizedBehavior }) => async ({ queryKey }) => {
+	const res = await fetch(queryKey.join("/"), { credentials: "include" });
+	if (unauthorizedBehavior === "returnNull" && res.status === 401) return null;
+	await throwIfResNotOk(res);
+	return await res.json();
+};
+/**
+* createQueryClient
+*
+* Builds a `QueryClient` carrying the defaults every Everysk app shares: the fetch-based
+* `queryFn` above, no retries, no refetch on focus or interval, and `staleTime: Infinity`.
+*
+* This is a factory rather than the shared instance the template exported. A module-level
+* `new QueryClient()` inside a published package is a single cache shared by every consumer
+* of that copy of the module: it cannot be configured per app, it cannot be reset, and in
+* tests it leaks state from one case into the next. The app owns the instance and passes it
+* to `QueryClientProvider` — `EveryskApp` does this for you when you don't pass one.
+*
+* @param {QueryClientConfig} [config] - Merged over the defaults, one level deep, so passing
+*  `defaultOptions.queries` replaces the whole `queries` object rather than merging into it.
+* @returns {QueryClient} A fresh client.
+*/
+var createQueryClient = (config) => new QueryClient({
+	...config,
+	defaultOptions: {
+		queries: {
+			queryFn: getQueryFn({ on401: "throw" }),
+			refetchInterval: false,
+			refetchOnWindowFocus: false,
+			staleTime: Infinity,
+			retry: false
+		},
+		mutations: { retry: false },
+		...config?.defaultOptions
+	}
+});
+//#endregion
+export { createQueryClient, getQueryFn };
+
+//# sourceMappingURL=queryClient.js.map

package/dist/lib/queryClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryClient.js","names":[],"sources":["../../src/lib/queryClient.ts"],"sourcesContent":["import { QueryClient, type QueryClientConfig, type QueryFunction } from \"@tanstack/react-query\";\n\nasync function throwIfResNotOk(res: Response) {\n    if (!res.ok) {\n        const text = (await res.text()) || res.statusText;\n        throw new Error(`${res.status}: ${text}`);\n    }\n}\n\ntype UnauthorizedBehavior = \"returnNull\" | \"throw\";\nexport const getQueryFn: <T>(options: {\n    on401: UnauthorizedBehavior;\n}) => QueryFunction<T> =\n    ({ on401: unauthorizedBehavior }) =>\n        async ({ queryKey }) => {\n            const res = await fetch(queryKey.join(\"/\") as string, {\n                credentials: \"include\",\n            });\n\n            if (unauthorizedBehavior === \"returnNull\" && res.status === 401) {\n                return null;\n            }\n\n            await throwIfResNotOk(res);\n            return await res.json();\n        };\n\n/**\n * createQueryClient\n *\n * Builds a `QueryClient` carrying the defaults every Everysk app shares: the fetch-based\n * `queryFn` above, no retries, no refetch on focus or interval, and `staleTime: Infinity`.\n *\n * This is a factory rather than the shared instance the template exported. A module-level\n * `new QueryClient()` inside a published package is a single cache shared by every consumer\n * of that copy of the module: it cannot be configured per app, it cannot be reset, and in\n * tests it leaks state from one case into the next. The app owns the instance and passes it\n * to `QueryClientProvider` — `EveryskApp` does this for you when you don't pass one.\n *\n * @param {QueryClientConfig} [config] - Merged over the defaults, one level deep, so passing\n *  `defaultOptions.queries` replaces the whole `queries` object rather than merging into it.\n * @returns {QueryClient} A fresh client.\n */\nexport const createQueryClient = (config?: QueryClientConfig): QueryClient =>\n    new QueryClient({\n        ...config,\n        defaultOptions: {\n            queries: {\n                queryFn: getQueryFn({ on401: \"throw\" }),\n                refetchInterval: false,\n                refetchOnWindowFocus: false,\n                staleTime: Infinity,\n                retry: false,\n            },\n            mutations: {\n                retry: false,\n            },\n            ...config?.defaultOptions,\n        },\n    });\n"],"mappings":";;AAEA,eAAe,gBAAgB,KAAe;CAC1C,IAAI,CAAC,IAAI,IAAI;EACT,MAAM,OAAQ,MAAM,IAAI,KAAK,KAAM,IAAI;EACvC,MAAM,IAAI,MAAM,GAAG,IAAI,OAAO,IAAI,MAAM;CAC5C;AACJ;AAGA,IAAa,cAGR,EAAE,OAAO,2BACN,OAAO,EAAE,eAAe;CACpB,MAAM,MAAM,MAAM,MAAM,SAAS,KAAK,GAAG,GAAa,EAClD,aAAa,UACjB,CAAC;CAED,IAAI,yBAAyB,gBAAgB,IAAI,WAAW,KACxD,OAAO;CAGX,MAAM,gBAAgB,GAAG;CACzB,OAAO,MAAM,IAAI,KAAK;AAC1B;;;;;;;;;;;;;;;;;AAkBR,IAAa,qBAAqB,WAC9B,IAAI,YAAY;CACZ,GAAG;CACH,gBAAgB;EACZ,SAAS;GACL,SAAS,WAAW,EAAE,OAAO,QAAQ,CAAC;GACtC,iBAAiB;GACjB,sBAAsB;GACtB,WAAW;GACX,OAAO;EACX;EACA,WAAW,EACP,OAAO,MACX;EACA,GAAG,QAAQ;CACf;AACJ,CAAC"}

package/dist/portfolio/index.d.ts

@@ -0,0 +1,6 @@
+export * from "../api/portfolio.js";
+export * from "../types/portfolio.d.ts";
+export * from "../hooks/portfolio/useFetchPortfolio.js";
+export * from "../hooks/portfolio/useFetchPortfolios.js";
+export * from "../hooks/portfolio/usePortfolioMutations.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/portfolio/index.ts"],"names":[],"mappings":"AAQA,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qCAAqC,CAAC;AACpD,cAAc,sCAAsC,CAAC;AACrD,cAAc,yCAAyC,CAAC"}

package/dist/profile/index.d.ts

@@ -0,0 +1,4 @@
+export * from "../api/profile.js";
+export * from "../types/profile.d.ts";
+export * from "../hooks/profile/useFetchProfile.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/profile/index.ts"],"names":[],"mappings":"AAQA,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,iCAAiC,CAAC"}

package/dist/socket/index.d.ts

@@ -0,0 +1,10 @@
+export * from "../contexts/webSocketContext/index.js";
+export * from "../contexts/webSocketContext/provider.js";
+export * from "../contexts/webSocketContext/types.d.ts";
+export * from "../contexts/webSocketContext/constants.js";
+export * from "../contexts/webSocketContext/handler.js";
+export * from "../contexts/webSocketContext/hooks/useWebSocket/index.js";
+export * from "../contexts/webSocketContext/hooks/useWebSocketSubscription/index.js";
+export * from "../contexts/webSocketContext/hooks/useAppNotificationSubscription/index.js";
+export * from "../api/websocketsConfig.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/socket/index.ts"],"names":[],"mappings":"AAUA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sCAAsC,CAAC;AACrD,cAAc,mCAAmC,CAAC;AAClD,cAAc,uCAAuC,CAAC;AACtD,cAAc,qCAAqC,CAAC;AACpD,cAAc,gDAAgD,CAAC;AAC/D,cAAc,4DAA4D,CAAC;AAC3E,cAAc,kEAAkE,CAAC;AACjF,cAAc,wBAAwB,CAAC"}

package/dist/socket/index.js

@@ -0,0 +1,9 @@
+import { WebSocketContext } from "../contexts/webSocketContext/index.js";
+import { getWebsocketsConfig } from "../api/websocketsConfig.js";
+import { APP_NOTIFICATION_EVENT_TYPE, JOIN_EVENT, NOTIFICATION_EVENT } from "../contexts/webSocketContext/constants.js";
+import { WebSocketHandler } from "../contexts/webSocketContext/handler.js";
+import { WebSocketProvider } from "../contexts/webSocketContext/provider.js";
+import { useWebSocket } from "../contexts/webSocketContext/hooks/useWebSocket/index.js";
+import { useWebSocketSubscription } from "../contexts/webSocketContext/hooks/useWebSocketSubscription/index.js";
+import { useAppNotificationSubscription } from "../contexts/webSocketContext/hooks/useAppNotificationSubscription/index.js";
+export { APP_NOTIFICATION_EVENT_TYPE, JOIN_EVENT, NOTIFICATION_EVENT, WebSocketContext, WebSocketHandler, WebSocketProvider, getWebsocketsConfig, useAppNotificationSubscription, useWebSocket, useWebSocketSubscription };

package/dist/test/index.d.ts

@@ -0,0 +1,2 @@
+export { renderWithProviders, renderHookWithProviders, createTestQueryClient, } from "./renderWithProviders";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/test/index.ts"],"names":[],"mappings":"AAKA,OAAO,EACH,mBAAmB,EACnB,uBAAuB,EACvB,qBAAqB,GACxB,MAAM,uBAAuB,CAAC"}

package/dist/test/index.js

@@ -0,0 +1,2 @@
+import { createTestQueryClient, renderHookWithProviders, renderWithProviders } from "./renderWithProviders.js";
+export { createTestQueryClient, renderHookWithProviders, renderWithProviders };

package/dist/test/mocks/agGridEnterprise.d.ts

@@ -0,0 +1,38 @@
+/**
+ * agGridEnterpriseMock
+ *
+ * A stand-in for `ag-grid-enterprise`, for a test that renders something registering the AG Grid
+ * licence. The real `LicenseManager` validates the key and warns on the console when it does not
+ * like it, which is noise a test neither needs nor should depend on.
+ *
+ * ```ts
+ * import { getAgGridLicenseKey } from "@everysk/apps-sdk/test/mocks";
+ *
+ * vi.mock("ag-grid-enterprise", async () =>
+ *   (await import("@everysk/apps-sdk/test/mocks")).agGridEnterpriseMock(),
+ * );
+ *
+ * it("registers the licence the app passes", () => {
+ *   render(<App />);
+ *   expect(getAgGridLicenseKey()).toBe("test-key");
+ * });
+ * ```
+ *
+ * `setLicenseKey` is a plain function rather than a `vi.fn`, and the key is captured at module
+ * level, for the same reason the socket double is built that way: a config with `restoreMocks`
+ * wipes a `vi.fn`'s implementation between tests, so a spy created inside the factory stops
+ * recording after the first case. Reading the captured key works whatever the config does.
+ *
+ * Opt-in, never applied from the shared setup file — `ag-grid-enterprise` is an OPTIONAL peer,
+ * and `vi.mock` on a module that cannot be resolved fails the whole test file at transform time.
+ */
+export declare const agGridEnterpriseMock: () => {
+    LicenseManager: {
+        setLicenseKey: (key: string) => void;
+    };
+};
+/** The licence key last registered, or null when nothing registered one. */
+export declare const getAgGridLicenseKey: () => string | null;
+/** Drops the captured key between tests. */
+export declare const resetAgGridLicense: () => void;
+//# sourceMappingURL=agGridEnterprise.d.ts.map

package/dist/test/mocks/agGridEnterprise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agGridEnterprise.d.ts","sourceRoot":"","sources":["../../../src/test/mocks/agGridEnterprise.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,oBAAoB;;6BAEJ,MAAM;;CAIjC,CAAC;AAEH,4EAA4E;AAC5E,eAAO,MAAM,mBAAmB,QAAO,MAAM,GAAG,IAAe,CAAC;AAEhE,4CAA4C;AAC5C,eAAO,MAAM,kBAAkB,QAAO,IAErC,CAAC"}

package/dist/test/mocks/agGridEnterprise.js

@@ -0,0 +1,43 @@
+//#region src/test/mocks/agGridEnterprise.ts
+var lastKey = null;
+/**
+* agGridEnterpriseMock
+*
+* A stand-in for `ag-grid-enterprise`, for a test that renders something registering the AG Grid
+* licence. The real `LicenseManager` validates the key and warns on the console when it does not
+* like it, which is noise a test neither needs nor should depend on.
+*
+* ```ts
+* import { getAgGridLicenseKey } from "@everysk/apps-sdk/test/mocks";
+*
+* vi.mock("ag-grid-enterprise", async () =>
+*   (await import("@everysk/apps-sdk/test/mocks")).agGridEnterpriseMock(),
+* );
+*
+* it("registers the licence the app passes", () => {
+*   render(<App />);
+*   expect(getAgGridLicenseKey()).toBe("test-key");
+* });
+* ```
+*
+* `setLicenseKey` is a plain function rather than a `vi.fn`, and the key is captured at module
+* level, for the same reason the socket double is built that way: a config with `restoreMocks`
+* wipes a `vi.fn`'s implementation between tests, so a spy created inside the factory stops
+* recording after the first case. Reading the captured key works whatever the config does.
+*
+* Opt-in, never applied from the shared setup file — `ag-grid-enterprise` is an OPTIONAL peer,
+* and `vi.mock` on a module that cannot be resolved fails the whole test file at transform time.
+*/
+var agGridEnterpriseMock = () => ({ LicenseManager: { setLicenseKey: (key) => {
+	lastKey = key;
+} } });
+/** The licence key last registered, or null when nothing registered one. */
+var getAgGridLicenseKey = () => lastKey;
+/** Drops the captured key between tests. */
+var resetAgGridLicense = () => {
+	lastKey = null;
+};
+//#endregion
+export { agGridEnterpriseMock, getAgGridLicenseKey, resetAgGridLicense };
+
+//# sourceMappingURL=agGridEnterprise.js.map

package/dist/test/mocks/agGridEnterprise.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agGridEnterprise.js","names":[],"sources":["../../../src/test/mocks/agGridEnterprise.ts"],"sourcesContent":["let lastKey: string | null = null;\n\n/**\n * agGridEnterpriseMock\n *\n * A stand-in for `ag-grid-enterprise`, for a test that renders something registering the AG Grid\n * licence. The real `LicenseManager` validates the key and warns on the console when it does not\n * like it, which is noise a test neither needs nor should depend on.\n *\n * ```ts\n * import { getAgGridLicenseKey } from \"@everysk/apps-sdk/test/mocks\";\n *\n * vi.mock(\"ag-grid-enterprise\", async () =>\n *   (await import(\"@everysk/apps-sdk/test/mocks\")).agGridEnterpriseMock(),\n * );\n *\n * it(\"registers the licence the app passes\", () => {\n *   render(<App />);\n *   expect(getAgGridLicenseKey()).toBe(\"test-key\");\n * });\n * ```\n *\n * `setLicenseKey` is a plain function rather than a `vi.fn`, and the key is captured at module\n * level, for the same reason the socket double is built that way: a config with `restoreMocks`\n * wipes a `vi.fn`'s implementation between tests, so a spy created inside the factory stops\n * recording after the first case. Reading the captured key works whatever the config does.\n *\n * Opt-in, never applied from the shared setup file — `ag-grid-enterprise` is an OPTIONAL peer,\n * and `vi.mock` on a module that cannot be resolved fails the whole test file at transform time.\n */\nexport const agGridEnterpriseMock = () => ({\n    LicenseManager: {\n        setLicenseKey: (key: string) => {\n            lastKey = key;\n        },\n    },\n});\n\n/** The licence key last registered, or null when nothing registered one. */\nexport const getAgGridLicenseKey = (): string | null => lastKey;\n\n/** Drops the captured key between tests. */\nexport const resetAgGridLicense = (): void => {\n    lastKey = null;\n};\n"],"mappings":";AAAA,IAAI,UAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8B7B,IAAa,8BAA8B,EACvC,gBAAgB,EACZ,gBAAgB,QAAgB;CAC5B,UAAU;AACd,EACJ,EACJ;;AAGA,IAAa,4BAA2C;;AAGxD,IAAa,2BAAiC;CAC1C,UAAU;AACd"}

package/dist/test/mocks/agGridReact.d.ts

@@ -0,0 +1,42 @@
+import type { ReactNode } from "react";
+type ColumnDef = {
+    field?: string;
+    headerName?: string;
+};
+type Row = Record<string, unknown>;
+type AgGridReactProps = {
+    rowData?: Row[] | null;
+    columnDefs?: ColumnDef[] | null;
+    children?: ReactNode;
+};
+/**
+ * agGridReactMock
+ *
+ * A stand-in for `ag-grid-react` that renders the data as plain DOM instead of running AG
+ * Grid's layout, virtualisation and ResizeObserver work — which is what makes grid tests slow
+ * under jsdom.
+ *
+ * It is deliberately not a black box: rows and cells are rendered with test ids, so
+ * assertions about *what the grid was given* keep working. Only the rendering engine is gone.
+ *
+ * ```tsx
+ * import { agGridReactMock } from "@everysk/apps-sdk/test/mocks";
+ *
+ * vi.mock("ag-grid-react", agGridReactMock);
+ *
+ * it("lists the portfolios", () => {
+ *   renderWithProviders(<PortfolioGrid />);
+ *   expect(screen.getAllByTestId("ag-grid-row")).toHaveLength(3);
+ *   expect(screen.getByTestId("ag-grid-cell-name")).toHaveTextContent("Fund A");
+ * });
+ * ```
+ *
+ * Opt-in on purpose. Applying this from the shared setup file would mock `ag-grid-react` for
+ * every app — including apps that never installed it, since it is an *optional* peer, and
+ * `vi.mock` on a module that cannot be resolved fails the whole test file at transform time.
+ */
+export declare const agGridReactMock: () => {
+    AgGridReact: ({ rowData, columnDefs, children }: AgGridReactProps) => import("react").JSX.Element;
+};
+export {};
+//# sourceMappingURL=agGridReact.d.ts.map

package/dist/test/mocks/agGridReact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agGridReact.d.ts","sourceRoot":"","sources":["../../../src/test/mocks/agGridReact.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,KAAK,SAAS,GAAG;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AACzD,KAAK,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEnC,KAAK,gBAAgB,GAAG;IACpB,OAAO,CAAC,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IACvB,UAAU,CAAC,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC;IAChC,QAAQ,CAAC,EAAE,SAAS,CAAC;CACxB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,eAAe;qDACyB,gBAAgB;CAsBnE,CAAC"}

package/dist/test/mocks/agGridReact.js

@@ -0,0 +1,47 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/test/mocks/agGridReact.tsx
+/**
+* agGridReactMock
+*
+* A stand-in for `ag-grid-react` that renders the data as plain DOM instead of running AG
+* Grid's layout, virtualisation and ResizeObserver work — which is what makes grid tests slow
+* under jsdom.
+*
+* It is deliberately not a black box: rows and cells are rendered with test ids, so
+* assertions about *what the grid was given* keep working. Only the rendering engine is gone.
+*
+* ```tsx
+* import { agGridReactMock } from "@everysk/apps-sdk/test/mocks";
+*
+* vi.mock("ag-grid-react", agGridReactMock);
+*
+* it("lists the portfolios", () => {
+*   renderWithProviders(<PortfolioGrid />);
+*   expect(screen.getAllByTestId("ag-grid-row")).toHaveLength(3);
+*   expect(screen.getByTestId("ag-grid-cell-name")).toHaveTextContent("Fund A");
+* });
+* ```
+*
+* Opt-in on purpose. Applying this from the shared setup file would mock `ag-grid-react` for
+* every app — including apps that never installed it, since it is an *optional* peer, and
+* `vi.mock` on a module that cannot be resolved fails the whole test file at transform time.
+*/
+var agGridReactMock = () => ({ AgGridReact: ({ rowData, columnDefs, children }) => {
+	const rows = rowData ?? [];
+	const columns = columnDefs ?? [];
+	return /* @__PURE__ */ jsxs("div", {
+		"data-testid": "ag-grid",
+		"data-row-count": rows.length,
+		children: [rows.map((row, index) => /* @__PURE__ */ jsx("div", {
+			"data-testid": "ag-grid-row",
+			children: columns.map((column) => /* @__PURE__ */ jsx("span", {
+				"data-testid": `ag-grid-cell-${column.field ?? ""}`,
+				children: String(row[column.field ?? ""] ?? "")
+			}, column.field ?? column.headerName))
+		}, index)), children]
+	});
+} });
+//#endregion
+export { agGridReactMock };
+
+//# sourceMappingURL=agGridReact.js.map

package/dist/test/mocks/agGridReact.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agGridReact.js","names":[],"sources":["../../../src/test/mocks/agGridReact.tsx"],"sourcesContent":["import type { ReactNode } from \"react\";\n\ntype ColumnDef = { field?: string; headerName?: string };\ntype Row = Record<string, unknown>;\n\ntype AgGridReactProps = {\n    rowData?: Row[] | null;\n    columnDefs?: ColumnDef[] | null;\n    children?: ReactNode;\n};\n\n/**\n * agGridReactMock\n *\n * A stand-in for `ag-grid-react` that renders the data as plain DOM instead of running AG\n * Grid's layout, virtualisation and ResizeObserver work — which is what makes grid tests slow\n * under jsdom.\n *\n * It is deliberately not a black box: rows and cells are rendered with test ids, so\n * assertions about *what the grid was given* keep working. Only the rendering engine is gone.\n *\n * ```tsx\n * import { agGridReactMock } from \"@everysk/apps-sdk/test/mocks\";\n *\n * vi.mock(\"ag-grid-react\", agGridReactMock);\n *\n * it(\"lists the portfolios\", () => {\n *   renderWithProviders(<PortfolioGrid />);\n *   expect(screen.getAllByTestId(\"ag-grid-row\")).toHaveLength(3);\n *   expect(screen.getByTestId(\"ag-grid-cell-name\")).toHaveTextContent(\"Fund A\");\n * });\n * ```\n *\n * Opt-in on purpose. Applying this from the shared setup file would mock `ag-grid-react` for\n * every app — including apps that never installed it, since it is an *optional* peer, and\n * `vi.mock` on a module that cannot be resolved fails the whole test file at transform time.\n */\nexport const agGridReactMock = () => ({\n    AgGridReact: ({ rowData, columnDefs, children }: AgGridReactProps) => {\n        const rows = rowData ?? [];\n        const columns = columnDefs ?? [];\n\n        return (\n            <div data-testid=\"ag-grid\" data-row-count={rows.length}>\n                {rows.map((row, index) => (\n                    <div key={index} data-testid=\"ag-grid-row\">\n                        {columns.map((column) => (\n                            <span\n                                key={column.field ?? column.headerName}\n                                data-testid={`ag-grid-cell-${column.field ?? \"\"}`}\n                            >\n                                {String(row[column.field ?? \"\"] ?? \"\")}\n                            </span>\n                        ))}\n                    </div>\n                ))}\n                {children}\n            </div>\n        );\n    },\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,IAAa,yBAAyB,EAClC,cAAc,EAAE,SAAS,YAAY,eAAiC;CAClE,MAAM,OAAO,WAAW,CAAC;CACzB,MAAM,UAAU,cAAc,CAAC;CAE/B,OACI,qBAAC,OAAD;EAAK,eAAY;EAAU,kBAAgB,KAAK;EAAhD,UAAA,CACK,KAAK,KAAK,KAAK,UACZ,oBAAC,OAAD;GAAiB,eAAY;GACxB,UAAA,QAAQ,KAAK,WACV,oBAAC,QAAD;IAEI,eAAa,gBAAgB,OAAO,SAAS;IAE5C,UAAA,OAAO,IAAI,OAAO,SAAS,OAAO,EAAE;GACnC,GAJG,OAAO,SAAS,OAAO,UAI1B,CACT;EACA,GATK,KASL,CACR,GACA,QACA;;AAEb,EACJ"}

package/dist/test/mocks/index.d.ts

@@ -0,0 +1,5 @@
+export { agGridReactMock } from "./agGridReact";
+export { agGridEnterpriseMock, getAgGridLicenseKey, resetAgGridLicense, } from "./agGridEnterprise";
+export { socketIoClientMock, createMockSocket, getMockSocket, resetMockSocket, } from "./socketIoClient";
+export type { MockSocket, SocketEventHandler } from "./socketIoClient";
+//# sourceMappingURL=index.d.ts.map

package/dist/test/mocks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/test/mocks/index.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EACH,oBAAoB,EACpB,mBAAmB,EACnB,kBAAkB,GACrB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACH,kBAAkB,EAClB,gBAAgB,EAChB,aAAa,EACb,eAAe,GAClB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC"}