@messenger-box/slack-ui-browser 10.0.3-alpha.176

package/src/machines/routeMachine.ts

@@ -0,0 +1,682 @@
+import { assign, setup } from 'xstate';
+import { SLACK_UI_ROUTES, SLACK_UI_ROUTE_KEYS, slackUiRoutePaths } from '../constants/routes';
+
+/**
+ * Route States Enum - matches SLACK_UI_ROUTES
+ * Note: Using underscores instead of dots to avoid XState hierarchical state interpretation
+ */
+export const enum RouteState {
+    Idle = 'idle',
+    Home = 'home',
+    ChannelsView = 'channelsView',
+    ChannelsNew = 'channelsNew',
+    MessagesView = 'messagesView',
+    MessagesNew = 'messagesNew',
+    TeamsView = 'teamsView',
+    TeamsNew = 'teamsNew',
+    Threads = 'threads',
+    Activity = 'activity',
+    Drafts = 'drafts',
+    Saved = 'saved',
+    Files = 'files',
+    Search = 'search',
+    Invite = 'invite',
+    InviteContacts = 'inviteContacts',
+    InviteEmail = 'inviteEmail',
+    InviteLink = 'inviteLink',
+}
+
+/**
+ * Route Actions Enum
+ */
+export const enum RouteAction {
+    NAVIGATE_HOME = 'NAVIGATE_HOME',
+    NAVIGATE_CHANNEL = 'NAVIGATE_CHANNEL',
+    NAVIGATE_CHANNEL_NEW = 'NAVIGATE_CHANNEL_NEW',
+    NAVIGATE_MESSAGE = 'NAVIGATE_MESSAGE',
+    NAVIGATE_MESSAGE_NEW = 'NAVIGATE_MESSAGE_NEW',
+    NAVIGATE_TEAM = 'NAVIGATE_TEAM',
+    NAVIGATE_TEAM_NEW = 'NAVIGATE_TEAM_NEW',
+    NAVIGATE_THREADS = 'NAVIGATE_THREADS',
+    NAVIGATE_ACTIVITY = 'NAVIGATE_ACTIVITY',
+    NAVIGATE_DRAFTS = 'NAVIGATE_DRAFTS',
+    NAVIGATE_SAVED = 'NAVIGATE_SAVED',
+    NAVIGATE_FILES = 'NAVIGATE_FILES',
+    NAVIGATE_SEARCH = 'NAVIGATE_SEARCH',
+    NAVIGATE_INVITE = 'NAVIGATE_INVITE',
+    NAVIGATE_INVITE_CONTACTS = 'NAVIGATE_INVITE_CONTACTS',
+    NAVIGATE_INVITE_EMAIL = 'NAVIGATE_INVITE_EMAIL',
+    NAVIGATE_INVITE_LINK = 'NAVIGATE_INVITE_LINK',
+    UPDATE_FROM_PATHNAME = 'UPDATE_FROM_PATHNAME',
+}
+
+/**
+ * Route Context Type
+ */
+export interface RouteContext {
+    orgSlug: string;
+    currentPath: string;
+    currentRouteKey: string | null;
+    channelName: string | null;
+    teamName: string | null;
+    previousPath: string | null;
+}
+
+/**
+ * Route Event Types
+ */
+export type RouteEvent =
+    | { type: RouteAction.NAVIGATE_HOME }
+    | { type: RouteAction.NAVIGATE_CHANNEL; channelName: string }
+    | { type: RouteAction.NAVIGATE_CHANNEL_NEW }
+    | { type: RouteAction.NAVIGATE_MESSAGE; channelName: string }
+    | { type: RouteAction.NAVIGATE_MESSAGE_NEW }
+    | { type: RouteAction.NAVIGATE_TEAM; teamName: string }
+    | { type: RouteAction.NAVIGATE_TEAM_NEW }
+    | { type: RouteAction.NAVIGATE_THREADS }
+    | { type: RouteAction.NAVIGATE_ACTIVITY }
+    | { type: RouteAction.NAVIGATE_DRAFTS }
+    | { type: RouteAction.NAVIGATE_SAVED }
+    | { type: RouteAction.NAVIGATE_FILES }
+    | { type: RouteAction.NAVIGATE_SEARCH }
+    | { type: RouteAction.NAVIGATE_INVITE }
+    | { type: RouteAction.NAVIGATE_INVITE_CONTACTS }
+    | { type: RouteAction.NAVIGATE_INVITE_EMAIL }
+    | { type: RouteAction.NAVIGATE_INVITE_LINK }
+    | { type: RouteAction.UPDATE_FROM_PATHNAME; pathname: string };
+
+/**
+ * Parse pathname to determine current route state and context
+ */
+export function parsePathname(pathname: string, orgSlug: string): { 
+    state: RouteState; 
+    routeKey: string | null;
+    channelName: string | null; 
+    teamName: string | null;
+} {
+    const basePath = `/o/${orgSlug}/home`;
+    
+    // Check each route pattern
+    if (pathname.endsWith('/channels/new')) {
+        return { state: RouteState.ChannelsNew, routeKey: SLACK_UI_ROUTE_KEYS.CHANNELS_NEW, channelName: null, teamName: null };
+    }
+    if (pathname.includes('/channels/')) {
+        const match = pathname.match(/\/channels\/([^/]+)$/);
+        return { 
+            state: RouteState.ChannelsView, 
+            routeKey: SLACK_UI_ROUTE_KEYS.CHANNELS,
+            channelName: match?.[1] || null, 
+            teamName: null 
+        };
+    }
+    if (pathname.endsWith('/messages/new')) {
+        return { state: RouteState.MessagesNew, routeKey: SLACK_UI_ROUTE_KEYS.MESSAGES_NEW, channelName: null, teamName: null };
+    }
+    if (pathname.includes('/messages/')) {
+        const match = pathname.match(/\/messages\/([^/]+)$/);
+        return { 
+            state: RouteState.MessagesView, 
+            routeKey: SLACK_UI_ROUTE_KEYS.MESSAGES,
+            channelName: match?.[1] || null, 
+            teamName: null 
+        };
+    }
+    if (pathname.endsWith('/teams/new')) {
+        return { state: RouteState.TeamsNew, routeKey: SLACK_UI_ROUTE_KEYS.TEAMS_NEW, channelName: null, teamName: null };
+    }
+    if (pathname.includes('/teams/')) {
+        const match = pathname.match(/\/teams\/([^/]+)$/);
+        return { 
+            state: RouteState.TeamsView, 
+            routeKey: SLACK_UI_ROUTE_KEYS.TEAMS,
+            channelName: null, 
+            teamName: match?.[1] || null 
+        };
+    }
+    if (pathname.endsWith('/invite/contacts')) {
+        return { state: RouteState.InviteContacts, routeKey: SLACK_UI_ROUTE_KEYS.INVITE_CONTACTS, channelName: null, teamName: null };
+    }
+    if (pathname.endsWith('/invite/email')) {
+        return { state: RouteState.InviteEmail, routeKey: SLACK_UI_ROUTE_KEYS.INVITE_EMAIL, channelName: null, teamName: null };
+    }
+    if (pathname.endsWith('/invite/link')) {
+        return { state: RouteState.InviteLink, routeKey: SLACK_UI_ROUTE_KEYS.INVITE_LINK, channelName: null, teamName: null };
+    }
+    if (pathname.includes('/invite')) {
+        return { state: RouteState.Invite, routeKey: SLACK_UI_ROUTE_KEYS.INVITE, channelName: null, teamName: null };
+    }
+    if (pathname.endsWith('/threads')) {
+        return { state: RouteState.Threads, routeKey: SLACK_UI_ROUTE_KEYS.THREADS, channelName: null, teamName: null };
+    }
+    if (pathname.endsWith('/activity')) {
+        return { state: RouteState.Activity, routeKey: SLACK_UI_ROUTE_KEYS.ACTIVITY, channelName: null, teamName: null };
+    }
+    if (pathname.endsWith('/drafts')) {
+        return { state: RouteState.Drafts, routeKey: SLACK_UI_ROUTE_KEYS.DRAFTS, channelName: null, teamName: null };
+    }
+    if (pathname.endsWith('/saved')) {
+        return { state: RouteState.Saved, routeKey: SLACK_UI_ROUTE_KEYS.SAVED, channelName: null, teamName: null };
+    }
+    if (pathname.endsWith('/files')) {
+        return { state: RouteState.Files, routeKey: SLACK_UI_ROUTE_KEYS.FILES, channelName: null, teamName: null };
+    }
+    if (pathname.endsWith('/search')) {
+        return { state: RouteState.Search, routeKey: SLACK_UI_ROUTE_KEYS.SEARCH, channelName: null, teamName: null };
+    }
+    
+    // Default to Home
+    return { state: RouteState.Home, routeKey: SLACK_UI_ROUTE_KEYS.HOME, channelName: null, teamName: null };
+}
+
+/**
+ * Get the path for a given route state
+ */
+export function getPathForRouteState(
+    state: RouteState, 
+    orgSlug: string, 
+    params?: { channelName?: string; teamName?: string }
+): string {
+    switch (state) {
+        case RouteState.Home:
+        case RouteState.Idle:
+            return slackUiRoutePaths.home(orgSlug);
+        case RouteState.ChannelsNew:
+            return slackUiRoutePaths.channelNew(orgSlug);
+        case RouteState.ChannelsView:
+            return slackUiRoutePaths.channel(orgSlug, params?.channelName || '');
+        case RouteState.MessagesNew:
+            return slackUiRoutePaths.messageNew(orgSlug);
+        case RouteState.MessagesView:
+            return slackUiRoutePaths.message(orgSlug, params?.channelName || '');
+        case RouteState.TeamsNew:
+            return slackUiRoutePaths.teamNew(orgSlug);
+        case RouteState.TeamsView:
+            return slackUiRoutePaths.team(orgSlug, params?.teamName || '');
+        case RouteState.Threads:
+            return slackUiRoutePaths.threads(orgSlug);
+        case RouteState.Activity:
+            return slackUiRoutePaths.activity(orgSlug);
+        case RouteState.Drafts:
+            return slackUiRoutePaths.drafts(orgSlug);
+        case RouteState.Saved:
+            return slackUiRoutePaths.saved(orgSlug);
+        case RouteState.Files:
+            return slackUiRoutePaths.files(orgSlug);
+        case RouteState.Search:
+            return slackUiRoutePaths.search(orgSlug);
+        case RouteState.Invite:
+            return slackUiRoutePaths.invite(orgSlug);
+        case RouteState.InviteContacts:
+            return slackUiRoutePaths.inviteContacts(orgSlug);
+        case RouteState.InviteEmail:
+            return slackUiRoutePaths.inviteEmail(orgSlug);
+        case RouteState.InviteLink:
+            return slackUiRoutePaths.inviteLink(orgSlug);
+        default:
+            return slackUiRoutePaths.home(orgSlug);
+    }
+}
+
+/**
+ * Slack UI Route Machine
+ * Manages navigation state for the slack-ui browser package
+ */
+export const routeMachine = setup({
+    types: {
+        context: {} as RouteContext,
+        events: {} as RouteEvent,
+    },
+    actions: {
+        updateContext: assign(({ context, event }) => {
+            if (event.type === RouteAction.UPDATE_FROM_PATHNAME) {
+                const parsed = parsePathname(event.pathname, context.orgSlug);
+                return {
+                    ...context,
+                    previousPath: context.currentPath,
+                    currentPath: event.pathname,
+                    currentRouteKey: parsed.routeKey,
+                    channelName: parsed.channelName,
+                    teamName: parsed.teamName,
+                };
+            }
+            return context;
+        }),
+        setChannelName: assign(({ context, event }) => {
+            if (event.type === RouteAction.NAVIGATE_CHANNEL) {
+                return {
+                    ...context,
+                    channelName: event.channelName,
+                    currentPath: slackUiRoutePaths.channel(context.orgSlug, event.channelName),
+                    currentRouteKey: SLACK_UI_ROUTE_KEYS.CHANNELS,
+                };
+            }
+            return context;
+        }),
+        setMessageChannelName: assign(({ context, event }) => {
+            if (event.type === RouteAction.NAVIGATE_MESSAGE) {
+                return {
+                    ...context,
+                    channelName: event.channelName,
+                    currentPath: slackUiRoutePaths.message(context.orgSlug, event.channelName),
+                    currentRouteKey: SLACK_UI_ROUTE_KEYS.MESSAGES,
+                };
+            }
+            return context;
+        }),
+        setTeamName: assign(({ context, event }) => {
+            if (event.type === RouteAction.NAVIGATE_TEAM) {
+                return {
+                    ...context,
+                    teamName: event.teamName,
+                    currentPath: slackUiRoutePaths.team(context.orgSlug, event.teamName),
+                    currentRouteKey: SLACK_UI_ROUTE_KEYS.TEAMS,
+                };
+            }
+            return context;
+        }),
+        clearParams: assign(({ context }) => ({
+            ...context,
+            channelName: null,
+            teamName: null,
+        })),
+        updatePathToHome: assign(({ context }) => ({
+            ...context,
+            previousPath: context.currentPath,
+            currentPath: slackUiRoutePaths.home(context.orgSlug),
+            currentRouteKey: SLACK_UI_ROUTE_KEYS.HOME,
+        })),
+        updatePathToChannelNew: assign(({ context }) => ({
+            ...context,
+            previousPath: context.currentPath,
+            currentPath: slackUiRoutePaths.channelNew(context.orgSlug),
+            currentRouteKey: SLACK_UI_ROUTE_KEYS.CHANNELS_NEW,
+            channelName: null,
+        })),
+        updatePathToMessageNew: assign(({ context }) => ({
+            ...context,
+            previousPath: context.currentPath,
+            currentPath: slackUiRoutePaths.messageNew(context.orgSlug),
+            currentRouteKey: SLACK_UI_ROUTE_KEYS.MESSAGES_NEW,
+            channelName: null,
+        })),
+        updatePathToTeamNew: assign(({ context }) => ({
+            ...context,
+            previousPath: context.currentPath,
+            currentPath: slackUiRoutePaths.teamNew(context.orgSlug),
+            currentRouteKey: SLACK_UI_ROUTE_KEYS.TEAMS_NEW,
+            teamName: null,
+        })),
+        updatePathToThreads: assign(({ context }) => ({
+            ...context,
+            previousPath: context.currentPath,
+            currentPath: slackUiRoutePaths.threads(context.orgSlug),
+            currentRouteKey: SLACK_UI_ROUTE_KEYS.THREADS,
+        })),
+        updatePathToActivity: assign(({ context }) => ({
+            ...context,
+            previousPath: context.currentPath,
+            currentPath: slackUiRoutePaths.activity(context.orgSlug),
+            currentRouteKey: SLACK_UI_ROUTE_KEYS.ACTIVITY,
+        })),
+        updatePathToDrafts: assign(({ context }) => ({
+            ...context,
+            previousPath: context.currentPath,
+            currentPath: slackUiRoutePaths.drafts(context.orgSlug),
+            currentRouteKey: SLACK_UI_ROUTE_KEYS.DRAFTS,
+        })),
+        updatePathToSaved: assign(({ context }) => ({
+            ...context,
+            previousPath: context.currentPath,
+            currentPath: slackUiRoutePaths.saved(context.orgSlug),
+            currentRouteKey: SLACK_UI_ROUTE_KEYS.SAVED,
+        })),
+        updatePathToFiles: assign(({ context }) => ({
+            ...context,
+            previousPath: context.currentPath,
+            currentPath: slackUiRoutePaths.files(context.orgSlug),
+            currentRouteKey: SLACK_UI_ROUTE_KEYS.FILES,
+        })),
+        updatePathToSearch: assign(({ context }) => ({
+            ...context,
+            previousPath: context.currentPath,
+            currentPath: slackUiRoutePaths.search(context.orgSlug),
+            currentRouteKey: SLACK_UI_ROUTE_KEYS.SEARCH,
+        })),
+        updatePathToInvite: assign(({ context }) => ({
+            ...context,
+            previousPath: context.currentPath,
+            currentPath: slackUiRoutePaths.invite(context.orgSlug),
+            currentRouteKey: SLACK_UI_ROUTE_KEYS.INVITE,
+        })),
+        updatePathToInviteContacts: assign(({ context }) => ({
+            ...context,
+            previousPath: context.currentPath,
+            currentPath: slackUiRoutePaths.inviteContacts(context.orgSlug),
+            currentRouteKey: SLACK_UI_ROUTE_KEYS.INVITE_CONTACTS,
+        })),
+        updatePathToInviteEmail: assign(({ context }) => ({
+            ...context,
+            previousPath: context.currentPath,
+            currentPath: slackUiRoutePaths.inviteEmail(context.orgSlug),
+            currentRouteKey: SLACK_UI_ROUTE_KEYS.INVITE_EMAIL,
+        })),
+        updatePathToInviteLink: assign(({ context }) => ({
+            ...context,
+            previousPath: context.currentPath,
+            currentPath: slackUiRoutePaths.inviteLink(context.orgSlug),
+            currentRouteKey: SLACK_UI_ROUTE_KEYS.INVITE_LINK,
+        })),
+    },
+    guards: {
+        hasChannelName: ({ event }) => {
+            if (event.type === RouteAction.NAVIGATE_CHANNEL) {
+                return !!event.channelName;
+            }
+            return false;
+        },
+        hasTeamName: ({ event }) => {
+            if (event.type === RouteAction.NAVIGATE_TEAM) {
+                return !!event.teamName;
+            }
+            return false;
+        },
+    },
+}).createMachine({
+    id: 'slack-ui-routes',
+    initial: RouteState.Idle,
+    context: {
+        orgSlug: '',
+        currentPath: '',
+        currentRouteKey: null,
+        channelName: null,
+        teamName: null,
+        previousPath: null,
+    },
+    states: {
+        [RouteState.Idle]: {
+            on: {
+                [RouteAction.UPDATE_FROM_PATHNAME]: {
+                    actions: ['updateContext'],
+                },
+                [RouteAction.NAVIGATE_HOME]: {
+                    target: RouteState.Home,
+                    actions: ['clearParams', 'updatePathToHome'],
+                },
+                [RouteAction.NAVIGATE_CHANNEL]: {
+                    target: RouteState.ChannelsView,
+                    guard: 'hasChannelName',
+                    actions: ['setChannelName'],
+                },
+                [RouteAction.NAVIGATE_CHANNEL_NEW]: {
+                    target: RouteState.ChannelsNew,
+                    actions: ['updatePathToChannelNew'],
+                },
+                [RouteAction.NAVIGATE_MESSAGE]: {
+                    target: RouteState.MessagesView,
+                    actions: ['setMessageChannelName'],
+                },
+                [RouteAction.NAVIGATE_MESSAGE_NEW]: {
+                    target: RouteState.MessagesNew,
+                    actions: ['updatePathToMessageNew'],
+                },
+                [RouteAction.NAVIGATE_TEAM]: {
+                    target: RouteState.TeamsView,
+                    guard: 'hasTeamName',
+                    actions: ['setTeamName'],
+                },
+                [RouteAction.NAVIGATE_TEAM_NEW]: {
+                    target: RouteState.TeamsNew,
+                    actions: ['updatePathToTeamNew'],
+                },
+                [RouteAction.NAVIGATE_THREADS]: {
+                    target: RouteState.Threads,
+                    actions: ['updatePathToThreads'],
+                },
+                [RouteAction.NAVIGATE_ACTIVITY]: {
+                    target: RouteState.Activity,
+                    actions: ['updatePathToActivity'],
+                },
+                [RouteAction.NAVIGATE_DRAFTS]: {
+                    target: RouteState.Drafts,
+                    actions: ['updatePathToDrafts'],
+                },
+                [RouteAction.NAVIGATE_SAVED]: {
+                    target: RouteState.Saved,
+                    actions: ['updatePathToSaved'],
+                },
+                [RouteAction.NAVIGATE_FILES]: {
+                    target: RouteState.Files,
+                    actions: ['updatePathToFiles'],
+                },
+                [RouteAction.NAVIGATE_SEARCH]: {
+                    target: RouteState.Search,
+                    actions: ['updatePathToSearch'],
+                },
+                [RouteAction.NAVIGATE_INVITE]: {
+                    target: RouteState.Invite,
+                    actions: ['updatePathToInvite'],
+                },
+                [RouteAction.NAVIGATE_INVITE_CONTACTS]: {
+                    target: RouteState.InviteContacts,
+                    actions: ['updatePathToInviteContacts'],
+                },
+                [RouteAction.NAVIGATE_INVITE_EMAIL]: {
+                    target: RouteState.InviteEmail,
+                    actions: ['updatePathToInviteEmail'],
+                },
+                [RouteAction.NAVIGATE_INVITE_LINK]: {
+                    target: RouteState.InviteLink,
+                    actions: ['updatePathToInviteLink'],
+                },
+            },
+        },
+        [RouteState.Home]: {
+            on: {
+                [RouteAction.UPDATE_FROM_PATHNAME]: {
+                    actions: ['updateContext'],
+                },
+                [RouteAction.NAVIGATE_CHANNEL]: {
+                    target: RouteState.ChannelsView,
+                    guard: 'hasChannelName',
+                    actions: ['setChannelName'],
+                },
+                [RouteAction.NAVIGATE_CHANNEL_NEW]: {
+                    target: RouteState.ChannelsNew,
+                    actions: ['updatePathToChannelNew'],
+                },
+                [RouteAction.NAVIGATE_MESSAGE]: {
+                    target: RouteState.MessagesView,
+                    actions: ['setMessageChannelName'],
+                },
+                [RouteAction.NAVIGATE_MESSAGE_NEW]: {
+                    target: RouteState.MessagesNew,
+                    actions: ['updatePathToMessageNew'],
+                },
+                [RouteAction.NAVIGATE_TEAM]: {
+                    target: RouteState.TeamsView,
+                    guard: 'hasTeamName',
+                    actions: ['setTeamName'],
+                },
+                [RouteAction.NAVIGATE_TEAM_NEW]: {
+                    target: RouteState.TeamsNew,
+                    actions: ['updatePathToTeamNew'],
+                },
+                [RouteAction.NAVIGATE_THREADS]: {
+                    target: RouteState.Threads,
+                    actions: ['updatePathToThreads'],
+                },
+                [RouteAction.NAVIGATE_ACTIVITY]: {
+                    target: RouteState.Activity,
+                    actions: ['updatePathToActivity'],
+                },
+                [RouteAction.NAVIGATE_DRAFTS]: {
+                    target: RouteState.Drafts,
+                    actions: ['updatePathToDrafts'],
+                },
+                [RouteAction.NAVIGATE_SAVED]: {
+                    target: RouteState.Saved,
+                    actions: ['updatePathToSaved'],
+                },
+                [RouteAction.NAVIGATE_FILES]: {
+                    target: RouteState.Files,
+                    actions: ['updatePathToFiles'],
+                },
+                [RouteAction.NAVIGATE_SEARCH]: {
+                    target: RouteState.Search,
+                    actions: ['updatePathToSearch'],
+                },
+                [RouteAction.NAVIGATE_INVITE]: {
+                    target: RouteState.Invite,
+                    actions: ['updatePathToInvite'],
+                },
+                [RouteAction.NAVIGATE_INVITE_CONTACTS]: {
+                    target: RouteState.InviteContacts,
+                    actions: ['updatePathToInviteContacts'],
+                },
+                [RouteAction.NAVIGATE_INVITE_EMAIL]: {
+                    target: RouteState.InviteEmail,
+                    actions: ['updatePathToInviteEmail'],
+                },
+                [RouteAction.NAVIGATE_INVITE_LINK]: {
+                    target: RouteState.InviteLink,
+                    actions: ['updatePathToInviteLink'],
+                },
+            },
+        },
+        [RouteState.ChannelsView]: {
+            on: {
+                [RouteAction.UPDATE_FROM_PATHNAME]: { actions: ['updateContext'] },
+                [RouteAction.NAVIGATE_HOME]: { target: RouteState.Home, actions: ['clearParams', 'updatePathToHome'] },
+                [RouteAction.NAVIGATE_CHANNEL]: { actions: ['setChannelName'] },
+                [RouteAction.NAVIGATE_CHANNEL_NEW]: { target: RouteState.ChannelsNew, actions: ['updatePathToChannelNew'] },
+                [RouteAction.NAVIGATE_MESSAGE]: { target: RouteState.MessagesView, actions: ['setMessageChannelName'] },
+                [RouteAction.NAVIGATE_MESSAGE_NEW]: { target: RouteState.MessagesNew, actions: ['updatePathToMessageNew'] },
+            },
+        },
+        [RouteState.ChannelsNew]: {
+            on: {
+                [RouteAction.UPDATE_FROM_PATHNAME]: { actions: ['updateContext'] },
+                [RouteAction.NAVIGATE_HOME]: { target: RouteState.Home, actions: ['clearParams', 'updatePathToHome'] },
+                [RouteAction.NAVIGATE_CHANNEL]: { target: RouteState.ChannelsView, actions: ['setChannelName'] },
+            },
+        },
+        [RouteState.MessagesView]: {
+            on: {
+                [RouteAction.UPDATE_FROM_PATHNAME]: { actions: ['updateContext'] },
+                [RouteAction.NAVIGATE_HOME]: { target: RouteState.Home, actions: ['clearParams', 'updatePathToHome'] },
+                [RouteAction.NAVIGATE_CHANNEL]: { target: RouteState.ChannelsView, actions: ['setChannelName'] },
+                [RouteAction.NAVIGATE_MESSAGE]: { actions: ['setMessageChannelName'] },
+                [RouteAction.NAVIGATE_MESSAGE_NEW]: { target: RouteState.MessagesNew, actions: ['updatePathToMessageNew'] },
+            },
+        },
+        [RouteState.MessagesNew]: {
+            on: {
+                [RouteAction.UPDATE_FROM_PATHNAME]: { actions: ['updateContext'] },
+                [RouteAction.NAVIGATE_HOME]: { target: RouteState.Home, actions: ['clearParams', 'updatePathToHome'] },
+                [RouteAction.NAVIGATE_MESSAGE]: { target: RouteState.MessagesView, actions: ['setMessageChannelName'] },
+            },
+        },
+        [RouteState.TeamsView]: {
+            on: {
+                [RouteAction.UPDATE_FROM_PATHNAME]: { actions: ['updateContext'] },
+                [RouteAction.NAVIGATE_HOME]: { target: RouteState.Home, actions: ['clearParams', 'updatePathToHome'] },
+                [RouteAction.NAVIGATE_TEAM]: { actions: ['setTeamName'] },
+                [RouteAction.NAVIGATE_TEAM_NEW]: { target: RouteState.TeamsNew, actions: ['updatePathToTeamNew'] },
+            },
+        },
+        [RouteState.TeamsNew]: {
+            on: {
+                [RouteAction.UPDATE_FROM_PATHNAME]: { actions: ['updateContext'] },
+                [RouteAction.NAVIGATE_HOME]: { target: RouteState.Home, actions: ['clearParams', 'updatePathToHome'] },
+                [RouteAction.NAVIGATE_TEAM]: { target: RouteState.TeamsView, actions: ['setTeamName'] },
+            },
+        },
+        [RouteState.Threads]: {
+            on: {
+                [RouteAction.UPDATE_FROM_PATHNAME]: { actions: ['updateContext'] },
+                [RouteAction.NAVIGATE_HOME]: { target: RouteState.Home, actions: ['clearParams', 'updatePathToHome'] },
+                [RouteAction.NAVIGATE_CHANNEL]: { target: RouteState.ChannelsView, actions: ['setChannelName'] },
+                [RouteAction.NAVIGATE_MESSAGE]: { target: RouteState.MessagesView, actions: ['setMessageChannelName'] },
+            },
+        },
+        [RouteState.Activity]: {
+            on: {
+                [RouteAction.UPDATE_FROM_PATHNAME]: { actions: ['updateContext'] },
+                [RouteAction.NAVIGATE_HOME]: { target: RouteState.Home, actions: ['clearParams', 'updatePathToHome'] },
+            },
+        },
+        [RouteState.Drafts]: {
+            on: {
+                [RouteAction.UPDATE_FROM_PATHNAME]: { actions: ['updateContext'] },
+                [RouteAction.NAVIGATE_HOME]: { target: RouteState.Home, actions: ['clearParams', 'updatePathToHome'] },
+            },
+        },
+        [RouteState.Saved]: {
+            on: {
+                [RouteAction.UPDATE_FROM_PATHNAME]: { actions: ['updateContext'] },
+                [RouteAction.NAVIGATE_HOME]: { target: RouteState.Home, actions: ['clearParams', 'updatePathToHome'] },
+            },
+        },
+        [RouteState.Files]: {
+            on: {
+                [RouteAction.UPDATE_FROM_PATHNAME]: { actions: ['updateContext'] },
+                [RouteAction.NAVIGATE_HOME]: { target: RouteState.Home, actions: ['clearParams', 'updatePathToHome'] },
+            },
+        },
+        [RouteState.Search]: {
+            on: {
+                [RouteAction.UPDATE_FROM_PATHNAME]: { actions: ['updateContext'] },
+                [RouteAction.NAVIGATE_HOME]: { target: RouteState.Home, actions: ['clearParams', 'updatePathToHome'] },
+            },
+        },
+        [RouteState.Invite]: {
+            on: {
+                [RouteAction.UPDATE_FROM_PATHNAME]: { actions: ['updateContext'] },
+                [RouteAction.NAVIGATE_HOME]: { target: RouteState.Home, actions: ['clearParams', 'updatePathToHome'] },
+                [RouteAction.NAVIGATE_INVITE_CONTACTS]: { target: RouteState.InviteContacts, actions: ['updatePathToInviteContacts'] },
+                [RouteAction.NAVIGATE_INVITE_EMAIL]: { target: RouteState.InviteEmail, actions: ['updatePathToInviteEmail'] },
+                [RouteAction.NAVIGATE_INVITE_LINK]: { target: RouteState.InviteLink, actions: ['updatePathToInviteLink'] },
+            },
+        },
+        [RouteState.InviteContacts]: {
+            on: {
+                [RouteAction.UPDATE_FROM_PATHNAME]: { actions: ['updateContext'] },
+                [RouteAction.NAVIGATE_HOME]: { target: RouteState.Home, actions: ['clearParams', 'updatePathToHome'] },
+                [RouteAction.NAVIGATE_INVITE]: { target: RouteState.Invite, actions: ['updatePathToInvite'] },
+            },
+        },
+        [RouteState.InviteEmail]: {
+            on: {
+                [RouteAction.UPDATE_FROM_PATHNAME]: { actions: ['updateContext'] },
+                [RouteAction.NAVIGATE_HOME]: { target: RouteState.Home, actions: ['clearParams', 'updatePathToHome'] },
+                [RouteAction.NAVIGATE_INVITE]: { target: RouteState.Invite, actions: ['updatePathToInvite'] },
+            },
+        },
+        [RouteState.InviteLink]: {
+            on: {
+                [RouteAction.UPDATE_FROM_PATHNAME]: { actions: ['updateContext'] },
+                [RouteAction.NAVIGATE_HOME]: { target: RouteState.Home, actions: ['clearParams', 'updatePathToHome'] },
+                [RouteAction.NAVIGATE_INVITE]: { target: RouteState.Invite, actions: ['updatePathToInvite'] },
+            },
+        },
+    },
+});
+
+/**
+ * Factory function to create a route machine with initial context
+ */
+export function createRouteMachineWithContext(orgSlug: string, initialPathname: string) {
+    const parsed = parsePathname(initialPathname, orgSlug);
+    
+    // In XState v5, we create a new machine with updated context via provide
+    return routeMachine.provide({
+        context: {
+            orgSlug,
+            currentPath: initialPathname,
+            currentRouteKey: parsed.routeKey,
+            channelName: parsed.channelName,
+            teamName: parsed.teamName,
+            previousPath: null,
+        } as RouteContext,
+    } as any);
+}

package/src/module.tsx

@@ -0,0 +1,6 @@
+import { Feature } from '@common-stack/client-react';
+import { filteredRoutes } from './compute';
+
+export default new Feature({
+    routeConfig: filteredRoutes as any,
+});

package/src/queries/index.ts

@@ -0,0 +1 @@
+export * from './slackuiQueries';