@messenger-box/platform-mobile 10.0.3-alpha.20 → 10.0.3-alpha.23

package/src/screens/inbox/workflow/dialog-threads-xstate.ts

@@ -0,0 +1,163 @@
+import { assign, setup } from 'xstate';
+import { threadsMachineConfig } from '../machines/threadsMachine';
+
+export enum BaseState {
+    Idle = 'idle',
+    LoadingChannel = 'loadingChannel',
+    LoadingThreads = 'loadingThreads',
+    Active = 'active',
+    Error = 'error',
+}
+
+export enum Actions {
+    INITIALIZE = 'INITIALIZE',
+    FETCH_CHANNEL_DETAIL = 'FETCH_CHANNEL_DETAIL',
+    SET_CHANNEL_DETAIL = 'SET_CHANNEL_DETAIL',
+    FETCH_THREADS = 'FETCH_THREADS',
+    SET_THREADS = 'SET_THREADS',
+    ERROR = 'ERROR',
+}
+
+// Type definitions for the event data
+type InitializeEventData = { channelId?: string; postParentId?: string; role?: string };
+type ChannelDetailEventData = { id: string };
+type SetChannelDetailEventData = { channelsDetail: any };
+type SetThreadsEventData = { threadData: any[] };
+type ErrorEventData = { error: any };
+
+export const dialogThreadsXstate = setup({
+    types: {
+        context: {} as {
+            channelId?: string;
+            postParentId?: string;
+            role?: string;
+            channelsDetail: any;
+            threadData: any[];
+            loading: boolean;
+            error: any;
+        },
+        events: {} as
+            | { type: typeof Actions.INITIALIZE; data: InitializeEventData }
+            | { type: typeof Actions.FETCH_CHANNEL_DETAIL; data: ChannelDetailEventData }
+            | { type: typeof Actions.SET_CHANNEL_DETAIL; data: SetChannelDetailEventData }
+            | { type: typeof Actions.FETCH_THREADS; data?: {} }
+            | { type: typeof Actions.SET_THREADS; data: SetThreadsEventData }
+            | { type: typeof Actions.ERROR; data: ErrorEventData },
+    },
+    actions: {
+        setInitialContext: assign({
+            channelId: ({ event }) => {
+                if (event.type === Actions.INITIALIZE) {
+                    return event.data.channelId;
+                }
+                return undefined;
+            },
+            postParentId: ({ event }) => {
+                if (event.type === Actions.INITIALIZE) {
+                    return event.data.postParentId;
+                }
+                return undefined;
+            },
+            role: ({ event }) => {
+                if (event.type === Actions.INITIALIZE) {
+                    return event.data.role;
+                }
+                return undefined;
+            },
+            loading: true,
+            error: null,
+        }),
+        setChannelDetail: assign({
+            channelsDetail: ({ event }) => {
+                if (event.type === Actions.SET_CHANNEL_DETAIL) {
+                    return event.data.channelsDetail;
+                }
+                return null;
+            },
+            loading: false,
+        }),
+        setThreads: assign({
+            threadData: ({ event }) => {
+                if (event.type === Actions.SET_THREADS) {
+                    return event.data.threadData;
+                }
+                return [];
+            },
+            loading: false,
+        }),
+        setError: assign({
+            error: ({ event }) => {
+                if (event.type === Actions.ERROR) {
+                    return event.data.error;
+                }
+                return null;
+            },
+            loading: false,
+        }),
+        setLoading: assign({
+            loading: true,
+        }),
+    },
+}).createMachine({
+    id: 'dialogThreads',
+    initial: BaseState.Idle,
+    context: {
+        channelId: undefined,
+        postParentId: undefined,
+        role: undefined,
+        channelsDetail: null,
+        threadData: [],
+        loading: true,
+        error: null,
+    },
+    states: {
+        [BaseState.Idle]: {
+            on: {
+                [Actions.INITIALIZE]: {
+                    target: BaseState.LoadingChannel,
+                    actions: 'setInitialContext',
+                },
+            },
+        },
+        [BaseState.LoadingChannel]: {
+            on: {
+                [Actions.SET_CHANNEL_DETAIL]: {
+                    target: BaseState.LoadingThreads,
+                    actions: 'setChannelDetail',
+                },
+                [Actions.ERROR]: {
+                    target: BaseState.Error,
+                    actions: 'setError',
+                },
+            },
+        },
+        [BaseState.LoadingThreads]: {
+            on: {
+                [Actions.SET_THREADS]: {
+                    target: BaseState.Active,
+                    actions: 'setThreads',
+                },
+                [Actions.ERROR]: {
+                    target: BaseState.Error,
+                    actions: 'setError',
+                },
+            },
+        },
+        [BaseState.Active]: {
+            on: {
+                [Actions.FETCH_THREADS]: {
+                    target: BaseState.LoadingThreads,
+                    actions: 'setLoading',
+                },
+            },
+        },
+        [BaseState.Error]: {
+            on: {
+                [Actions.INITIALIZE]: {
+                    target: BaseState.LoadingChannel,
+                    actions: 'setInitialContext',
+                },
+            },
+        },
+    },
+});