-
- );
- }
-
- const isInitializingApp = initAppState !== InitAppState.InitCompleted;
-
return (
- <>
- {authState === AuthState.NotLoggedIn ? (
-
- Checking if user is signed in...
-
-
- Restoring working session...
-
-
- 
-
- ) : (
- isInitializingApp && (
- FMU Analysis
-Please sign in to continue.
- -
- 
- {makeStateMessages()}
-
- )
- )}
-
- <>
-
-
+
+
+
);
}
diff --git a/frontend/src/GlobalErrorBoundary.tsx b/frontend/src/GlobalErrorBoundary.tsx
index 196486049..62e3f785b 100644
--- a/frontend/src/GlobalErrorBoundary.tsx
+++ b/frontend/src/GlobalErrorBoundary.tsx
@@ -59,7 +59,7 @@ export class GlobalErrorBoundary extends React.Component
The application was terminated due to the following error:
-
+ = {};
+ private _enabledLoggers: Set = new Set();
+ loggers: Record = Object.create(null);
+
+ constructor() {
+ // Initialize the global logger registry from localStorage if it exists
+ const storedRegistry = getDebugSetting(DEBUG_SETTING_NAME);
+ if (storedRegistry) {
+ try {
+ const parsed = JSON.parse(storedRegistry);
+ if (!isArray(parsed)) {
+ console.error("Stored enabled loggers is not an array");
+ return;
+ }
+ for (const loggerName of parsed) {
+ if (typeof loggerName !== "string") {
+ console.error(`Invalid logger name: ${loggerName}`);
+ continue;
+ }
+ this._enabledLoggers.add(loggerName);
+ }
+ } catch (error) {
+ console.error("Failed to parse enabled loggers entry from localStorage:", error);
+ }
+ }
+ }
+
+ private getLogger(name: string): Logger {
+ return this._registry[name];
+ }
+
+ private setLoggerEnabled(name: string, enabled: boolean) {
+ if (enabled) {
+ if (!this._enabledLoggers.has(name)) {
+ this._enabledLoggers.add(name);
+ this.getLogger(name).enable();
+ }
+ } else {
+ this._enabledLoggers.delete(name);
+ this.getLogger(name).disable();
+ }
+
+ this.updateDebugSetting();
+ }
+
+ private updateDebugSetting() {
+ // Update the localStorage entry with the current enabled loggers
+ const enabledLoggersArray = Array.from(this._enabledLoggers);
+ setDebugSetting(DEBUG_SETTING_NAME, JSON.stringify(enabledLoggersArray));
+ }
+
+ registerLogger(name: TName, color?: string): Logger {
+ if (!isValidLoggerName(name)) {
+ throw Error(`Invalid logger name: "${name}". Must start with an uppercase letter and end with a letter.`);
+ }
+
+ if (name in this._registry) {
+ console.warn(`Logger with name "${name}" already exists. Returning existing logger.`);
+ return this.getLogger(name);
+ }
+
+ const loggerColor = color ?? getNextColor();
+ const logger = new Logger(name, loggerColor);
+ this._registry[name] = logger;
+ this.loggers[name] = Object.create(null);
+ this.loggers[name]["enable"] = () => {
+ this.setLoggerEnabled(name, true);
+ return `Logger "${name}" enabled.`;
+ };
+ this.loggers[name]["disable"] = () => {
+ this.setLoggerEnabled(name, false);
+ return `Logger "${name}" disabled.`;
+ };
+
+ if (this._enabledLoggers.has(name)) {
+ this.getLogger(name).enable();
+ }
+
+ return this.getLogger(name);
+ }
+
+ enableAll() {
+ for (const name in this._registry) {
+ this.setLoggerEnabled(name, true);
+ }
+ this.updateDebugSetting();
+ }
+
+ disableAll() {
+ for (const name in this._registry) {
+ this.setLoggerEnabled(name, false);
+ }
+ this.updateDebugSetting();
+ }
+}
+
+export const globalLog = new GlobalLog();
+
+const log = Object.create(null);
+log.loggers = globalLog.loggers;
+log.enableAll = () => globalLog.enableAll();
+log.disableAll = () => globalLog.disableAll();
+// @ts-expect-error This is a global variable for easy access in the application
+globalThis.log = log;
diff --git a/frontend/src/WorkbenchWrapper.tsx b/frontend/src/WorkbenchWrapper.tsx
new file mode 100644
index 000000000..dc99f2e3b
--- /dev/null
+++ b/frontend/src/WorkbenchWrapper.tsx
@@ -0,0 +1,78 @@
+import React from "react";
+
+import { useQueryClient } from "@tanstack/react-query";
+import { GuiState, useGuiValue } from "@framework/GuiMessageBroker";
+import { ActiveSessionBoundary } from "@framework/internal/components/ActiveSessionBoundary";
+import { ActiveSessionRecoveryDialog } from "@framework/internal/components/ActiveSessionRecoveryDialog/activeSessionRecoveryDialog";
+import { CreateSnapshotDialog } from "@framework/internal/components/CreateSnapshotDialog/createSnapshotDialog";
+import { LoadingOverlay } from "@framework/internal/components/LoadingOverlay";
+import { MultiSessionsRecoveryDialog } from "@framework/internal/components/MultiSessionsRecoveryDialog";
+import { LeftNavBar, RightNavBar } from "@framework/internal/components/NavBar";
+import { SaveSessionDialog } from "@framework/internal/components/SaveSessionDialog/saveSessionDialog";
+import { SelectEnsemblesDialog } from "@framework/internal/components/SelectEnsemblesDialog";
+import { SettingsContentPanels } from "@framework/internal/components/SettingsContentPanels";
+import { StartPage } from "@framework/internal/components/StartPage/StartPage";
+import { ToggleDevToolsButton } from "@framework/internal/components/ToggleDevToolsButton";
+import { TopBar } from "@framework/internal/components/TopBar/topBar";
+import { Workbench, WorkbenchTopic } from "@framework/Workbench";
+import "./modules/registerAllModules";
+import "./templates/registerAllTemplates";
+import { usePublishSubscribeTopicValue } from "@lib/utils/PublishSubscribeDelegate";
+import { TemplatesDialog } from "@framework/internal/components/TemplatesDialog/templatesDialog";
+
+export function WorkbenchWrapper() {
+ // Workbench must be kept as a state in order to keep it when any framework code is changed in dev mode.
+ // Otherwise, the workbench will be reset on every code change. This would cause it to loose its state and will
+ // cause the app to crash.
+ const queryClient = useQueryClient();
+ const [workbench] = React.useState(new Workbench(queryClient));
+ const [isInitialized, setIsInitialized] = React.useState(false);
+ const isSessionLoading = useGuiValue(workbench.getGuiMessageBroker(), GuiState.IsLoadingSession);
+ const hasActiveSession = usePublishSubscribeTopicValue(workbench, WorkbenchTopic.HAS_ACTIVE_SESSION);
+
+ React.useEffect(
+ function initApp() {
+ workbench.initialize().then(() => {
+ setIsInitialized(true);
+ });
+ },
+ [workbench],
+ );
+
+ let content: React.ReactNode;
+ if (!isInitialized) {
+ content =
+
+ ) => {
});
};
+export const getSessionsMetadataQueryKey = (options?: Options) => [
+ createQueryKey("getSessionsMetadata", options),
+];
+
+export const getSessionsMetadataOptions = (options?: Options) => {
+ return queryOptions({
+ queryFn: async ({ queryKey, signal }) => {
+ const { data } = await getSessionsMetadata({
+ ...options,
+ ...queryKey[0],
+ signal,
+ throwOnError: true,
+ });
+ return data;
+ },
+ queryKey: getSessionsMetadataQueryKey(options),
+ });
+};
+
+export const createSessionQueryKey = (options: Options) => [
+ createQueryKey("createSession", options),
+];
+
+export const createSessionOptions = (options: Options) => {
+ return queryOptions({
+ queryFn: async ({ queryKey, signal }) => {
+ const { data } = await createSession({
+ ...options,
+ ...queryKey[0],
+ signal,
+ throwOnError: true,
+ });
+ return data;
+ },
+ queryKey: createSessionQueryKey(options),
+ });
+};
+
+export const createSessionMutation = (options?: Partial>) => {
+ const mutationOptions: UseMutationOptions<
+ CreateSessionResponse_api,
+ AxiosError,
+ Options
+ > = {
+ mutationFn: async (localOptions) => {
+ const { data } = await createSession({
+ ...options,
+ ...localOptions,
+ throwOnError: true,
+ });
+ return data;
+ },
+ };
+ return mutationOptions;
+};
+
+export const deleteSessionMutation = (options?: Partial>) => {
+ const mutationOptions: UseMutationOptions, Options> = {
+ mutationFn: async (localOptions) => {
+ const { data } = await deleteSession({
+ ...options,
+ ...localOptions,
+ throwOnError: true,
+ });
+ return data;
+ },
+ };
+ return mutationOptions;
+};
+
+export const getSessionQueryKey = (options: Options) => [createQueryKey("getSession", options)];
+
+export const getSessionOptions = (options: Options) => {
+ return queryOptions({
+ queryFn: async ({ queryKey, signal }) => {
+ const { data } = await getSession({
+ ...options,
+ ...queryKey[0],
+ signal,
+ throwOnError: true,
+ });
+ return data;
+ },
+ queryKey: getSessionQueryKey(options),
+ });
+};
+
+export const updateSessionMutation = (options?: Partial>) => {
+ const mutationOptions: UseMutationOptions, Options> = {
+ mutationFn: async (localOptions) => {
+ const { data } = await updateSession({
+ ...options,
+ ...localOptions,
+ throwOnError: true,
+ });
+ return data;
+ },
+ };
+ return mutationOptions;
+};
+
+export const getSessionMetadataQueryKey = (options: Options) => [
+ createQueryKey("getSessionMetadata", options),
+];
+
+export const getSessionMetadataOptions = (options: Options) => {
+ return queryOptions({
+ queryFn: async ({ queryKey, signal }) => {
+ const { data } = await getSessionMetadata({
+ ...options,
+ ...queryKey[0],
+ signal,
+ throwOnError: true,
+ });
+ return data;
+ },
+ queryKey: getSessionMetadataQueryKey(options),
+ });
+};
+
+export const getRecentSnapshotsQueryKey = (options?: Options) => [
+ createQueryKey("getRecentSnapshots", options),
+];
+
+export const getRecentSnapshotsOptions = (options?: Options) => {
+ return queryOptions({
+ queryFn: async ({ queryKey, signal }) => {
+ const { data } = await getRecentSnapshots({
+ ...options,
+ ...queryKey[0],
+ signal,
+ throwOnError: true,
+ });
+ return data;
+ },
+ queryKey: getRecentSnapshotsQueryKey(options),
+ });
+};
+
+const createInfiniteParams = [0], "body" | "headers" | "path" | "query">>(
+ queryKey: QueryKey,
+ page: K,
+) => {
+ const params = queryKey[0];
+ if (page.body) {
+ params.body = {
+ ...(queryKey[0].body as any),
+ ...(page.body as any),
+ };
+ }
+ if (page.headers) {
+ params.headers = {
+ ...queryKey[0].headers,
+ ...page.headers,
+ };
+ }
+ if (page.path) {
+ params.path = {
+ ...(queryKey[0].path as any),
+ ...(page.path as any),
+ };
+ }
+ if (page.query) {
+ params.query = {
+ ...(queryKey[0].query as any),
+ ...(page.query as any),
+ };
+ }
+ return params as unknown as typeof page;
+};
+
+export const getRecentSnapshotsInfiniteQueryKey = (
+ options?: Options,
+): QueryKey> => [createQueryKey("getRecentSnapshots", options, true)];
+
+export const getRecentSnapshotsInfiniteOptions = (options?: Options) => {
+ return infiniteQueryOptions<
+ GetRecentSnapshotsResponse_api,
+ AxiosError,
+ InfiniteData,
+ QueryKey>,
+ number | null | Pick>[0], "body" | "headers" | "path" | "query">
+ >(
+ // @ts-ignore
+ {
+ queryFn: async ({ pageParam, queryKey, signal }) => {
+ // @ts-ignore
+ const page: Pick>[0], "body" | "headers" | "path" | "query"> =
+ typeof pageParam === "object"
+ ? pageParam
+ : {
+ query: {
+ offset: pageParam,
+ },
+ };
+ const params = createInfiniteParams(queryKey, page);
+ const { data } = await getRecentSnapshots({
+ ...options,
+ ...params,
+ signal,
+ throwOnError: true,
+ });
+ return data;
+ },
+ queryKey: getRecentSnapshotsInfiniteQueryKey(options),
+ },
+ );
+};
+
+export const getSnapshotsMetadataQueryKey = (options?: Options) => [
+ createQueryKey("getSnapshotsMetadata", options),
+];
+
+export const getSnapshotsMetadataOptions = (options?: Options) => {
+ return queryOptions({
+ queryFn: async ({ queryKey, signal }) => {
+ const { data } = await getSnapshotsMetadata({
+ ...options,
+ ...queryKey[0],
+ signal,
+ throwOnError: true,
+ });
+ return data;
+ },
+ queryKey: getSnapshotsMetadataQueryKey(options),
+ });
+};
+
+export const createSnapshotQueryKey = (options: Options) => [
+ createQueryKey("createSnapshot", options),
+];
+
+export const createSnapshotOptions = (options: Options) => {
+ return queryOptions({
+ queryFn: async ({ queryKey, signal }) => {
+ const { data } = await createSnapshot({
+ ...options,
+ ...queryKey[0],
+ signal,
+ throwOnError: true,
+ });
+ return data;
+ },
+ queryKey: createSnapshotQueryKey(options),
+ });
+};
+
+export const createSnapshotMutation = (options?: Partial>) => {
+ const mutationOptions: UseMutationOptions<
+ CreateSnapshotResponse_api,
+ AxiosError,
+ Options
+ > = {
+ mutationFn: async (localOptions) => {
+ const { data } = await createSnapshot({
+ ...options,
+ ...localOptions,
+ throwOnError: true,
+ });
+ return data;
+ },
+ };
+ return mutationOptions;
+};
+
+export const deleteSnapshotMutation = (options?: Partial>) => {
+ const mutationOptions: UseMutationOptions, Options> = {
+ mutationFn: async (localOptions) => {
+ const { data } = await deleteSnapshot({
+ ...options,
+ ...localOptions,
+ throwOnError: true,
+ });
+ return data;
+ },
+ };
+ return mutationOptions;
+};
+
+export const getSnapshotQueryKey = (options: Options) => [createQueryKey("getSnapshot", options)];
+
+export const getSnapshotOptions = (options: Options) => {
+ return queryOptions({
+ queryFn: async ({ queryKey, signal }) => {
+ const { data } = await getSnapshot({
+ ...options,
+ ...queryKey[0],
+ signal,
+ throwOnError: true,
+ });
+ return data;
+ },
+ queryKey: getSnapshotQueryKey(options),
+ });
+};
+
+export const updateSnapshotMutation = (options?: Partial>) => {
+ const mutationOptions: UseMutationOptions, Options> = {
+ mutationFn: async (localOptions) => {
+ const { data } = await updateSnapshot({
+ ...options,
+ ...localOptions,
+ throwOnError: true,
+ });
+ return data;
+ },
+ };
+ return mutationOptions;
+};
+
+export const getSnapshotMetadataQueryKey = (options: Options) => [
+ createQueryKey("getSnapshotMetadata", options),
+];
+
+export const getSnapshotMetadataOptions = (options: Options) => {
+ return queryOptions({
+ queryFn: async ({ queryKey, signal }) => {
+ const { data } = await getSnapshotMetadata({
+ ...options,
+ ...queryKey[0],
+ signal,
+ throwOnError: true,
+ });
+ return data;
+ },
+ queryKey: getSnapshotMetadataQueryKey(options),
+ });
+};
+
+export const snapshotPreviewQueryKey = (options: Options) => [
+ createQueryKey("snapshotPreview", options),
+];
+
+export const snapshotPreviewOptions = (options: Options) => {
+ return queryOptions({
+ queryFn: async ({ queryKey, signal }) => {
+ const { data } = await snapshotPreview({
+ ...options,
+ ...queryKey[0],
+ signal,
+ throwOnError: true,
+ });
+ return data;
+ },
+ queryKey: snapshotPreviewQueryKey(options),
+ });
+};
+
export const loginRouteQueryKey = (options?: Options) => [createQueryKey("loginRoute", options)];
export const loginRouteOptions = (options?: Options) => {
diff --git a/frontend/src/api/autogen/sdk.gen.ts b/frontend/src/api/autogen/sdk.gen.ts
index e3602b509..43847200d 100644
--- a/frontend/src/api/autogen/sdk.gen.ts
+++ b/frontend/src/api/autogen/sdk.gen.ts
@@ -194,6 +194,44 @@ import type {
GetVfpTableData_api,
GetVfpTableResponse_api,
GetVfpTableError_api,
+ GetSessionsMetadataData_api,
+ GetSessionsMetadataResponse_api,
+ GetSessionsMetadataError_api,
+ CreateSessionData_api,
+ CreateSessionResponse_api,
+ CreateSessionError_api,
+ DeleteSessionData_api,
+ DeleteSessionError_api,
+ GetSessionData_api,
+ GetSessionResponse_api,
+ GetSessionError_api,
+ UpdateSessionData_api,
+ UpdateSessionError_api,
+ GetSessionMetadataData_api,
+ GetSessionMetadataResponse_api,
+ GetSessionMetadataError_api,
+ GetRecentSnapshotsData_api,
+ GetRecentSnapshotsResponse_api,
+ GetRecentSnapshotsError_api,
+ GetSnapshotsMetadataData_api,
+ GetSnapshotsMetadataResponse_api,
+ GetSnapshotsMetadataError_api,
+ CreateSnapshotData_api,
+ CreateSnapshotResponse_api,
+ CreateSnapshotError_api,
+ DeleteSnapshotData_api,
+ DeleteSnapshotError_api,
+ GetSnapshotData_api,
+ GetSnapshotResponse_api,
+ GetSnapshotError_api,
+ UpdateSnapshotData_api,
+ UpdateSnapshotError_api,
+ GetSnapshotMetadataData_api,
+ GetSnapshotMetadataResponse_api,
+ GetSnapshotMetadataError_api,
+ SnapshotPreviewData_api,
+ SnapshotPreviewResponse_api,
+ SnapshotPreviewError_api,
LoginRouteData_api,
LoginRouteError_api,
AuthorizedCallbackRouteData_api,
@@ -1218,6 +1256,187 @@ export const getVfpTable = (options: Optio
});
};
+/**
+ * Get Sessions Metadata
+ */
+export const getSessionsMetadata = (
+ options?: Options,
+) => {
+ return (options?.client ?? client).get({
+ ...options,
+ url: "/sessions/sessions",
+ });
+};
+
+/**
+ * Create Session
+ */
+export const createSession = (
+ options: Options,
+) => {
+ return (options?.client ?? client).post({
+ ...options,
+ headers: {
+ "Content-Type": "application/json",
+ ...options?.headers,
+ },
+ url: "/sessions/sessions",
+ });
+};
+
+/**
+ * Delete Session
+ */
+export const deleteSession = (
+ options: Options,
+) => {
+ return (options?.client ?? client).delete({
+ ...options,
+ url: "/sessions/sessions/{session_id}",
+ });
+};
+
+/**
+ * Get Session
+ */
+export const getSession = (options: Options) => {
+ return (options?.client ?? client).get({
+ ...options,
+ url: "/sessions/sessions/{session_id}",
+ });
+};
+
+/**
+ * Update Session
+ */
+export const updateSession = (
+ options: Options,
+) => {
+ return (options?.client ?? client).put({
+ ...options,
+ headers: {
+ "Content-Type": "application/json",
+ ...options?.headers,
+ },
+ url: "/sessions/sessions/{session_id}",
+ });
+};
+
+/**
+ * Get Session Metadata
+ */
+export const getSessionMetadata = (
+ options: Options,
+) => {
+ return (options?.client ?? client).get({
+ ...options,
+ url: "/sessions/sessions/metadata/{session_id}",
+ });
+};
+
+/**
+ * Get Recent Snapshots
+ */
+export const getRecentSnapshots = (
+ options?: Options,
+) => {
+ return (options?.client ?? client).get({
+ ...options,
+ url: "/snapshots/recent_snapshots",
+ });
+};
+
+/**
+ * Get Snapshots Metadata
+ */
+export const getSnapshotsMetadata = (
+ options?: Options,
+) => {
+ return (options?.client ?? client).get({
+ ...options,
+ url: "/snapshots/snapshots",
+ });
+};
+
+/**
+ * Create Snapshot
+ */
+export const createSnapshot = (
+ options: Options,
+) => {
+ return (options?.client ?? client).post({
+ ...options,
+ headers: {
+ "Content-Type": "application/json",
+ ...options?.headers,
+ },
+ url: "/snapshots/snapshots",
+ });
+};
+
+/**
+ * Delete Snapshot
+ */
+export const deleteSnapshot = (
+ options: Options,
+) => {
+ return (options?.client ?? client).delete({
+ ...options,
+ url: "/snapshots/snapshots/{snapshot_id}",
+ });
+};
+
+/**
+ * Get Snapshot
+ */
+export const getSnapshot = (options: Options) => {
+ return (options?.client ?? client).get({
+ ...options,
+ url: "/snapshots/snapshots/{snapshot_id}",
+ });
+};
+
+/**
+ * Update Snapshot
+ */
+export const updateSnapshot = (
+ options: Options,
+) => {
+ return (options?.client ?? client).put({
+ ...options,
+ headers: {
+ "Content-Type": "application/json",
+ ...options?.headers,
+ },
+ url: "/snapshots/snapshots/{snapshot_id}",
+ });
+};
+
+/**
+ * Get Snapshot Metadata
+ */
+export const getSnapshotMetadata = (
+ options: Options,
+) => {
+ return (options?.client ?? client).get({
+ ...options,
+ url: "/snapshots/snapshots/metadata/{snapshot_id}",
+ });
+};
+
+/**
+ * Snapshot Preview
+ */
+export const snapshotPreview = (
+ options: Options,
+) => {
+ return (options?.client ?? client).get({
+ ...options,
+ responseType: "text",
+ url: "/snapshot-preview/{snapshot_id}",
+ });
+};
+
/**
* Login Route
*/
diff --git a/frontend/src/api/autogen/types.gen.ts b/frontend/src/api/autogen/types.gen.ts
index 6d6ca30ae..597dd9e4b 100644
--- a/frontend/src/api/autogen/types.gen.ts
+++ b/frontend/src/api/autogen/types.gen.ts
@@ -391,6 +391,18 @@ export type NetworkNode_api = {
children: Array;
};
+export type NewSession_api = {
+ title: string;
+ description: string | null;
+ content: string;
+};
+
+export type NewSnapshot_api = {
+ title: string;
+ description: string | null;
+ content: string;
+};
+
export enum NodeType_api {
PROD = "prod",
INJ = "inj",
@@ -676,6 +688,80 @@ export enum SensitivityType_api {
SCENARIO = "scenario",
}
+export type SessionDocument_api = {
+ id: string;
+ ownerId: string;
+ metadata: SessionMetadata_api;
+ content: string;
+};
+
+export type SessionMetadata_api = {
+ title: string;
+ description: string | null;
+ createdAt: string;
+ updatedAt: string;
+ version: number;
+ hash: string;
+};
+
+export type SessionMetadataWithId_api = {
+ id: string;
+ title: string;
+ description: string | null;
+ createdAt: string;
+ updatedAt: string;
+ version: number;
+};
+
+export type SessionUpdate_api = {
+ id: string;
+ metadata: SessionUserEditableMetadata_api;
+ content: string;
+};
+
+export type SessionUserEditableMetadata_api = {
+ title: string;
+ description?: string | null;
+};
+
+export type Snapshot_api = {
+ id: string;
+ metadata: SnapshotMetadata_api;
+ content: string;
+};
+
+export type SnapshotAccessLog_api = {
+ visitorId: string;
+ snapshotId: string;
+ visits: number;
+ firstVisitedAt: string | null;
+ lastVisitedAt: string | null;
+ snapshotMetadata: SnapshotMetadata_api;
+};
+
+export type SnapshotMetadata_api = {
+ ownerId: string;
+ title: string;
+ description: string | null;
+ createdAt: string;
+ updatedAt: string;
+ hash: string;
+};
+
+export type SnapshotUpdate_api = {
+ metadata: SnapshotUserEditableMetadata_api;
+};
+
+export type SnapshotUserEditableMetadata_api = {
+ title: string;
+ description?: string | null;
+};
+
+export enum SortDirection_api {
+ ASC = "asc",
+ DESC = "desc",
+}
+
export enum StatisticFunction_api {
MEAN = "MEAN",
MIN = "MIN",
@@ -1160,6 +1246,21 @@ export type WellboreTrajectory_api = {
northingArr: Array;
};
+export enum PrimaryServicesDatabaseAccessSessionAccessTypesSortBy_api {
+ CREATED_AT = "created_at",
+ UPDATED_AT = "updated_at",
+ TITLE = "title",
+ TITLE_LOWER = "title_lower",
+}
+
+export enum PrimaryServicesDatabaseAccessSnapshotAccessTypesSortBy_api {
+ CREATED_AT = "created_at",
+ UPDATED_AT = "updated_at",
+ TITLE = "title",
+ TITLE_LOWER = "title_lower",
+ LAST_VISITED_AT = "last_visited_at",
+}
+
export type GetFieldsData_api = {
body?: never;
path?: never;
@@ -1384,7 +1485,8 @@ export type GetDeltaEnsembleVectorListErrors_api = {
422: HttpValidationError_api;
};
-export type GetDeltaEnsembleVectorListError_api = GetDeltaEnsembleVectorListErrors_api[keyof GetDeltaEnsembleVectorListErrors_api];
+export type GetDeltaEnsembleVectorListError_api =
+ GetDeltaEnsembleVectorListErrors_api[keyof GetDeltaEnsembleVectorListErrors_api];
export type GetDeltaEnsembleVectorListResponses_api = {
/**
@@ -1432,7 +1534,8 @@ export type GetRealizationsVectorDataErrors_api = {
422: HttpValidationError_api;
};
-export type GetRealizationsVectorDataError_api = GetRealizationsVectorDataErrors_api[keyof GetRealizationsVectorDataErrors_api];
+export type GetRealizationsVectorDataError_api =
+ GetRealizationsVectorDataErrors_api[keyof GetRealizationsVectorDataErrors_api];
export type GetRealizationsVectorDataResponses_api = {
/**
@@ -1572,7 +1675,8 @@ export type GetHistoricalVectorDataErrors_api = {
422: HttpValidationError_api;
};
-export type GetHistoricalVectorDataError_api = GetHistoricalVectorDataErrors_api[keyof GetHistoricalVectorDataErrors_api];
+export type GetHistoricalVectorDataError_api =
+ GetHistoricalVectorDataErrors_api[keyof GetHistoricalVectorDataErrors_api];
export type GetHistoricalVectorDataResponses_api = {
/**
@@ -1581,7 +1685,8 @@ export type GetHistoricalVectorDataResponses_api = {
200: VectorHistoricalData_api;
};
-export type GetHistoricalVectorDataResponse_api = GetHistoricalVectorDataResponses_api[keyof GetHistoricalVectorDataResponses_api];
+export type GetHistoricalVectorDataResponse_api =
+ GetHistoricalVectorDataResponses_api[keyof GetHistoricalVectorDataResponses_api];
export type GetStatisticalVectorDataData_api = {
body?: never;
@@ -1623,7 +1728,8 @@ export type GetStatisticalVectorDataErrors_api = {
422: HttpValidationError_api;
};
-export type GetStatisticalVectorDataError_api = GetStatisticalVectorDataErrors_api[keyof GetStatisticalVectorDataErrors_api];
+export type GetStatisticalVectorDataError_api =
+ GetStatisticalVectorDataErrors_api[keyof GetStatisticalVectorDataErrors_api];
export type GetStatisticalVectorDataResponses_api = {
/**
@@ -2084,7 +2190,8 @@ export type PostGetSurfaceIntersectionErrors_api = {
422: HttpValidationError_api;
};
-export type PostGetSurfaceIntersectionError_api = PostGetSurfaceIntersectionErrors_api[keyof PostGetSurfaceIntersectionErrors_api];
+export type PostGetSurfaceIntersectionError_api =
+ PostGetSurfaceIntersectionErrors_api[keyof PostGetSurfaceIntersectionErrors_api];
export type PostGetSurfaceIntersectionResponses_api = {
/**
@@ -2237,7 +2344,8 @@ export type GetMisfitSurfaceDataResponses_api = {
200: Array;
};
-export type GetMisfitSurfaceDataResponse_api = GetMisfitSurfaceDataResponses_api[keyof GetMisfitSurfaceDataResponses_api];
+export type GetMisfitSurfaceDataResponse_api =
+ GetMisfitSurfaceDataResponses_api[keyof GetMisfitSurfaceDataResponses_api];
export type DeprecatedGetStratigraphicUnitsData_api = {
body?: never;
@@ -2764,7 +2872,8 @@ export type GetRealizationFlowNetworkErrors_api = {
422: HttpValidationError_api;
};
-export type GetRealizationFlowNetworkError_api = GetRealizationFlowNetworkErrors_api[keyof GetRealizationFlowNetworkErrors_api];
+export type GetRealizationFlowNetworkError_api =
+ GetRealizationFlowNetworkErrors_api[keyof GetRealizationFlowNetworkErrors_api];
export type GetRealizationFlowNetworkResponses_api = {
/**
@@ -2852,7 +2961,8 @@ export type GetWellCompletionsDataResponses_api = {
200: WellCompletionsData_api;
};
-export type GetWellCompletionsDataResponse_api = GetWellCompletionsDataResponses_api[keyof GetWellCompletionsDataResponses_api];
+export type GetWellCompletionsDataResponse_api =
+ GetWellCompletionsDataResponses_api[keyof GetWellCompletionsDataResponses_api];
export type GetDrilledWellboreHeadersData_api = {
body?: never;
@@ -2874,7 +2984,8 @@ export type GetDrilledWellboreHeadersErrors_api = {
422: HttpValidationError_api;
};
-export type GetDrilledWellboreHeadersError_api = GetDrilledWellboreHeadersErrors_api[keyof GetDrilledWellboreHeadersErrors_api];
+export type GetDrilledWellboreHeadersError_api =
+ GetDrilledWellboreHeadersErrors_api[keyof GetDrilledWellboreHeadersErrors_api];
export type GetDrilledWellboreHeadersResponses_api = {
/**
@@ -2941,7 +3052,8 @@ export type GetWellborePickIdentifiersErrors_api = {
422: HttpValidationError_api;
};
-export type GetWellborePickIdentifiersError_api = GetWellborePickIdentifiersErrors_api[keyof GetWellborePickIdentifiersErrors_api];
+export type GetWellborePickIdentifiersError_api =
+ GetWellborePickIdentifiersErrors_api[keyof GetWellborePickIdentifiersErrors_api];
export type GetWellborePickIdentifiersResponses_api = {
/**
@@ -3122,7 +3234,8 @@ export type GetWellboreCompletionsResponses_api = {
200: Array;
};
-export type GetWellboreCompletionsResponse_api = GetWellboreCompletionsResponses_api[keyof GetWellboreCompletionsResponses_api];
+export type GetWellboreCompletionsResponse_api =
+ GetWellboreCompletionsResponses_api[keyof GetWellboreCompletionsResponses_api];
export type GetWellboreCasingsData_api = {
body?: never;
@@ -3175,7 +3288,8 @@ export type GetWellborePerforationsErrors_api = {
422: HttpValidationError_api;
};
-export type GetWellborePerforationsError_api = GetWellborePerforationsErrors_api[keyof GetWellborePerforationsErrors_api];
+export type GetWellborePerforationsError_api =
+ GetWellborePerforationsErrors_api[keyof GetWellborePerforationsErrors_api];
export type GetWellborePerforationsResponses_api = {
/**
@@ -3184,7 +3298,8 @@ export type GetWellborePerforationsResponses_api = {
200: Array;
};
-export type GetWellborePerforationsResponse_api = GetWellborePerforationsResponses_api[keyof GetWellborePerforationsResponses_api];
+export type GetWellborePerforationsResponse_api =
+ GetWellborePerforationsResponses_api[keyof GetWellborePerforationsResponses_api];
export type GetWellboreLogCurveHeadersData_api = {
body?: never;
@@ -3210,7 +3325,8 @@ export type GetWellboreLogCurveHeadersErrors_api = {
422: HttpValidationError_api;
};
-export type GetWellboreLogCurveHeadersError_api = GetWellboreLogCurveHeadersErrors_api[keyof GetWellboreLogCurveHeadersErrors_api];
+export type GetWellboreLogCurveHeadersError_api =
+ GetWellboreLogCurveHeadersErrors_api[keyof GetWellboreLogCurveHeadersErrors_api];
export type GetWellboreLogCurveHeadersResponses_api = {
/**
@@ -3298,7 +3414,8 @@ export type GetSeismicCubeMetaListResponses_api = {
200: Array;
};
-export type GetSeismicCubeMetaListResponse_api = GetSeismicCubeMetaListResponses_api[keyof GetSeismicCubeMetaListResponses_api];
+export type GetSeismicCubeMetaListResponse_api =
+ GetSeismicCubeMetaListResponses_api[keyof GetSeismicCubeMetaListResponses_api];
export type GetInlineSliceData_api = {
body?: never;
@@ -3549,7 +3666,8 @@ export type GetPolygonsDirectoryResponses_api = {
200: Array;
};
-export type GetPolygonsDirectoryResponse_api = GetPolygonsDirectoryResponses_api[keyof GetPolygonsDirectoryResponses_api];
+export type GetPolygonsDirectoryResponse_api =
+ GetPolygonsDirectoryResponses_api[keyof GetPolygonsDirectoryResponses_api];
export type GetPolygonsDataData_api = {
body?: never;
@@ -3828,6 +3946,435 @@ export type GetVfpTableResponses_api = {
export type GetVfpTableResponse_api = GetVfpTableResponses_api[keyof GetVfpTableResponses_api];
+export type GetSessionsMetadataData_api = {
+ body?: never;
+ path?: never;
+ query?: {
+ /**
+ * Sort the result by
+ */
+ sort_by?: PrimaryServicesDatabaseAccessSessionAccessTypesSortBy_api | null;
+ /**
+ * Sort direction: 'asc' or 'desc'
+ */
+ sort_direction?: SortDirection_api | null;
+ /**
+ * Limit the number of results
+ */
+ limit?: number | null;
+ t?: number;
+ };
+ url: "/sessions/sessions";
+};
+
+export type GetSessionsMetadataErrors_api = {
+ /**
+ * Validation Error
+ */
+ 422: HttpValidationError_api;
+};
+
+export type GetSessionsMetadataError_api = GetSessionsMetadataErrors_api[keyof GetSessionsMetadataErrors_api];
+
+export type GetSessionsMetadataResponses_api = {
+ /**
+ * Successful Response
+ */
+ 200: Array;
+};
+
+export type GetSessionsMetadataResponse_api = GetSessionsMetadataResponses_api[keyof GetSessionsMetadataResponses_api];
+
+export type CreateSessionData_api = {
+ body: NewSession_api;
+ path?: never;
+ query?: {
+ t?: number;
+ };
+ url: "/sessions/sessions";
+};
+
+export type CreateSessionErrors_api = {
+ /**
+ * Validation Error
+ */
+ 422: HttpValidationError_api;
+};
+
+export type CreateSessionError_api = CreateSessionErrors_api[keyof CreateSessionErrors_api];
+
+export type CreateSessionResponses_api = {
+ /**
+ * Successful Response
+ */
+ 200: string;
+};
+
+export type CreateSessionResponse_api = CreateSessionResponses_api[keyof CreateSessionResponses_api];
+
+export type DeleteSessionData_api = {
+ body?: never;
+ path: {
+ session_id: string;
+ };
+ query?: {
+ t?: number;
+ };
+ url: "/sessions/sessions/{session_id}";
+};
+
+export type DeleteSessionErrors_api = {
+ /**
+ * Validation Error
+ */
+ 422: HttpValidationError_api;
+};
+
+export type DeleteSessionError_api = DeleteSessionErrors_api[keyof DeleteSessionErrors_api];
+
+export type DeleteSessionResponses_api = {
+ /**
+ * Successful Response
+ */
+ 200: unknown;
+};
+
+export type GetSessionData_api = {
+ body?: never;
+ path: {
+ session_id: string;
+ };
+ query?: {
+ t?: number;
+ };
+ url: "/sessions/sessions/{session_id}";
+};
+
+export type GetSessionErrors_api = {
+ /**
+ * Validation Error
+ */
+ 422: HttpValidationError_api;
+};
+
+export type GetSessionError_api = GetSessionErrors_api[keyof GetSessionErrors_api];
+
+export type GetSessionResponses_api = {
+ /**
+ * Successful Response
+ */
+ 200: SessionDocument_api;
+};
+
+export type GetSessionResponse_api = GetSessionResponses_api[keyof GetSessionResponses_api];
+
+export type UpdateSessionData_api = {
+ body: SessionUpdate_api;
+ path: {
+ session_id: string;
+ };
+ query?: {
+ t?: number;
+ };
+ url: "/sessions/sessions/{session_id}";
+};
+
+export type UpdateSessionErrors_api = {
+ /**
+ * Validation Error
+ */
+ 422: HttpValidationError_api;
+};
+
+export type UpdateSessionError_api = UpdateSessionErrors_api[keyof UpdateSessionErrors_api];
+
+export type UpdateSessionResponses_api = {
+ /**
+ * Successful Response
+ */
+ 200: unknown;
+};
+
+export type GetSessionMetadataData_api = {
+ body?: never;
+ path: {
+ session_id: string;
+ };
+ query?: {
+ t?: number;
+ };
+ url: "/sessions/sessions/metadata/{session_id}";
+};
+
+export type GetSessionMetadataErrors_api = {
+ /**
+ * Validation Error
+ */
+ 422: HttpValidationError_api;
+};
+
+export type GetSessionMetadataError_api = GetSessionMetadataErrors_api[keyof GetSessionMetadataErrors_api];
+
+export type GetSessionMetadataResponses_api = {
+ /**
+ * Successful Response
+ */
+ 200: SessionMetadata_api;
+};
+
+export type GetSessionMetadataResponse_api = GetSessionMetadataResponses_api[keyof GetSessionMetadataResponses_api];
+
+export type GetRecentSnapshotsData_api = {
+ body?: never;
+ path?: never;
+ query?: {
+ /**
+ * Sort the result by
+ */
+ sort_by?: PrimaryServicesDatabaseAccessSnapshotAccessTypesSortBy_api | null;
+ /**
+ * Sort direction: 'asc' or 'desc'
+ */
+ sort_direction?: SortDirection_api | null;
+ /**
+ * Limit the number of results
+ */
+ limit?: number | null;
+ /**
+ * The offset of the results
+ */
+ offset?: number | null;
+ t?: number;
+ };
+ url: "/snapshots/recent_snapshots";
+};
+
+export type GetRecentSnapshotsErrors_api = {
+ /**
+ * Validation Error
+ */
+ 422: HttpValidationError_api;
+};
+
+export type GetRecentSnapshotsError_api = GetRecentSnapshotsErrors_api[keyof GetRecentSnapshotsErrors_api];
+
+export type GetRecentSnapshotsResponses_api = {
+ /**
+ * Successful Response
+ */
+ 200: Array;
+};
+
+export type GetRecentSnapshotsResponse_api = GetRecentSnapshotsResponses_api[keyof GetRecentSnapshotsResponses_api];
+
+export type GetSnapshotsMetadataData_api = {
+ body?: never;
+ path?: never;
+ query?: {
+ /**
+ * Sort the result by
+ */
+ sort_by?: PrimaryServicesDatabaseAccessSnapshotAccessTypesSortBy_api | null;
+ /**
+ * Sort direction: 'asc' or 'desc'
+ */
+ sort_direction?: SortDirection_api | null;
+ /**
+ * Limit the number of results
+ */
+ limit?: number | null;
+ t?: number;
+ };
+ url: "/snapshots/snapshots";
+};
+
+export type GetSnapshotsMetadataErrors_api = {
+ /**
+ * Validation Error
+ */
+ 422: HttpValidationError_api;
+};
+
+export type GetSnapshotsMetadataError_api = GetSnapshotsMetadataErrors_api[keyof GetSnapshotsMetadataErrors_api];
+
+export type GetSnapshotsMetadataResponses_api = {
+ /**
+ * Successful Response
+ */
+ 200: Array;
+};
+
+export type GetSnapshotsMetadataResponse_api =
+ GetSnapshotsMetadataResponses_api[keyof GetSnapshotsMetadataResponses_api];
+
+export type CreateSnapshotData_api = {
+ body: NewSnapshot_api;
+ path?: never;
+ query?: {
+ t?: number;
+ };
+ url: "/snapshots/snapshots";
+};
+
+export type CreateSnapshotErrors_api = {
+ /**
+ * Validation Error
+ */
+ 422: HttpValidationError_api;
+};
+
+export type CreateSnapshotError_api = CreateSnapshotErrors_api[keyof CreateSnapshotErrors_api];
+
+export type CreateSnapshotResponses_api = {
+ /**
+ * Successful Response
+ */
+ 200: string;
+};
+
+export type CreateSnapshotResponse_api = CreateSnapshotResponses_api[keyof CreateSnapshotResponses_api];
+
+export type DeleteSnapshotData_api = {
+ body?: never;
+ path: {
+ snapshot_id: string;
+ };
+ query?: {
+ t?: number;
+ };
+ url: "/snapshots/snapshots/{snapshot_id}";
+};
+
+export type DeleteSnapshotErrors_api = {
+ /**
+ * Validation Error
+ */
+ 422: HttpValidationError_api;
+};
+
+export type DeleteSnapshotError_api = DeleteSnapshotErrors_api[keyof DeleteSnapshotErrors_api];
+
+export type DeleteSnapshotResponses_api = {
+ /**
+ * Successful Response
+ */
+ 200: unknown;
+};
+
+export type GetSnapshotData_api = {
+ body?: never;
+ path: {
+ snapshot_id: string;
+ };
+ query?: {
+ t?: number;
+ };
+ url: "/snapshots/snapshots/{snapshot_id}";
+};
+
+export type GetSnapshotErrors_api = {
+ /**
+ * Validation Error
+ */
+ 422: HttpValidationError_api;
+};
+
+export type GetSnapshotError_api = GetSnapshotErrors_api[keyof GetSnapshotErrors_api];
+
+export type GetSnapshotResponses_api = {
+ /**
+ * Successful Response
+ */
+ 200: Snapshot_api;
+};
+
+export type GetSnapshotResponse_api = GetSnapshotResponses_api[keyof GetSnapshotResponses_api];
+
+export type UpdateSnapshotData_api = {
+ body: SnapshotUpdate_api;
+ path: {
+ snapshot_id: string;
+ };
+ query?: {
+ t?: number;
+ };
+ url: "/snapshots/snapshots/{snapshot_id}";
+};
+
+export type UpdateSnapshotErrors_api = {
+ /**
+ * Validation Error
+ */
+ 422: HttpValidationError_api;
+};
+
+export type UpdateSnapshotError_api = UpdateSnapshotErrors_api[keyof UpdateSnapshotErrors_api];
+
+export type UpdateSnapshotResponses_api = {
+ /**
+ * Successful Response
+ */
+ 200: unknown;
+};
+
+export type GetSnapshotMetadataData_api = {
+ body?: never;
+ path: {
+ snapshot_id: string;
+ };
+ query?: {
+ t?: number;
+ };
+ url: "/snapshots/snapshots/metadata/{snapshot_id}";
+};
+
+export type GetSnapshotMetadataErrors_api = {
+ /**
+ * Validation Error
+ */
+ 422: HttpValidationError_api;
+};
+
+export type GetSnapshotMetadataError_api = GetSnapshotMetadataErrors_api[keyof GetSnapshotMetadataErrors_api];
+
+export type GetSnapshotMetadataResponses_api = {
+ /**
+ * Successful Response
+ */
+ 200: SnapshotMetadata_api;
+};
+
+export type GetSnapshotMetadataResponse_api = GetSnapshotMetadataResponses_api[keyof GetSnapshotMetadataResponses_api];
+
+export type SnapshotPreviewData_api = {
+ body?: never;
+ path: {
+ snapshot_id: string;
+ };
+ query?: {
+ t?: number;
+ };
+ url: "/snapshot-preview/{snapshot_id}";
+};
+
+export type SnapshotPreviewErrors_api = {
+ /**
+ * Validation Error
+ */
+ 422: HttpValidationError_api;
+};
+
+export type SnapshotPreviewError_api = SnapshotPreviewErrors_api[keyof SnapshotPreviewErrors_api];
+
+export type SnapshotPreviewResponses_api = {
+ /**
+ * Successful Response
+ */
+ 200: string;
+};
+
+export type SnapshotPreviewResponse_api = SnapshotPreviewResponses_api[keyof SnapshotPreviewResponses_api];
+
export type LoginRouteData_api = {
body?: never;
path?: never;
diff --git a/frontend/src/framework/ConfirmationService.ts b/frontend/src/framework/ConfirmationService.ts
new file mode 100644
index 000000000..e8cd52a3d
--- /dev/null
+++ b/frontend/src/framework/ConfirmationService.ts
@@ -0,0 +1,41 @@
+import type { ButtonProps } from "@lib/components/Button/button";
+
+export type ConfirmAction = {
+ id: T;
+ label: string;
+ color?: ButtonProps["color"];
+};
+
+export type ConfirmOptions = {
+ title: string;
+ message: string;
+ actions: ConfirmAction[];
+};
+
+export class ConfirmationService {
+ private _resolver: ((result: T) => void) | null = null;
+ private _showDialogCallback: ((options: ConfirmOptions) => void) | null = null;
+
+ setShowDialogCallback(callback: (options: ConfirmOptions) => void) {
+ this._showDialogCallback = callback;
+ }
+
+ confirm(options: ConfirmOptions): Promise {
+ if (!this._showDialogCallback) {
+ throw new Error("ConfirmationService: Show dialog callback is not set.");
+ }
+
+ return new Promise((resolve) => {
+ this._resolver = resolve;
+ this._showDialogCallback!(options);
+ });
+ }
+
+ resolve(result: T): void {
+ this._resolver?.(result);
+ this._resolver = null; // Reset resolver after resolving
+ }
+}
+
+// Making a singleton instance of ConfirmationService
+export const confirmationService = new ConfirmationService();
diff --git a/frontend/src/framework/EnsembleTimestampsStore.ts b/frontend/src/framework/EnsembleTimestampsStore.ts
new file mode 100644
index 000000000..bbff5eff6
--- /dev/null
+++ b/frontend/src/framework/EnsembleTimestampsStore.ts
@@ -0,0 +1,45 @@
+import type { RegularEnsembleIdent } from "./RegularEnsembleIdent";
+
+export type EnsembleTimestamps = {
+ caseUpdatedAtUtcMs: number;
+ dataUpdatedAtUtcMs: number;
+};
+
+class EnsembleTimestampsStoreImpl {
+ private _timestamps: Map = new Map();
+
+ setAll(timestamps: Map) {
+ this._timestamps = timestamps;
+ }
+
+ update(timestamps: Map) {
+ for (const [key, value] of timestamps) {
+ this._timestamps.set(key, value);
+ }
+ }
+
+ getLatestTimestamps(...idents: RegularEnsembleIdent[]): EnsembleTimestamps {
+ let dataUpdatedAt = 0;
+ let caseUpdatedAt = 0;
+
+ for (const ident of idents) {
+ const ts = this._timestamps.get(ident.toString());
+ if (!ts) continue;
+
+ if (ts.dataUpdatedAtUtcMs && ts.dataUpdatedAtUtcMs > dataUpdatedAt) {
+ dataUpdatedAt = ts.dataUpdatedAtUtcMs;
+ }
+ if (ts.caseUpdatedAtUtcMs && ts.caseUpdatedAtUtcMs > caseUpdatedAt) {
+ caseUpdatedAt = ts.caseUpdatedAtUtcMs;
+ }
+ }
+
+ return { dataUpdatedAtUtcMs: dataUpdatedAt, caseUpdatedAtUtcMs: caseUpdatedAt };
+ }
+
+ clear() {
+ this._timestamps.clear();
+ }
+}
+
+export const EnsembleTimestampsStore = new EnsembleTimestampsStoreImpl();
diff --git a/frontend/src/framework/GlobalAtoms.ts b/frontend/src/framework/GlobalAtoms.ts
index ca67c6b69..0db45e6c4 100644
--- a/frontend/src/framework/GlobalAtoms.ts
+++ b/frontend/src/framework/GlobalAtoms.ts
@@ -1,4 +1,3 @@
-
import { atom } from "jotai";
import { isEqual } from "lodash";
diff --git a/frontend/src/framework/GuiMessageBroker.ts b/frontend/src/framework/GuiMessageBroker.ts
index d0c17c225..bf2026e13 100644
--- a/frontend/src/framework/GuiMessageBroker.ts
+++ b/frontend/src/framework/GuiMessageBroker.ts
@@ -8,8 +8,6 @@ import type { UnsavedChangesAction } from "./types/unsavedChangesAction";
export enum LeftDrawerContent {
ModuleSettings = "ModuleSettings",
- ModulesList = "ModulesList",
- TemplatesList = "TemplatesList",
SyncSettings = "SyncSettings",
ColorPaletteSettings = "ColorPaletteSettings",
}
@@ -17,19 +15,29 @@ export enum LeftDrawerContent {
export enum RightDrawerContent {
RealizationFilterSettings = "RealizationFilterSettings",
ModuleInstanceLog = "ModuleInstanceLog",
+ ModulesList = "ModulesList",
}
export enum GuiState {
LeftDrawerContent = "leftDrawerContent",
RightDrawerContent = "rightDrawerContent",
LeftSettingsPanelWidthInPercent = "leftSettingsPanelWidthInPercent",
- ActiveModuleInstanceId = "activeModuleInstanceId",
DataChannelConnectionLayerVisible = "dataChannelConnectionLayerVisible",
DevToolsVisible = "devToolsVisible",
EditDataChannelConnections = "editDataChannelConnections",
RightSettingsPanelWidthInPercent = "rightSettingsPanelWidthInPercent",
AppInitialized = "appInitialized",
NumberOfUnsavedRealizationFilters = "numberOfUnsavedRealizationFilters",
+ SaveSessionDialogOpen = "saveSessionDialogOpen",
+ SessionHasUnsavedChanges = "sessionHasUnsavedChanges",
+ IsSavingSession = "isSavingSession",
+ IsMakingSnapshot = "isMakingSnapshot",
+ IsLoadingSession = "isLoadingSession",
+ EnsembleDialogOpen = "ensembleDialogOpen",
+ MultiSessionsRecoveryDialogOpen = "multiSessionsRecoveryDialogOpen",
+ ActiveSessionRecoveryDialogOpen = "activeSessionRecoveryDialogOpen",
+ MakeSnapshotDialogOpen = "makeSnapshotDialogOpen",
+ TemplatesDialogOpen = "templatesDialogOpen",
}
export enum GuiEvent {
@@ -88,25 +96,44 @@ type GuiStateValueTypes = {
[GuiState.LeftDrawerContent]: LeftDrawerContent;
[GuiState.RightDrawerContent]: RightDrawerContent | undefined;
[GuiState.LeftSettingsPanelWidthInPercent]: number;
- [GuiState.ActiveModuleInstanceId]: string;
[GuiState.DataChannelConnectionLayerVisible]: boolean;
[GuiState.DevToolsVisible]: boolean;
[GuiState.EditDataChannelConnections]: boolean;
[GuiState.RightSettingsPanelWidthInPercent]: number;
[GuiState.AppInitialized]: boolean;
[GuiState.NumberOfUnsavedRealizationFilters]: number;
+ [GuiState.SaveSessionDialogOpen]: boolean;
+ [GuiState.IsSavingSession]: boolean;
+ [GuiState.IsLoadingSession]: boolean;
+ [GuiState.SessionHasUnsavedChanges]: boolean;
+ [GuiState.EnsembleDialogOpen]: boolean;
+ [GuiState.MultiSessionsRecoveryDialogOpen]: boolean;
+ [GuiState.ActiveSessionRecoveryDialogOpen]: boolean;
+ [GuiState.MakeSnapshotDialogOpen]: boolean;
+ [GuiState.IsMakingSnapshot]: boolean;
+ [GuiState.TemplatesDialogOpen]: boolean;
};
const defaultStates: Map = new Map();
defaultStates.set(GuiState.LeftDrawerContent, LeftDrawerContent.ModuleSettings);
defaultStates.set(GuiState.RightDrawerContent, undefined);
defaultStates.set(GuiState.LeftSettingsPanelWidthInPercent, 30);
-defaultStates.set(GuiState.ActiveModuleInstanceId, "");
defaultStates.set(GuiState.DataChannelConnectionLayerVisible, false);
defaultStates.set(GuiState.DevToolsVisible, isDevMode());
defaultStates.set(GuiState.RightSettingsPanelWidthInPercent, 0);
defaultStates.set(GuiState.AppInitialized, false);
defaultStates.set(GuiState.NumberOfUnsavedRealizationFilters, 0);
+defaultStates.set(GuiState.SaveSessionDialogOpen, false);
+defaultStates.set(GuiState.IsSavingSession, false);
+defaultStates.set(GuiState.IsLoadingSession, false);
+defaultStates.set(GuiState.SessionHasUnsavedChanges, false);
+defaultStates.set(GuiState.EditDataChannelConnections, false);
+defaultStates.set(GuiState.EnsembleDialogOpen, false);
+defaultStates.set(GuiState.MultiSessionsRecoveryDialogOpen, false);
+defaultStates.set(GuiState.ActiveSessionRecoveryDialogOpen, false);
+defaultStates.set(GuiState.MakeSnapshotDialogOpen, false);
+defaultStates.set(GuiState.IsMakingSnapshot, false);
+defaultStates.set(GuiState.TemplatesDialogOpen, false);
const persistentStates: GuiState[] = [
GuiState.LeftSettingsPanelWidthInPercent,
diff --git a/frontend/src/framework/Module.tsx b/frontend/src/framework/Module.tsx
index 53ede2286..066375be1 100644
--- a/frontend/src/framework/Module.tsx
+++ b/frontend/src/framework/Module.tsx
@@ -1,7 +1,9 @@
import type React from "react";
+import type { JTDSchemaType } from "ajv/dist/core";
import type { Getter, Setter } from "jotai";
+import type { AtomStoreMaster } from "./AtomStoreMaster";
import type { ChannelDefinition, ChannelReceiverDefinition } from "./DataChannelTypes";
import type { InitialSettings } from "./InitialSettings";
import type { SettingsContext, ViewContext } from "./ModuleContext";
@@ -10,7 +12,6 @@ import { ModuleInstance, ModuleInstanceTopic } from "./ModuleInstance";
import type { DrawPreviewFunc } from "./Preview";
import type { SyncSettingKey } from "./SyncSettings";
import type { InterfaceBaseType, InterfaceInitialization } from "./UniDirectionalModuleComponentsInterface";
-import type { Workbench } from "./Workbench";
import type { WorkbenchServices } from "./WorkbenchServices";
import type { WorkbenchSession } from "./WorkbenchSession";
import type { WorkbenchSettings } from "./WorkbenchSettings";
@@ -50,8 +51,9 @@ export type ModuleSettingsProps<
settingsToView: Record;
viewToSettings: Record;
},
+ TSerializedStateDef extends ModuleComponentsStateBase = NoModuleStateSchema,
> = {
- settingsContext: SettingsContext;
+ settingsContext: SettingsContext;
workbenchSession: WorkbenchSession;
workbenchServices: WorkbenchServices;
workbenchSettings: WorkbenchSettings;
@@ -63,8 +65,9 @@ export type ModuleViewProps<
settingsToView: Record;
viewToSettings: Record;
},
+ TSerializedStateDef extends ModuleComponentsStateBase = NoModuleStateSchema,
> = {
- viewContext: ViewContext;
+ viewContext: ViewContext;
workbenchSession: WorkbenchSession;
workbenchServices: WorkbenchServices;
workbenchSettings: WorkbenchSettings;
@@ -77,28 +80,87 @@ export type InterfaceEffects = ((
getAtomValue: Getter,
) => void)[];
+export type JTDBaseType = Record;
+
+export type ModuleComponentsStateBase = {
+ settings?: Record;
+ view?: Record;
+};
+
+export type SerializedModuleComponentsState = {
+ settings: TSerializedStateDef["settings"];
+ view: TSerializedStateDef["view"];
+};
+
+export type NoModuleStateSchema = {
+ settings: Record;
+ view: Record;
+};
+
+export type ModuleStateSchema = {
+ settings?: JTDSchemaType;
+ view?: JTDSchemaType;
+};
+
+export interface SerializeStateFunction {
+ (get: Getter): T;
+}
+
+export interface DeserializeStateFunction {
+ (raw: Partial, set: Setter): void;
+}
+
+export type ModuleComponentSerializationFunctions =
+ TSerializedStateDef extends NoModuleStateSchema
+ ? {
+ serializeStateFunctions?: never;
+ deserializeStateFunctions?: never;
+ }
+ : {
+ serializeStateFunctions: {
+ settings?: SerializeStateFunction;
+ view?: SerializeStateFunction;
+ };
+ deserializeStateFunctions: {
+ settings?: DeserializeStateFunction;
+ view?: DeserializeStateFunction;
+ };
+ };
+
+export function hasSerialization(
+ val: ModuleComponentSerializationFunctions,
+): val is Exclude {
+ return !!(val as any).serializeStateFunctions;
+}
+
+export type MakeReadonly = {
+ readonly [P in keyof T]: T[P];
+};
+
export type ModuleSettings<
TInterfaceTypes extends ModuleInterfaceTypes = {
settingsToView: Record;
viewToSettings: Record;
},
-> = React.FC>;
+ TSerializedStateDef extends ModuleComponentsStateBase = NoModuleStateSchema,
+> = React.FC>;
export type ModuleView<
TInterfaceTypes extends ModuleInterfaceTypes = {
settingsToView: Record;
viewToSettings: Record;
},
-> = React.FC>;
+ TSerializedStateDef extends ModuleComponentsStateBase = NoModuleStateSchema,
+> = React.FC>;
-export enum ImportState {
+export enum ImportStatus {
NotImported = "NotImported",
Importing = "Importing",
Imported = "Imported",
Failed = "Failed",
}
-export interface ModuleOptions {
+export type ModuleOptions = {
name: string;
defaultTitle: string;
category: ModuleCategory;
@@ -110,15 +172,16 @@ export interface ModuleOptions {
channelDefinitions?: ChannelDefinition[];
channelReceiverDefinitions?: ChannelReceiverDefinition[];
onInstanceUnloadFunc?: OnInstanceUnloadFunc;
-}
+ serializedStateSchema?: ModuleStateSchema;
+};
-export class Module {
+export class Module {
private _name: string;
private _defaultTitle: string;
- public viewFC: ModuleView;
- public settingsFC: ModuleSettings;
- protected _importState: ImportState = ImportState.NotImported;
- private _moduleInstances: ModuleInstance[] = [];
+ public viewFC: ModuleView;
+ public settingsFC: ModuleSettings;
+ protected _importState: ImportStatus = ImportStatus.NotImported;
+ private _moduleInstances: ModuleInstance[] = [];
private _settingsToViewInterfaceInitialization: InterfaceInitialization<
Exclude
> | null = null;
@@ -129,7 +192,6 @@ export class Module {
[];
private _settingsToViewInterfaceEffects: InterfaceEffects> =
[];
- private _workbench: Workbench | null = null;
private _syncableSettingKeys: SyncSettingKey[];
private _drawPreviewFunc: DrawPreviewFunc | null;
private _onInstanceUnloadFunc: OnInstanceUnloadFunc | null;
@@ -139,8 +201,11 @@ export class Module {
private _category: ModuleCategory;
private _devState: ModuleDevState;
private _dataTagIds: ModuleDataTagId[];
+ private _serializedStateSchema: ModuleStateSchema | null;
+ private _serializationFunctions: ModuleComponentSerializationFunctions | undefined;
+ private _atomStoreMaster: AtomStoreMaster | null = null;
- constructor(options: ModuleOptions) {
+ constructor(options: ModuleOptions) {
this._name = options.name;
this._defaultTitle = options.defaultTitle;
this._category = options.category;
@@ -154,13 +219,18 @@ export class Module {
this._channelDefinitions = options.channelDefinitions ?? null;
this._channelReceiverDefinitions = options.channelReceiverDefinitions ?? null;
this._dataTagIds = options.dataTagIds ?? [];
+ this._serializedStateSchema = options.serializedStateSchema ?? null;
+ }
+
+ getSerializedStateSchema(): ModuleStateSchema | null {
+ return this._serializedStateSchema;
}
getDrawPreviewFunc(): DrawPreviewFunc | null {
return this._drawPreviewFunc;
}
- getImportState(): ImportState {
+ getImportState(): ImportStatus {
return this._importState;
}
@@ -188,10 +258,6 @@ export class Module {
return this._description;
}
- setWorkbench(workbench: Workbench): void {
- this._workbench = workbench;
- }
-
setSettingsToViewInterfaceInitialization(
interfaceInitialization: InterfaceInitialization>,
): void {
@@ -216,6 +282,14 @@ export class Module {
this._settingsToViewInterfaceEffects = atomsInitialization;
}
+ setSerializationFunctions(serializationFunctions: ModuleComponentSerializationFunctions): void {
+ this._serializationFunctions = serializationFunctions;
+ }
+
+ getComponentSerializationFunctions(): ModuleComponentSerializationFunctions | undefined {
+ return this._serializationFunctions;
+ }
+
getViewToSettingsInterfaceEffects(): InterfaceEffects> {
return this._viewToSettingsInterfaceEffects;
}
@@ -232,19 +306,16 @@ export class Module {
return this._syncableSettingKeys.includes(key);
}
- makeInstance(instanceNumber: number): ModuleInstance {
- if (!this._workbench) {
- throw new Error("Module must be added to a workbench before making an instance");
- }
-
- const instance = new ModuleInstance({
+ makeInstance(id: string, atomStoreMaster: AtomStoreMaster): ModuleInstance {
+ const instance = new ModuleInstance({
module: this,
- workbench: this._workbench,
- instanceNumber,
+ atomStoreMaster,
+ id,
channelDefinitions: this._channelDefinitions,
channelReceiverDefinitions: this._channelReceiverDefinitions,
});
this._moduleInstances.push(instance);
+ atomStoreMaster.makeAtomStoreForModuleInstance(id);
this.maybeImportSelf();
return instance;
}
@@ -253,19 +324,14 @@ export class Module {
this._onInstanceUnloadFunc?.(instanceId);
}
- private setImportState(state: ImportState): void {
+ private setImportState(state: ImportStatus): void {
this._importState = state;
this._moduleInstances.forEach((instance) => {
- instance.notifySubscribers(ModuleInstanceTopic.IMPORT_STATE);
+ instance.notifySubscribers(ModuleInstanceTopic.IMPORT_STATUS);
});
-
- if (this._workbench && state === ImportState.Imported) {
- this._workbench.maybeMakeFirstModuleInstanceActive();
- }
}
- private initializeModuleInstance(instance: ModuleInstance): void {
- instance.initialize();
+ private initializeModuleInstance(instance: ModuleInstance): void {
if (this._settingsToViewInterfaceInitialization) {
instance.makeSettingsToViewInterface(this._settingsToViewInterfaceInitialization);
}
@@ -274,11 +340,15 @@ export class Module {
instance.makeViewToSettingsInterface(this._viewToSettingsInterfaceInitialization);
}
instance.makeViewToSettingsInterfaceEffectsAtom();
+ if (this._serializationFunctions) {
+ instance.makeSerializer(this._serializationFunctions);
+ }
+ instance.initialize();
}
- private maybeImportSelf(): void {
- if (this._importState !== ImportState.NotImported) {
- if (this._importState === ImportState.Imported) {
+ private async maybeImportSelf(): Promise {
+ if (this._importState !== ImportStatus.NotImported) {
+ if (this._importState === ImportStatus.Imported) {
this._moduleInstances.forEach((instance) => {
if (instance.isInitialized()) {
return;
@@ -289,27 +359,26 @@ export class Module {
return;
}
- this.setImportState(ImportState.Importing);
+ this.setImportState(ImportStatus.Importing);
const path = `/src/modules/${this._name}/loadModule.tsx`;
const importer = moduleImporters[path];
if (!importer) {
console.error(`Module importer not found for ${path}`);
- this.setImportState(ImportState.Failed);
+ this.setImportState(ImportStatus.Failed);
return;
}
- importer()
- .then(() => {
- this.setImportState(ImportState.Imported);
- this._moduleInstances.forEach((instance) => {
- this.initializeModuleInstance(instance);
- });
- })
- .catch((e) => {
- console.error(`Failed to import module ${this._name}`, e);
- this.setImportState(ImportState.Failed);
+ try {
+ await importer();
+ this.setImportState(ImportStatus.Imported);
+ this._moduleInstances.forEach((instance) => {
+ this.initializeModuleInstance(instance);
});
+ } catch (e) {
+ console.error(`Failed to initialize module ${this._name}`, e);
+ this.setImportState(ImportStatus.Failed);
+ }
}
}
diff --git a/frontend/src/framework/ModuleContext.ts b/frontend/src/framework/ModuleContext.ts
index 1b86e29cf..834fa82ca 100644
--- a/frontend/src/framework/ModuleContext.ts
+++ b/frontend/src/framework/ModuleContext.ts
@@ -13,7 +13,7 @@
import type { ChannelContentDefinition, KeyKind } from "./DataChannelTypes";
import { useChannelReceiver } from "./internal/DataChannels/hooks/useChannelReceiver";
import { usePublishChannelContents } from "./internal/DataChannels/hooks/usePublishChannelContents";
-import type { ModuleInterfaceTypes } from "./Module";
+import type { ModuleComponentsStateBase, ModuleInterfaceTypes, NoModuleStateSchema } from "./Module";
import type { ModuleInstance, ModuleInstanceTopicValueTypes } from "./ModuleInstance";
import { ModuleInstanceTopic, useModuleInstanceTopicValue } from "./ModuleInstance";
import type { ModuleInstanceStatusController } from "./ModuleInstanceStatusController";
@@ -21,10 +21,13 @@ import type { SyncSettingKey } from "./SyncSettings";
import type { InterfaceBaseType } from "./UniDirectionalModuleComponentsInterface";
import { useInterfaceValue } from "./UniDirectionalModuleComponentsInterface";
-export class ModuleContext {
- protected _moduleInstance: ModuleInstance;
+export class ModuleContext<
+ TInterfaceTypes extends ModuleInterfaceTypes,
+ TSerializedStateDef extends ModuleComponentsStateBase,
+> {
+ protected _moduleInstance: ModuleInstance;
- constructor(moduleInstance: ModuleInstance) {
+ constructor(moduleInstance: ModuleInstance) {
this._moduleInstance = moduleInstance;
}
@@ -92,12 +95,18 @@ export class ModuleContext {
}
}
-export type ViewContext = Omit<
- ModuleContext,
+export type ViewContext<
+ TInterfaceType extends InterfaceBaseType,
+ TSerializedStateDef extends ModuleComponentsStateBase = NoModuleStateSchema,
+> = Omit<
+ ModuleContext,
"useViewToSettingsInterfaceValue" | "useSettingsAtom" | "useSetSettingsAtom" | "useSettingsAtomValue"
>;
-export type SettingsContext = Omit<
- ModuleContext,
+export type SettingsContext<
+ TInterfaceType extends InterfaceBaseType,
+ TSerializedStateDef extends ModuleComponentsStateBase = NoModuleStateSchema,
+> = Omit<
+ ModuleContext,
"useSettingsToViewInterfaceValue" | "useViewAtom" | "useViewAtomValue" | "useSetViewAtom"
>;
diff --git a/frontend/src/framework/ModuleInstance.ts b/frontend/src/framework/ModuleInstance.ts
index 96e85f6ab..b4972c128 100644
--- a/frontend/src/framework/ModuleInstance.ts
+++ b/frontend/src/framework/ModuleInstance.ts
@@ -5,18 +5,28 @@ import type { Atom } from "jotai";
import { atom } from "jotai";
import { atomEffect } from "jotai-effect";
+import type { AtomStoreMaster } from "./AtomStoreMaster";
import type { ChannelDefinition, ChannelReceiverDefinition } from "./DataChannelTypes";
import type { InitialSettings } from "./InitialSettings";
-import { ChannelManager } from "./internal/DataChannels/ChannelManager";
+import { ChannelManager, type DataChannelReceiverSubscription } from "./internal/DataChannels/ChannelManager";
import { ModuleInstanceStatusControllerInternal } from "./internal/ModuleInstanceStatusControllerInternal";
-import type { ImportState, Module, ModuleInterfaceTypes, ModuleSettings, ModuleView } from "./Module";
+import type { Dashboard } from "./internal/WorkbenchSession/Dashboard";
+import type {
+ ImportStatus,
+ Module,
+ ModuleComponentSerializationFunctions,
+ ModuleComponentsStateBase,
+ ModuleInterfaceTypes,
+ ModuleSettings,
+ ModuleView,
+} from "./Module";
import { ModuleContext } from "./ModuleContext";
+import { ModuleInstanceSerializer } from "./ModuleInstanceSerializer";
import type { SyncSettingKey } from "./SyncSettings";
import type { InterfaceInitialization } from "./UniDirectionalModuleComponentsInterface";
import { UniDirectionalModuleComponentsInterface } from "./UniDirectionalModuleComponentsInterface";
-import type { Workbench } from "./Workbench";
-export enum ModuleInstanceState {
+export enum ModuleInstanceLifeCycleState {
INITIALIZING,
OK,
ERROR,
@@ -26,34 +36,60 @@ export enum ModuleInstanceState {
export enum ModuleInstanceTopic {
TITLE = "title",
SYNCED_SETTINGS = "synced-settings",
- STATE = "state",
- IMPORT_STATE = "import-state",
+ LIFECYCLE_STATE = "state",
+ IMPORT_STATUS = "import-status",
+ SERIALIZED_STATE = "serialized-state",
}
export type ModuleInstanceTopicValueTypes = {
[ModuleInstanceTopic.TITLE]: string;
[ModuleInstanceTopic.SYNCED_SETTINGS]: SyncSettingKey[];
- [ModuleInstanceTopic.STATE]: ModuleInstanceState;
- [ModuleInstanceTopic.IMPORT_STATE]: ImportState;
+ [ModuleInstanceTopic.LIFECYCLE_STATE]: ModuleInstanceLifeCycleState;
+ [ModuleInstanceTopic.IMPORT_STATUS]: ImportStatus;
+ [ModuleInstanceTopic.SERIALIZED_STATE]: ModuleComponentsStateBase;
};
-export interface ModuleInstanceOptions {
- module: Module;
- workbench: Workbench;
- instanceNumber: number;
+export interface ModuleInstanceOptions<
+ TInterfaceTypes extends ModuleInterfaceTypes,
+ TSerializedStateSchema extends ModuleComponentsStateBase,
+> {
+ module: Module;
+ atomStoreMaster: AtomStoreMaster;
+ id: string;
channelDefinitions: ChannelDefinition[] | null;
channelReceiverDefinitions: ChannelReceiverDefinition[] | null;
}
-export class ModuleInstance {
+export type ModuleInstanceSerializedState = {
+ id: string;
+ name: string;
+ dataChannelReceiverSubscriptions: DataChannelReceiverSubscription[];
+ syncedSettingKeys: SyncSettingKey[];
+ serializedState: StringifiedSerializedModuleState | null;
+};
+
+type StringifiedSerializedModuleState = {
+ settings?: string;
+ view?: string;
+};
+
+export type PartialSerializedModuleState = {
+ settings?: Partial;
+ view?: Partial;
+};
+
+export class ModuleInstance<
+ TInterfaceTypes extends ModuleInterfaceTypes,
+ TSerializedStateSchema extends ModuleComponentsStateBase,
+> {
private _id: string;
private _title: string;
private _initialized: boolean = false;
- private _moduleInstanceState: ModuleInstanceState = ModuleInstanceState.INITIALIZING;
+ private _moduleInstanceState: ModuleInstanceLifeCycleState = ModuleInstanceLifeCycleState.INITIALIZING;
private _fatalError: { err: Error; errInfo: ErrorInfo } | null = null;
private _syncedSettingKeys: SyncSettingKey[] = [];
- private _module: Module;
- private _context: ModuleContext | null = null;
+ private _module: Module;
+ private _context: ModuleContext | null = null;
private _subscribers: Map void>> = new Map();
private _initialSettings: InitialSettings | null = null;
private _statusController: ModuleInstanceStatusControllerInternal = new ModuleInstanceStatusControllerInternal();
@@ -66,11 +102,18 @@ export class ModuleInstance {
> | null = null;
private _settingsToViewInterfaceEffectsAtom: Atom | null = null;
private _viewToSettingsInterfaceEffectsAtom: Atom | null = null;
+ private _atomStoreMaster: AtomStoreMaster;
- constructor(options: ModuleInstanceOptions) {
- this._id = `${options.module.getName()}-${options.instanceNumber}`;
+ private _serializer: ModuleInstanceSerializer | null = null;
+ private _storedSerializedState: ModuleInstanceSerializedState | null = null;
+ private _storedTemplateState: PartialSerializedModuleState | null = null;
+ private _dashboard: Dashboard | null = null;
+
+ constructor(options: ModuleInstanceOptions) {
+ this._id = options.id;
this._title = options.module.getDefaultTitle();
this._module = options.module;
+ this._atomStoreMaster = options.atomStoreMaster;
this._channelManager = new ChannelManager(this._id);
@@ -88,6 +131,66 @@ export class ModuleInstance {
}
}
+ handleStateChange(): void {
+ this.notifySubscribers(ModuleInstanceTopic.SERIALIZED_STATE);
+ }
+
+ serialize(): ModuleInstanceSerializedState {
+ return {
+ id: this._id,
+ name: this._module.getName(),
+ // Replace with channel manager's own serialization logic
+ dataChannelReceiverSubscriptions: this._channelManager
+ .getReceivers()
+ .filter((receiver) => receiver.hasActiveSubscription())
+ .map((receiver) => ({
+ idString: receiver.getIdString(),
+ listensToModuleInstanceId: receiver.getChannel()?.getManager().getModuleInstanceId() ?? "",
+ channelIdString: receiver.getChannel()?.getIdString() ?? "",
+ contentIdStrings: receiver.getContentIdStrings(),
+ })),
+ syncedSettingKeys: this._syncedSettingKeys,
+ serializedState: this._serializer?.getStringifiedSerializedState() ?? null,
+ };
+ }
+
+ initiateDeserialization(raw: ModuleInstanceSerializedState, dashboard: Dashboard): void {
+ this._storedSerializedState = raw;
+ this._dashboard = dashboard;
+ this.deserialize();
+ }
+
+ initiateTemplateStateApplication(initialState: PartialSerializedModuleState): void {
+ this._storedTemplateState = initialState;
+ this.applyTemplateState();
+ }
+
+ private applyTemplateState(): void {
+ if (this._initialized && this._storedTemplateState && this._serializer) {
+ this._serializer.applyTemplateState(this._storedTemplateState);
+ this._storedTemplateState = null;
+ }
+ }
+
+ private deserialize(): void {
+ if (this._initialized && this._storedSerializedState && this._dashboard) {
+ this._syncedSettingKeys = this._storedSerializedState.syncedSettingKeys;
+
+ this._id = this._storedSerializedState.id;
+
+ if (this._storedSerializedState.serializedState && this._serializer) {
+ this._serializer.deserializeState(this._storedSerializedState.serializedState);
+ }
+
+ this._channelManager.deserialize(
+ this._storedSerializedState.dataChannelReceiverSubscriptions,
+ this._dashboard,
+ );
+
+ this._storedSerializedState = null;
+ }
+ }
+
getUniDirectionalSettingsToViewInterface(): UniDirectionalModuleComponentsInterface<
Exclude
> {
@@ -111,9 +214,11 @@ export class ModuleInstance {
}
initialize(): void {
- this._context = new ModuleContext(this);
+ this._context = new ModuleContext(this);
this._initialized = true;
- this.setModuleInstanceState(ModuleInstanceState.OK);
+ this.setModuleInstanceState(ModuleInstanceLifeCycleState.OK);
+ this.deserialize();
+ this.applyTemplateState();
}
makeSettingsToViewInterface(
@@ -134,6 +239,18 @@ export class ModuleInstance {
this._viewToSettingsInterface = new UniDirectionalModuleComponentsInterface(interfaceInitialization);
}
+ makeSerializer(serializationFunctions: ModuleComponentSerializationFunctions | null): void {
+ if (serializationFunctions) {
+ this._serializer = new ModuleInstanceSerializer(
+ this,
+ this._atomStoreMaster.getAtomStoreForModuleInstance(this._id),
+ this._module.getSerializedStateSchema(),
+ serializationFunctions,
+ this.handleStateChange.bind(this),
+ );
+ }
+ }
+
makeSettingsToViewInterfaceEffectsAtom(): void {
const effectFuncs = this.getModule().getSettingsToViewInterfaceEffects();
const getUniDirectionalSettingsToViewInterface: () => UniDirectionalModuleComponentsInterface<
@@ -186,19 +303,27 @@ export class ModuleInstance {
getSettingsToViewInterfaceEffectsAtom(): Atom {
if (!this._settingsToViewInterfaceEffectsAtom) {
- throw `Module instance '${this._title}' does not have settings to view interface effects yet. Did you forget to init the module?`;
+ throw new Error(
+ `Module instance '${this._title}' does not have settings to view interface effects yet. Did you forget to init the module?`,
+ );
}
return this._settingsToViewInterfaceEffectsAtom;
}
getViewToSettingsInterfaceEffectsAtom(): Atom {
if (!this._viewToSettingsInterfaceEffectsAtom) {
- throw `Module instance '${this._title}' does not have view to settings interface effects yet. Did you forget to init the module?`;
+ throw new Error(
+ `Module instance '${this._title}' does not have view to settings interface effects yet. Did you forget to init the module?`,
+ );
}
return this._viewToSettingsInterfaceEffectsAtom;
}
addSyncedSetting(settingKey: SyncSettingKey): void {
+ if (this._syncedSettingKeys.includes(settingKey)) {
+ console.warn(`Setting key '${settingKey}' is already synced for module instance '${this._title}'.`);
+ return;
+ }
this._syncedSettingKeys.push(settingKey);
this.notifySubscribers(ModuleInstanceTopic.SYNCED_SETTINGS);
}
@@ -220,21 +345,23 @@ export class ModuleInstance {
return this._initialized;
}
- getViewFC(): ModuleView {
+ getViewFC(): ModuleView {
return this._module.viewFC;
}
- getSettingsFC(): ModuleSettings {
+ getSettingsFC(): ModuleSettings {
return this._module.settingsFC;
}
- getImportState(): ImportState {
+ getImportState(): ImportStatus {
return this._module.getImportState();
}
- getContext(): ModuleContext {
+ getContext(): ModuleContext {
if (!this._context) {
- throw `Module context is not available yet. Did you forget to init the module '${this._title}.'?`;
+ throw new Error(
+ `Module context is not available yet. Did you forget to init the module '${this._title}.'?`,
+ );
}
return this._context;
}
@@ -288,18 +415,22 @@ export class ModuleInstance {
if (topic === ModuleInstanceTopic.SYNCED_SETTINGS) {
return this.getSyncedSettingKeys();
}
- if (topic === ModuleInstanceTopic.STATE) {
+ if (topic === ModuleInstanceTopic.LIFECYCLE_STATE) {
return this.getModuleInstanceState();
}
- if (topic === ModuleInstanceTopic.IMPORT_STATE) {
+ if (topic === ModuleInstanceTopic.IMPORT_STATUS) {
return this.getImportState();
}
+ if (topic === ModuleInstanceTopic.SERIALIZED_STATE) {
+ // !This is not reference-stable, so we return a new object each time
+ return this.serialize();
+ }
};
return snapshotGetter;
}
- getModule(): Module {
+ getModule(): Module {
return this._module;
}
@@ -307,17 +438,17 @@ export class ModuleInstance
{this.state.error.name}: {this.state.error.message}
You can use the following URL to start a clean session:
diff --git a/frontend/src/Log.ts b/frontend/src/Log.ts
new file mode 100644
index 000000000..a8715b9f2
--- /dev/null
+++ b/frontend/src/Log.ts
@@ -0,0 +1,203 @@
+/* eslint-disable no-console */
+import { formatHex } from "culori";
+import { isArray } from "lodash";
+
+import { getDebugSetting, setDebugSetting } from "@framework/internal/utils/debug";
+
+let colorIndex = 0;
+
+function getNextColor(): string {
+ const goldenAngle = 137.508; // degrees
+ const hue = (colorIndex++ * goldenAngle) % 360;
+ const color = { mode: "hsl", h: hue, s: 0.7, l: 0.5 } as const;
+ return formatHex(color); // → "#a05ce0", etc.
+}
+
+type CapitalLetter =
+ | "A"
+ | "B"
+ | "C"
+ | "D"
+ | "E"
+ | "F"
+ | "G"
+ | "H"
+ | "I"
+ | "J"
+ | "K"
+ | "L"
+ | "M"
+ | "N"
+ | "O"
+ | "P"
+ | "Q"
+ | "R"
+ | "S"
+ | "T"
+ | "U"
+ | "V"
+ | "W"
+ | "X"
+ | "Y"
+ | "Z";
+
+type PascalCase = `${CapitalLetter}${string}`; // Start with uppercase
+
+function isValidLoggerName(name: string): boolean {
+ return /^[A-Z][a-zA-Z_]*[a-zA-Z]$/.test(name);
+}
+
+class ConsoleLogger {
+ private _name: string;
+ private _color: string;
+
+ constructor(name: string, color: string) {
+ this._name = name;
+ this._color = color;
+ }
+
+ private _log(level: "debug" | "info" | "warn" | "error", ...args: unknown[]) {
+ const prefix = `%c[${this._name}]`;
+ const style = `color: ${this._color}; font-weight: bold`;
+ console[level](prefix, style, ...args);
+ }
+
+ log(...args: unknown[]) {
+ this._log("debug", ...args);
+ }
+}
+
+class Logger {
+ private _name: string;
+ private _color: string;
+
+ console: ConsoleLogger | undefined;
+
+ constructor(name: string, color: string) {
+ this._name = name;
+ this._color = color;
+ }
+
+ enable() {
+ if (!this.console) {
+ this.console = new ConsoleLogger(this._name, this._color);
+ }
+ }
+
+ disable() {
+ this.console = undefined;
+ }
+}
+
+type LoggerControl = {
+ enable: () => void;
+ disable: () => void;
+};
+
+const DEBUG_SETTING_NAME = "enabledLoggers";
+
+class GlobalLog {
+ private _registry: Record
+
+
+ );
+ } else {
+ content =
+
+