KeepCurrentChannel

index.ts

Download

Source

src/plugins/keepCurrentChannel/index.ts

1import * as DataStore from "@api/DataStore";

2import { Devs } from "@utils/constants";

3import definePlugin from "@utils/types";

import { ChannelRouter, ChannelStore, NavigationRouter, SelectedChannelStore, SelectedGuildStore } from "@webpack/common";

6export interface LogoutEvent {

7 type: "LOGOUT";

8 isSwitchingAccount: boolean;

9}

11interface ChannelSelectEvent {

12 type: "CHANNEL_SELECT";

13 channelId: string | null;

14 guildId: string | null;

15}

17interface PreviousChannel {

18 guildId: string | null;

19 channelId: string | null;

20}

22let isSwitchingAccount = false;

23let previousCache: PreviousChannel | undefined;

25export default definePlugin({

26 name: "KeepCurrentChannel",

27 description: "Attempt to navigate to the channel you were in before switching accounts or loading Discord.",

28 tags: ["Utility", "Organisation"],

29 authors: [Devs.Nuckyz],

31 patches: [

32 {

33 find: '"Switching accounts"',

34 replacement: {

35 match: /goHomeAfterSwitching:\i/,

36 replace: "goHomeAfterSwitching:!1"

37 }

38 }

39 ],

41 flux: {

42 LOGOUT(e: LogoutEvent) {

43 ({ isSwitchingAccount } = e);

44 },

46 CONNECTION_OPEN() {

47 if (!isSwitchingAccount) return;

48 isSwitchingAccount = false;

50 if (previousCache?.channelId) {

51 if (ChannelStore.hasChannel(previousCache.channelId)) {

52 ChannelRouter.transitionToChannel(previousCache.channelId);

53 } else {

54 NavigationRouter.transitionToGuild("@me");

55 }

56 }

57 },

59 async CHANNEL_SELECT({ guildId, channelId }: ChannelSelectEvent) {

60 if (isSwitchingAccount) return;

62 previousCache = {

63 guildId,

64 channelId

65 };

66 await DataStore.set("KeepCurrentChannel_previousData", previousCache);

67 }

68 },

70 async start() {

71 previousCache = await DataStore.get<PreviousChannel>("KeepCurrentChannel_previousData");

72 if (!previousCache) {

73 previousCache = {

74 guildId: SelectedGuildStore.getGuildId(),

75 channelId: SelectedChannelStore.getChannelId() ?? null

76 };

78 await DataStore.set("KeepCurrentChannel_previousData", previousCache);

79 } else if (previousCache.channelId) {

80 ChannelRouter.transitionToChannel(previousCache.channelId);

81 }

82 }

83});

import * as DataStore from "@api/DataStore";
import { Devs } from "@utils/constants";
import definePlugin from "@utils/types";
import { ChannelRouter, ChannelStore, NavigationRouter, SelectedChannelStore, SelectedGuildStore } from "@webpack/common";

export interface LogoutEvent {
    type: "LOGOUT";
    isSwitchingAccount: boolean;
}

interface ChannelSelectEvent {
    type: "CHANNEL_SELECT";
    channelId: string | null;
    guildId: string | null;
}

interface PreviousChannel {
    guildId: string | null;
    channelId: string | null;
}

let isSwitchingAccount = false;
let previousCache: PreviousChannel | undefined;

export default definePlugin({
    name: "KeepCurrentChannel",
    description: "Attempt to navigate to the channel you were in before switching accounts or loading Discord.",
    tags: ["Utility", "Organisation"],
    authors: [Devs.Nuckyz],

    patches: [
        {
            find: '"Switching accounts"',
            replacement: {
                match: /goHomeAfterSwitching:\i/,
                replace: "goHomeAfterSwitching:!1"
            }
        }
    ],

    flux: {
        LOGOUT(e: LogoutEvent) {
            ({ isSwitchingAccount } = e);
        },

        CONNECTION_OPEN() {
            if (!isSwitchingAccount) return;
            isSwitchingAccount = false;

            if (previousCache?.channelId) {
                if (ChannelStore.hasChannel(previousCache.channelId)) {
                    ChannelRouter.transitionToChannel(previousCache.channelId);
                } else {
                    NavigationRouter.transitionToGuild("@me");
                }
            }
        },

        async CHANNEL_SELECT({ guildId, channelId }: ChannelSelectEvent) {
            if (isSwitchingAccount) return;

            previousCache = {
                guildId,
                channelId
            };
            await DataStore.set("KeepCurrentChannel_previousData", previousCache);
        }
    },

    async start() {
        previousCache = await DataStore.get<PreviousChannel>("KeepCurrentChannel_previousData");
        if (!previousCache) {
            previousCache = {
                guildId: SelectedGuildStore.getGuildId(),
                channelId: SelectedChannelStore.getChannelId() ?? null
            };

            await DataStore.set("KeepCurrentChannel_previousData", previousCache);
        } else if (previousCache.channelId) {
            ChannelRouter.transitionToChannel(previousCache.channelId);
        }
    }
});

Source

FiveCord for Windows