From b21b6d7e5dae67537864274bd9e9f58c1f827b8f Mon Sep 17 00:00:00 2001
From: V <vendicated@riseup.net>
Date: Wed, 22 Nov 2023 06:48:59 +0100
Subject: [PATCH] Make it possible to destructure lazy webpack finds

---
 src/plugins/betterFolders/index.tsx      |  5 ++---
 src/plugins/greetStickerPicker/index.tsx |  5 ++---
 src/utils/lazy.ts                        | 25 +++++++++++++++++++++---
 src/webpack/common/stores.ts             | 19 +++++++++---------
 4 files changed, 36 insertions(+), 18 deletions(-)

diff --git a/src/plugins/betterFolders/index.tsx b/src/plugins/betterFolders/index.tsx
index 8f40d90f..68c50bcf 100644
--- a/src/plugins/betterFolders/index.tsx
+++ b/src/plugins/betterFolders/index.tsx
@@ -18,9 +18,8 @@
 
 import { definePluginSettings } from "@api/Settings";
 import { Devs } from "@utils/constants";
-import { proxyLazy } from "@utils/lazy";
 import definePlugin, { OptionType } from "@utils/types";
-import { findByProps, findByPropsLazy, findStoreLazy } from "@webpack";
+import { findByPropsLazy, findStoreLazy } from "@webpack";
 import { FluxDispatcher, i18n } from "@webpack/common";
 
 import FolderSideBar from "./FolderSideBar";
@@ -31,7 +30,7 @@ enum FolderIconDisplay {
     MoreThanOneFolderExpanded
 }
 
-const GuildsTree = proxyLazy(() => findByProps("GuildsTree").GuildsTree);
+const { GuildsTree } = findByPropsLazy("GuildsTree");
 const SortedGuildStore = findStoreLazy("SortedGuildStore");
 export const ExpandedGuildFolderStore = findStoreLazy("ExpandedGuildFolderStore");
 const FolderUtils = findByPropsLazy("move", "toggleGuildFolderExpand");
diff --git a/src/plugins/greetStickerPicker/index.tsx b/src/plugins/greetStickerPicker/index.tsx
index 2c8f3379..845c7a1b 100644
--- a/src/plugins/greetStickerPicker/index.tsx
+++ b/src/plugins/greetStickerPicker/index.tsx
@@ -18,9 +18,8 @@
 
 import { definePluginSettings } from "@api/Settings";
 import { Devs } from "@utils/constants";
-import { proxyLazy } from "@utils/lazy";
 import definePlugin, { OptionType } from "@utils/types";
-import { findByProps, findByPropsLazy } from "@webpack";
+import { findByPropsLazy } from "@webpack";
 import { ContextMenu, FluxDispatcher, Menu } from "@webpack/common";
 import { Channel, Message } from "discord-types/general";
 
@@ -51,7 +50,7 @@ const settings = definePluginSettings({
 }>();
 
 const MessageActions = findByPropsLazy("sendGreetMessage");
-const WELCOME_STICKERS = proxyLazy(() => findByProps("WELCOME_STICKERS")?.WELCOME_STICKERS);
+const { WELCOME_STICKERS } = findByPropsLazy("WELCOME_STICKERS");
 
 function greet(channel: Channel, message: Message, stickers: string[]) {
     const options = MessageActions.getSendMessageOptionsForReply({
diff --git a/src/utils/lazy.ts b/src/utils/lazy.ts
index 4bac45bc..1c89d511 100644
--- a/src/utils/lazy.ts
+++ b/src/utils/lazy.ts
@@ -43,7 +43,6 @@ for (const method of [
     "construct",
     "defineProperty",
     "deleteProperty",
-    "get",
     "getOwnPropertyDescriptor",
     "getPrototypeOf",
     "has",
@@ -86,7 +85,11 @@ handler.getOwnPropertyDescriptor = (target, p) => {
  * Note that the example below exists already as an api, see {@link findByPropsLazy}
  * @example const mod = proxyLazy(() => findByProps("blah")); console.log(mod.blah);
  */
-export function proxyLazy<T>(factory: () => T, attempts = 5): T {
+export function proxyLazy<T>(factory: () => T, attempts = 5, isChild = false): T {
+    let isSameTick = true;
+    if (!isChild)
+        setTimeout(() => isSameTick = false, 0);
+
     let tries = 0;
     const proxyDummy = Object.assign(function () { }, {
         [kCACHE]: void 0 as T | undefined,
@@ -100,5 +103,21 @@ export function proxyLazy<T>(factory: () => T, attempts = 5): T {
         }
     });
 
-    return new Proxy(proxyDummy, handler) as any;
+    return new Proxy(proxyDummy, {
+        ...handler,
+        get(target, p, receiver) {
+            // if we're still in the same tick, it means the lazy was immediately used.
+            // thus, we lazy proxy the get access to make things like destructuring work as expected
+            // meow here will also be a lazy
+            // `const { meow } = findByPropsLazy("meow");`
+            if (!isChild && isSameTick)
+                return proxyLazy(
+                    () => Reflect.get(target[kGET](), p, receiver),
+                    attempts,
+                    true
+                );
+
+            return Reflect.get(target[kGET](), p, receiver);
+        }
+    }) as any;
 }
diff --git a/src/webpack/common/stores.ts b/src/webpack/common/stores.ts
index d10b1866..1b00180f 100644
--- a/src/webpack/common/stores.ts
+++ b/src/webpack/common/stores.ts
@@ -16,11 +16,10 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
-import { proxyLazy } from "@utils/lazy";
 import type * as Stores from "discord-types/stores";
 
 // eslint-disable-next-line path-alias/no-relative
-import { filters, findByProps, findByPropsLazy, mapMangledModuleLazy } from "../webpack";
+import { filters, findByPropsLazy, mapMangledModuleLazy } from "../webpack";
 import { waitForStore } from "./internal";
 import * as t from "./types/stores";
 
@@ -78,13 +77,15 @@ export const MaskedLinkStore = mapMangledModuleLazy('"MaskedLinkStore"', {
  *
  * @example const user = useStateFromStores([UserStore], () => UserStore.getCurrentUser(), null, (old, current) => old.id === current.id);
  */
-export const useStateFromStores: <T>(
-    stores: t.FluxStore[],
-    mapper: () => T,
-    idk?: any,
-    isEqual?: (old: T, newer: T) => boolean
-) => T
-    = proxyLazy(() => findByProps("useStateFromStores").useStateFromStores);
+export const { useStateFromStores }: {
+    useStateFromStores: <T>(
+        stores: t.FluxStore[],
+        mapper: () => T,
+        idk?: any,
+        isEqual?: (old: T, newer: T) => boolean
+    ) => T;
+}
+    = findByPropsLazy("useStateFromStores");
 
 waitForStore("DraftStore", s => DraftStore = s);
 waitForStore("UserStore", s => UserStore = s);