-
- );
- }
-
- 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.`;
+ };
+
+ 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..f0aea36cb
--- /dev/null
+++ b/frontend/src/WorkbenchWrapper.tsx
@@ -0,0 +1,79 @@
+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 { EditSessionDialog } from "@framework/internal/components/EditSessionDialog";
+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";
+
+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 getUserInfoQueryKey = (options: Options) => [createQueryKey("getUserInfo", options)];
+
+export const getUserInfoOptions = (options: Options) => {
+ return queryOptions({
+ queryFn: async ({ queryKey, signal }) => {
+ const { data } = await getUserInfo({
+ ...options,
+ ...queryKey[0],
+ signal,
+ throwOnError: true,
+ });
+ return data;
+ },
+ queryKey: getUserInfoQueryKey(options),
+ });
+};
+
export const getUserPhotoQueryKey = (options: Options) => [createQueryKey("getUserPhoto", options)];
export const getUserPhotoOptions = (options: Options) => {
@@ -1549,6 +1612,382 @@ export const getVfpTableOptions = (options: Options) => {
});
};
+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),
+ });
+};
+
+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 getSessionsMetadataInfiniteQueryKey = (
+ options?: Options,
+): QueryKey> => [createQueryKey("getSessionsMetadata", options, true)];
+
+export const getSessionsMetadataInfiniteOptions = (options?: Options) => {
+ return infiniteQueryOptions<
+ GetSessionsMetadataResponse_api,
+ AxiosError,
+ InfiniteData,
+ QueryKey>,
+ string | 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: {
+ cursor: pageParam,
+ },
+ };
+ const params = createInfiniteParams(queryKey, page);
+ const { data } = await getSessionsMetadata({
+ ...options,
+ ...params,
+ signal,
+ throwOnError: true,
+ });
+ return data;
+ },
+ queryKey: getSessionsMetadataInfiniteQueryKey(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<
+ UpdateSessionResponse_api,
+ AxiosError,
+ 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 getVisitedSnapshotsQueryKey = (options?: Options) => [
+ createQueryKey("getVisitedSnapshots", options),
+];
+
+export const getVisitedSnapshotsOptions = (options?: Options) => {
+ return queryOptions({
+ queryFn: async ({ queryKey, signal }) => {
+ const { data } = await getVisitedSnapshots({
+ ...options,
+ ...queryKey[0],
+ signal,
+ throwOnError: true,
+ });
+ return data;
+ },
+ queryKey: getVisitedSnapshotsQueryKey(options),
+ });
+};
+
+export const getVisitedSnapshotsInfiniteQueryKey = (
+ options?: Options,
+): QueryKey> => [createQueryKey("getVisitedSnapshots", options, true)];
+
+export const getVisitedSnapshotsInfiniteOptions = (options?: Options) => {
+ return infiniteQueryOptions<
+ GetVisitedSnapshotsResponse_api,
+ AxiosError,
+ InfiniteData,
+ QueryKey>,
+ string | 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: {
+ cursor: pageParam,
+ },
+ };
+ const params = createInfiniteParams(queryKey, page);
+ const { data } = await getVisitedSnapshots({
+ ...options,
+ ...params,
+ signal,
+ throwOnError: true,
+ });
+ return data;
+ },
+ queryKey: getVisitedSnapshotsInfiniteQueryKey(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 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..f7c86c55e 100644
--- a/frontend/src/api/autogen/sdk.gen.ts
+++ b/frontend/src/api/autogen/sdk.gen.ts
@@ -176,6 +176,9 @@ import type {
GetPolygonsDataData_api,
GetPolygonsDataResponse_api,
GetPolygonsDataError_api,
+ GetUserInfoData_api,
+ GetUserInfoResponse_api,
+ GetUserInfoError_api,
GetUserPhotoData_api,
GetUserPhotoResponse_api,
GetUserPhotoError_api,
@@ -194,6 +197,43 @@ 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,
+ UpdateSessionResponse_api,
+ UpdateSessionError_api,
+ GetSessionMetadataData_api,
+ GetSessionMetadataResponse_api,
+ GetSessionMetadataError_api,
+ GetVisitedSnapshotsData_api,
+ GetVisitedSnapshotsResponse_api,
+ GetVisitedSnapshotsError_api,
+ GetSnapshotsMetadataData_api,
+ GetSnapshotsMetadataResponse_api,
+ GetSnapshotsMetadataError_api,
+ CreateSnapshotData_api,
+ CreateSnapshotResponse_api,
+ CreateSnapshotError_api,
+ DeleteSnapshotData_api,
+ DeleteSnapshotError_api,
+ GetSnapshotData_api,
+ GetSnapshotResponse_api,
+ GetSnapshotError_api,
+ GetSnapshotMetadataData_api,
+ GetSnapshotMetadataResponse_api,
+ GetSnapshotMetadataError_api,
+ SnapshotPreviewData_api,
+ SnapshotPreviewResponse_api,
+ SnapshotPreviewError_api,
LoginRouteData_api,
LoginRouteError_api,
AuthorizedCallbackRouteData_api,
@@ -1146,6 +1186,16 @@ export const getPolygonsData = (
});
};
+/**
+ * Get User Info
+ */
+export const getUserInfo = (options: Options) => {
+ return (options?.client ?? client).get({
+ ...options,
+ url: "/graph/user_info/{user_id_or_email}",
+ });
+};
+
/**
* Get User Photo
* Get username, display name and avatar from Microsoft Graph API for a given user email
@@ -1218,6 +1268,172 @@ 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
+ * Updates a session object. Allows for partial update objects
+ */
+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 Visited Snapshots
+ */
+export const getVisitedSnapshots = (
+ options?: Options,
+) => {
+ return (options?.client ?? client).get({
+ ...options,
+ url: "/snapshots/visited_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}",
+ });
+};
+
+/**
+ * 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..55ae74b3a 100644
--- a/frontend/src/api/autogen/types.gen.ts
+++ b/frontend/src/api/autogen/types.gen.ts
@@ -238,6 +238,13 @@ export enum Gfr_api {
MMW = "MMW",
}
+export type GraphUser_api = {
+ id: string;
+ principal_name: string;
+ display_name: string;
+ email: string;
+};
+
export type GraphUserPhoto_api = {
avatar_b64str?: string | null;
};
@@ -391,6 +398,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 +695,103 @@ export enum SensitivityType_api {
SCENARIO = "scenario",
}
+export type SessionDocument_api = {
+ id: string;
+ ownerId: string;
+ metadata: SessionMetadata_api;
+ content: string;
+};
+
+export type SessionIndexPage_api = {
+ items: Array;
+ continuation_token: string | null;
+};
+
+export type SessionMetadata_api = {
+ title: string;
+ description: string | null;
+ createdAt: string;
+ updatedAt: string;
+ version: number;
+ hash: string;
+};
+
+export type SessionMetadataUpdate_api = {
+ title?: string;
+ description?: string | null;
+};
+
+export type SessionMetadataWithId_api = {
+ title: string;
+ description: string | null;
+ createdAt: string;
+ updatedAt: string;
+ version: number;
+ hash: string;
+ id: string;
+};
+
+export enum SessionSortBy_api {
+ METADATA_CREATED_AT = "metadata.created_at",
+ METADATA_UPDATED_AT = "metadata.updated_at",
+ METADATA_TITLE = "metadata.title",
+}
+
+export type SessionUpdate_api = {
+ id: string;
+ metadata?: SessionMetadataUpdate_api;
+ content?: string;
+};
+
+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;
+ snapshotDeleted: boolean;
+ snapshotMetadata: SnapshotMetadata_api;
+};
+
+export type SnapshotAccessLogIndexPage_api = {
+ items: Array;
+ continuation_token: string | null;
+};
+
+export enum SnapshotAccessLogSortBy_api {
+ VISITS = "visits",
+ LAST_VISITED_AT = "last_visited_at",
+ SNAPSHOT_METADATA_TITLE = "snapshot_metadata.title",
+ SNAPSHOT_METADATA_CREATED_AT = "snapshot_metadata.created_at",
+}
+
+export type SnapshotMetadata_api = {
+ ownerId: string;
+ title: string;
+ description: string | null;
+ createdAt: string;
+ updatedAt: string;
+ hash: string;
+};
+
+export enum SnapshotSortBy_api {
+ CREATED_AT = "created_at",
+ UPDATED_AT = "updated_at",
+ TITLE = "title",
+ TITLE_LOWER = "title_lower",
+}
+
+export enum SortDirection_api {
+ ASC = "asc",
+ DESC = "desc",
+}
+
export enum StatisticFunction_api {
MEAN = "MEAN",
MIN = "MIN",
@@ -907,6 +1023,7 @@ export enum UnitType_api {
}
export type UserInfo_api = {
+ user_id: string;
username: string;
display_name?: string | null;
avatar_b64str?: string | null;
@@ -3598,6 +3715,38 @@ export type GetPolygonsDataResponses_api = {
export type GetPolygonsDataResponse_api = GetPolygonsDataResponses_api[keyof GetPolygonsDataResponses_api];
+export type GetUserInfoData_api = {
+ body?: never;
+ path: {
+ /**
+ * User email, id or 'me' for the authenticated user
+ */
+ user_id_or_email: string;
+ };
+ query?: {
+ t?: number;
+ };
+ url: "/graph/user_info/{user_id_or_email}";
+};
+
+export type GetUserInfoErrors_api = {
+ /**
+ * Validation Error
+ */
+ 422: HttpValidationError_api;
+};
+
+export type GetUserInfoError_api = GetUserInfoErrors_api[keyof GetUserInfoErrors_api];
+
+export type GetUserInfoResponses_api = {
+ /**
+ * Successful Response
+ */
+ 200: GraphUser_api | null;
+};
+
+export type GetUserInfoResponse_api = GetUserInfoResponses_api[keyof GetUserInfoResponses_api];
+
export type GetUserPhotoData_api = {
body?: never;
path?: never;
@@ -3605,7 +3754,7 @@ export type GetUserPhotoData_api = {
/**
* User email or 'me' for the authenticated user
*/
- user_email: string;
+ user_id_or_email: string;
t?: number;
};
url: "/graph/user_photo/";
@@ -3828,6 +3977,434 @@ export type GetVfpTableResponses_api = {
export type GetVfpTableResponse_api = GetVfpTableResponses_api[keyof GetVfpTableResponses_api];
+export type GetSessionsMetadataData_api = {
+ body?: never;
+ path?: never;
+ query?: {
+ cursor?: string | null;
+ /**
+ * Sort the result by
+ */
+ sort_by?: SessionSortBy_api | null;
+ /**
+ * Sort direction: 'asc' or 'desc'
+ */
+ sort_direction?: SortDirection_api | null;
+ /**
+ * Limit the number of results
+ */
+ limit?: number;
+ /**
+ * Filter results by title (case insensitive)
+ */
+ filter_title?: string | null;
+ /**
+ * Filter results by date
+ */
+ filter_updated_from?: string | null;
+ /**
+ * Filter results by date
+ */
+ filter_updated_to?: string | 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: SessionIndexPage_api;
+};
+
+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: SessionDocument_api;
+};
+
+export type UpdateSessionResponse_api = UpdateSessionResponses_api[keyof UpdateSessionResponses_api];
+
+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 GetVisitedSnapshotsData_api = {
+ body?: never;
+ path?: never;
+ query?: {
+ /**
+ * Continuation token for pagination
+ */
+ cursor?: string | null;
+ /**
+ * Limit the number of results
+ */
+ limit?: number | null;
+ /**
+ * Sort the result by
+ */
+ sort_by?: SnapshotAccessLogSortBy_api | null;
+ /**
+ * Sort direction: 'asc' or 'desc'
+ */
+ sort_direction?: SortDirection_api | null;
+ /**
+ * Filter results by title (case insensitive)
+ */
+ filter_title?: string | null;
+ /**
+ * Filter results by date
+ */
+ filter_updated_from?: string | null;
+ /**
+ * Filter results by date
+ */
+ filter_updated_to?: string | null;
+ t?: number;
+ };
+ url: "/snapshots/visited_snapshots";
+};
+
+export type GetVisitedSnapshotsErrors_api = {
+ /**
+ * Validation Error
+ */
+ 422: HttpValidationError_api;
+};
+
+export type GetVisitedSnapshotsError_api = GetVisitedSnapshotsErrors_api[keyof GetVisitedSnapshotsErrors_api];
+
+export type GetVisitedSnapshotsResponses_api = {
+ /**
+ * Successful Response
+ */
+ 200: SnapshotAccessLogIndexPage_api;
+};
+
+export type GetVisitedSnapshotsResponse_api = GetVisitedSnapshotsResponses_api[keyof GetVisitedSnapshotsResponses_api];
+
+export type GetSnapshotsMetadataData_api = {
+ body?: never;
+ path?: never;
+ query?: {
+ /**
+ * Sort the result by
+ */
+ sort_by?: SnapshotSortBy_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 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..d25f886e7 100644
--- a/frontend/src/framework/GuiMessageBroker.ts
+++ b/frontend/src/framework/GuiMessageBroker.ts
@@ -8,7 +8,6 @@ import type { UnsavedChangesAction } from "./types/unsavedChangesAction";
export enum LeftDrawerContent {
ModuleSettings = "ModuleSettings",
- ModulesList = "ModulesList",
TemplatesList = "TemplatesList",
SyncSettings = "SyncSettings",
ColorPaletteSettings = "ColorPaletteSettings",
@@ -17,19 +16,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",
+ EditSessionDialogOpen = "editSessionDialogOpen",
+ SessionHasUnsavedChanges = "sessionHasUnsavedChanges",
+ IsSavingSession = "isSavingSession",
+ IsMakingSnapshot = "isMakingSnapshot",
+ IsLoadingSession = "isLoadingSession",
+ EnsembleDialogOpen = "ensembleDialogOpen",
+ MultiSessionsRecoveryDialogOpen = "multiSessionsRecoveryDialogOpen",
+ ActiveSessionRecoveryDialogOpen = "activeSessionRecoveryDialogOpen",
+ MakeSnapshotDialogOpen = "makeSnapshotDialogOpen",
}
export enum GuiEvent {
@@ -88,25 +97,43 @@ 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.EditSessionDialogOpen]: 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;
};
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);
const persistentStates: GuiState[] = [
GuiState.LeftSettingsPanelWidthInPercent,
diff --git a/frontend/src/framework/Module.tsx b/frontend/src/framework/Module.tsx
index 53ede2286..17b08a3f2 100644
--- a/frontend/src/framework/Module.tsx
+++ b/frontend/src/framework/Module.tsx
@@ -1,5 +1,6 @@
import type React from "react";
+import type { JTDDataType } from "ajv/dist/core";
import type { Getter, Setter } from "jotai";
import type { ChannelDefinition, ChannelReceiverDefinition } from "./DataChannelTypes";
@@ -10,7 +11,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,12 +50,14 @@ export type ModuleSettingsProps<
settingsToView: Record;
viewToSettings: Record;
},
+ TSerializedStateDef extends ModuleStateBaseSchema = NoModuleStateSchema,
> = {
- settingsContext: SettingsContext;
+ settingsContext: SettingsContext;
workbenchSession: WorkbenchSession;
workbenchServices: WorkbenchServices;
workbenchSettings: WorkbenchSettings;
initialSettings?: InitialSettings;
+ persistence: ModulePersistence;
};
export type ModuleViewProps<
@@ -63,12 +65,19 @@ export type ModuleViewProps<
settingsToView: Record;
viewToSettings: Record;
},
+ TSerializedStateDef extends ModuleStateBaseSchema = NoModuleStateSchema,
> = {
- viewContext: ViewContext;
+ viewContext: ViewContext;
workbenchSession: WorkbenchSession;
workbenchServices: WorkbenchServices;
workbenchSettings: WorkbenchSettings;
initialSettings?: InitialSettings;
+ persistence: ModulePersistence;
+};
+
+export type ModulePersistence = {
+ serializedState: JTDDataType;
+ serializeState: (state: JTDDataType) => void;
};
export type InterfaceEffects = ((
@@ -77,28 +86,51 @@ export type InterfaceEffects = ((
getAtomValue: Getter,
) => void)[];
+export type JTDBaseType = Record;
+
+export type ModuleStateBaseSchema = {
+ settings: JTDBaseType;
+ view: JTDBaseType;
+};
+
+export type NoModuleStateSchema = {
+ settings: Record;
+ view: Record;
+};
+
+export type SerializedModuleState = {
+ view: JTDDataType;
+ settings: JTDDataType;
+};
+
+export type MakeReadonly = {
+ readonly [P in keyof T]: T[P];
+};
+
export type ModuleSettings<
TInterfaceTypes extends ModuleInterfaceTypes = {
settingsToView: Record;
viewToSettings: Record;
},
-> = React.FC>;
+ TSerializedStateDef extends ModuleStateBaseSchema = NoModuleStateSchema,
+> = React.FC>;
export type ModuleView<
TInterfaceTypes extends ModuleInterfaceTypes = {
settingsToView: Record;
viewToSettings: Record;
},
-> = React.FC>;
+ TSerializedStateDef extends ModuleStateBaseSchema = NoModuleStateSchema,
+> = React.FC>;
-export enum ImportState {
+export enum ImportStatus {
NotImported = "NotImported",
Importing = "Importing",
Imported = "Imported",
Failed = "Failed",
}
-export interface ModuleOptions {
+export interface ModuleOptions {
name: string;
defaultTitle: string;
category: ModuleCategory;
@@ -110,15 +142,19 @@ export interface ModuleOptions {
channelDefinitions?: ChannelDefinition[];
channelReceiverDefinitions?: ChannelReceiverDefinition[];
onInstanceUnloadFunc?: OnInstanceUnloadFunc;
+ serializedStateSchema?: TSerializedStateSchema;
}
-export class Module {
+export class Module<
+ TInterfaceTypes extends ModuleInterfaceTypes,
+ TSerializedStateSchema extends ModuleStateBaseSchema,
+> {
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 +165,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 +174,9 @@ export class Module {
private _category: ModuleCategory;
private _devState: ModuleDevState;
private _dataTagIds: ModuleDataTagId[];
+ private _serializedStateSchema: TSerializedStateSchema | null;
- constructor(options: ModuleOptions) {
+ constructor(options: ModuleOptions) {
this._name = options.name;
this._defaultTitle = options.defaultTitle;
this._category = options.category;
@@ -154,13 +190,18 @@ export class Module {
this._channelDefinitions = options.channelDefinitions ?? null;
this._channelReceiverDefinitions = options.channelReceiverDefinitions ?? null;
this._dataTagIds = options.dataTagIds ?? [];
+ this._serializedStateSchema = options.serializedStateSchema ?? null;
+ }
+
+ getSerializedStateSchema(): TSerializedStateSchema | null {
+ return this._serializedStateSchema;
}
getDrawPreviewFunc(): DrawPreviewFunc | null {
return this._drawPreviewFunc;
}
- getImportState(): ImportState {
+ getImportState(): ImportStatus {
return this._importState;
}
@@ -188,10 +229,6 @@ export class Module {
return this._description;
}
- setWorkbench(workbench: Workbench): void {
- this._workbench = workbench;
- }
-
setSettingsToViewInterfaceInitialization(
interfaceInitialization: InterfaceInitialization>,
): void {
@@ -232,15 +269,10 @@ 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): ModuleInstance {
+ const instance = new ModuleInstance({
module: this,
- workbench: this._workbench,
- instanceNumber,
+ id,
channelDefinitions: this._channelDefinitions,
channelReceiverDefinitions: this._channelReceiverDefinitions,
});
@@ -253,18 +285,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 {
+ private initializeModuleInstance(instance: ModuleInstance): void {
instance.initialize();
if (this._settingsToViewInterfaceInitialization) {
instance.makeSettingsToViewInterface(this._settingsToViewInterfaceInitialization);
@@ -277,8 +305,8 @@ export class Module {
}
private maybeImportSelf(): void {
- if (this._importState !== ImportState.NotImported) {
- if (this._importState === ImportState.Imported) {
+ if (this._importState !== ImportStatus.NotImported) {
+ if (this._importState === ImportStatus.Imported) {
this._moduleInstances.forEach((instance) => {
if (instance.isInitialized()) {
return;
@@ -289,27 +317,27 @@ 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.setImportState(ImportStatus.Imported);
this._moduleInstances.forEach((instance) => {
this.initializeModuleInstance(instance);
});
})
.catch((e) => {
console.error(`Failed to import module ${this._name}`, e);
- this.setImportState(ImportState.Failed);
+ this.setImportState(ImportStatus.Failed);
});
}
}
diff --git a/frontend/src/framework/ModuleContext.ts b/frontend/src/framework/ModuleContext.ts
index 1b86e29cf..e0ce8963d 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 { ModuleStateBaseSchema, 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 ModuleStateBaseSchema,
+> {
+ 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 ModuleStateBaseSchema = NoModuleStateSchema,
+> = Omit<
+ ModuleContext,
"useViewToSettingsInterfaceValue" | "useSettingsAtom" | "useSetSettingsAtom" | "useSettingsAtomValue"
>;
-export type SettingsContext = Omit<
- ModuleContext,
+export type SettingsContext<
+ TInterfaceType extends InterfaceBaseType,
+ TSerializedStateDef extends ModuleStateBaseSchema = NoModuleStateSchema,
+> = Omit<
+ ModuleContext,
"useSettingsToViewInterfaceValue" | "useViewAtom" | "useViewAtomValue" | "useSetViewAtom"
>;
diff --git a/frontend/src/framework/ModuleInstance.ts b/frontend/src/framework/ModuleInstance.ts
index 96e85f6ab..4935fdce4 100644
--- a/frontend/src/framework/ModuleInstance.ts
+++ b/frontend/src/framework/ModuleInstance.ts
@@ -1,6 +1,8 @@
import type { ErrorInfo } from "react";
import React from "react";
+import type { JTDDataType } from "ajv/dist/core";
+import { Ajv } from "ajv/dist/jtd";
import type { Atom } from "jotai";
import { atom } from "jotai";
import { atomEffect } from "jotai-effect";
@@ -9,14 +11,23 @@ import type { ChannelDefinition, ChannelReceiverDefinition } from "./DataChannel
import type { InitialSettings } from "./InitialSettings";
import { ChannelManager } from "./internal/DataChannels/ChannelManager";
import { ModuleInstanceStatusControllerInternal } from "./internal/ModuleInstanceStatusControllerInternal";
-import type { ImportState, Module, ModuleInterfaceTypes, ModuleSettings, ModuleView } from "./Module";
+import type {
+ ImportStatus,
+ Module,
+ ModuleStateBaseSchema,
+ ModuleInterfaceTypes,
+ ModuleSettings,
+ SerializedModuleState,
+ ModuleView,
+} from "./Module";
import { ModuleContext } from "./ModuleContext";
import type { SyncSettingKey } from "./SyncSettings";
import type { InterfaceInitialization } from "./UniDirectionalModuleComponentsInterface";
import { UniDirectionalModuleComponentsInterface } from "./UniDirectionalModuleComponentsInterface";
-import type { Workbench } from "./Workbench";
-export enum ModuleInstanceState {
+const ajv = new Ajv();
+
+export enum ModuleInstanceLifeCycleState {
INITIALIZING,
OK,
ERROR,
@@ -26,34 +37,59 @@ 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]: ModuleStateBaseSchema;
};
-export interface ModuleInstanceOptions {
- module: Module;
- workbench: Workbench;
- instanceNumber: number;
+export interface ModuleInstanceOptions<
+ TInterfaceTypes extends ModuleInterfaceTypes,
+ TSerializedStateSchema extends ModuleStateBaseSchema,
+> {
+ module: Module;
+ id: string;
channelDefinitions: ChannelDefinition[] | null;
channelReceiverDefinitions: ChannelReceiverDefinition[] | null;
}
-export class ModuleInstance {
+export type ModuleInstanceFullState = {
+ id: string;
+ name: string;
+ dataChannelReceiverSubscriptions: {
+ idString: string;
+ listensToModuleInstanceId: string;
+ channelIdString: string;
+ contentIdStrings: string[];
+ }[];
+ syncedSettingKeys: SyncSettingKey[];
+ serializedState: StringifiedSerializedModuleState | null;
+};
+
+type StringifiedSerializedModuleState = {
+ settings?: string;
+ view?: string;
+};
+
+export class ModuleInstance<
+ TInterfaceTypes extends ModuleInterfaceTypes,
+ TSerializedStateSchema extends ModuleStateBaseSchema,
+> {
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,9 +102,10 @@ export class ModuleInstance {
> | null = null;
private _settingsToViewInterfaceEffectsAtom: Atom | null = null;
private _viewToSettingsInterfaceEffectsAtom: Atom | null = null;
+ private _serializedState: SerializedModuleState | null = null;
- constructor(options: ModuleInstanceOptions) {
- this._id = `${options.module.getName()}-${options.instanceNumber}`;
+ constructor(options: ModuleInstanceOptions) {
+ this._id = options.id;
this._title = options.module.getDefaultTitle();
this._module = options.module;
@@ -88,6 +125,100 @@ export class ModuleInstance {
}
}
+ setSerializedState(serializedState: SerializedModuleState): void {
+ this._serializedState = serializedState;
+ }
+
+ getSerializedState(): SerializedModuleState | null {
+ return this._serializedState;
+ }
+
+ deserializeSerializedState(raw: StringifiedSerializedModuleState): void {
+ const schema = this._module.getSerializedStateSchema();
+ if (!schema) {
+ return; // No schema defined, cannot deserialize
+ }
+
+ let parsedSettings: unknown;
+ let parsedView: unknown;
+ try {
+ parsedSettings = raw.settings ? JSON.parse(raw.settings) : undefined;
+ parsedView = raw.view ? JSON.parse(raw.view) : undefined;
+ } catch (e) {
+ console.warn(`Invalid JSON in module state for ${this._module.getName()}:`, e);
+ this._serializedState = null;
+ return;
+ }
+
+ const validateSettings = ajv.compile(schema.settings);
+ const validateView = ajv.compile(schema.view);
+
+ const isSettingsValid = parsedSettings === undefined || validateSettings(parsedSettings);
+ const isViewValid = parsedView === undefined || validateView(parsedView);
+
+ if (!isSettingsValid || !isViewValid) {
+ console.warn(`Validation failed for ${this._module.getName()}`, {
+ settingsErrors: validateSettings.errors,
+ viewErrors: validateView.errors,
+ });
+ this._serializedState = null;
+ return;
+ }
+
+ this._serializedState = {
+ settings: parsedSettings as JTDDataType,
+ view: parsedView as JTDDataType,
+ };
+ }
+
+ setFullState(fullState: ModuleInstanceFullState): void {
+ this._syncedSettingKeys = fullState.syncedSettingKeys;
+
+ this._id = fullState.id;
+ this._title = fullState.name;
+
+ if (fullState.serializedState) {
+ this.deserializeSerializedState(fullState.serializedState);
+ }
+ }
+
+ getFullState(): ModuleInstanceFullState {
+ return {
+ id: this._id,
+ name: this._module.getName(),
+ 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: {
+ settings: JSON.stringify(this._serializedState?.settings ?? ""),
+ view: JSON.stringify(this._serializedState?.view ?? ""),
+ },
+ };
+ }
+
+ serializeSettingsState(state: JTDDataType): void {
+ this._serializedState = {
+ ...(this._serializedState ?? ({} as SerializedModuleState)),
+ settings: state,
+ };
+ this.notifySubscribers(ModuleInstanceTopic.SERIALIZED_STATE);
+ }
+
+ serializeViewState(state: JTDDataType): void {
+ this._serializedState = {
+ ...(this._serializedState ?? ({} as SerializedModuleState)),
+ view: state,
+ };
+ this.notifySubscribers(ModuleInstanceTopic.SERIALIZED_STATE);
+ }
+
getUniDirectionalSettingsToViewInterface(): UniDirectionalModuleComponentsInterface<
Exclude
> {
@@ -111,9 +242,9 @@ 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);
}
makeSettingsToViewInterface(
@@ -220,19 +351,19 @@ 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}.'?`;
}
@@ -288,18 +419,21 @@ 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) {
+ return this.getSerializedState();
+ }
};
return snapshotGetter;
}
- getModule(): Module {
+ getModule(): Module {
return this._module;
}
@@ -307,17 +441,17 @@ export class ModuleInstance {
return this._statusController;
}
- private setModuleInstanceState(moduleInstanceState: ModuleInstanceState): void {
+ private setModuleInstanceState(moduleInstanceState: ModuleInstanceLifeCycleState): void {
this._moduleInstanceState = moduleInstanceState;
- this.notifySubscribers(ModuleInstanceTopic.STATE);
+ this.notifySubscribers(ModuleInstanceTopic.LIFECYCLE_STATE);
}
- getModuleInstanceState(): ModuleInstanceState {
+ getModuleInstanceState(): ModuleInstanceLifeCycleState {
return this._moduleInstanceState;
}
setFatalError(err: Error, errInfo: ErrorInfo): void {
- this.setModuleInstanceState(ModuleInstanceState.ERROR);
+ this.setModuleInstanceState(ModuleInstanceLifeCycleState.ERROR);
this._fatalError = {
err,
errInfo,
@@ -332,7 +466,7 @@ export class ModuleInstance {
}
reset(): Promise {
- this.setModuleInstanceState(ModuleInstanceState.RESETTING);
+ this.setModuleInstanceState(ModuleInstanceLifeCycleState.RESETTING);
return new Promise((resolve) => {
this._module.onInstanceUnload(this._id);
@@ -353,10 +487,20 @@ export class ModuleInstance {
unload() {
this._module.onInstanceUnload(this._id);
}
+
+ beforeDestroy(): void {
+ this._channelManager.unregisterAllChannels();
+ this._channelManager.unregisterAllReceivers();
+ this._context = null;
+ this._settingsToViewInterface = null;
+ this._viewToSettingsInterface = null;
+ this._settingsToViewInterfaceEffectsAtom = null;
+ this._viewToSettingsInterfaceEffectsAtom = null;
+ }
}
export function useModuleInstanceTopicValue(
- moduleInstance: ModuleInstance,
+ moduleInstance: ModuleInstance,
topic: T,
): ModuleInstanceTopicValueTypes[T] {
const value = React.useSyncExternalStore(
diff --git a/frontend/src/framework/ModuleRegistry.ts b/frontend/src/framework/ModuleRegistry.ts
index f32a717d4..28f1e1629 100644
--- a/frontend/src/framework/ModuleRegistry.ts
+++ b/frontend/src/framework/ModuleRegistry.ts
@@ -2,9 +2,13 @@ import type { ChannelDefinition, ChannelReceiverDefinition } from "./DataChannel
import { ModuleNotFoundPlaceholder } from "./internal/ModuleNotFoundPlaceholder";
import type {
InterfaceEffects,
+ JTDBaseType,
+ MakeReadonly,
+ ModuleStateBaseSchema,
ModuleCategory,
ModuleDevState,
ModuleInterfaceTypes,
+ NoModuleStateSchema,
OnInstanceUnloadFunc,
} from "./Module";
import { Module } from "./Module";
@@ -13,7 +17,7 @@ import type { DrawPreviewFunc } from "./Preview";
import type { SyncSettingKey } from "./SyncSettings";
import type { InterfaceInitialization } from "./UniDirectionalModuleComponentsInterface";
-export type RegisterModuleOptions = {
+export type RegisterModuleOptions = {
moduleName: string;
category: ModuleCategory;
devState: ModuleDevState;
@@ -25,6 +29,7 @@ export type RegisterModuleOptions = {
preview?: DrawPreviewFunc;
description?: string;
onInstanceUnload?: OnInstanceUnloadFunc;
+ serializedStateSchema?: MakeReadonly;
};
export class ModuleNotFoundError extends Error {
@@ -38,15 +43,16 @@ export class ModuleNotFoundError extends Error {
}
export class ModuleRegistry {
- private static _registeredModules: Record> = {};
- private static _moduleNotFoundPlaceholders: Record> = {};
+ private static _registeredModules: Record> = {};
+ private static _moduleNotFoundPlaceholders: Record> = {};
private constructor() {}
- static registerModule(
- options: RegisterModuleOptions,
- ): Module {
- const module = new Module
{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..a744b8d67
--- /dev/null
+++ b/frontend/src/Log.ts
@@ -0,0 +1,198 @@
+/* eslint-disable no-console */
+import { getDebugSetting, setDebugSetting } from "@framework/internal/utils/debug";
+import { formatHex } from "culori";
+import { isArray } from "lodash";
+
+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 =
+
+