byPrototype

src/renderer/modules/webpack/filters.ts

@@ -1,13 +1,20 @@
 import { getExportsForProps } from "./get-modules";
 import { sourceStrings } from "./patch-load";
-import type { RawModule } from "../../../types";
+import type { RawModule, byPropsOptions } from "../../../types";
 
 /**
  * Get a module that has all the given properties on one of its exports
  * @param props List of property names
  */
-export const byProps = <P extends PropertyKey = PropertyKey>(...props: P[]) => {
-  return (m: RawModule) => typeof getExportsForProps(m.exports, props) !== "undefined";
+export const byProps = <P extends PropertyKey = PropertyKey>(
+  ...args: [...P[], byPropsOptions] | P[]
+): ((m: RawModule) => boolean) => {
+  if (typeof args.at(-1) === "object" && !Array.isArray(args.at(-1)) && args.at(-1) !== null) {
+    const options = args.pop() as byPropsOptions;
+    return (m: RawModule) =>
+      typeof getExportsForProps(m.exports, args as P[], options) !== "undefined";
+  }
+  return (m: RawModule) => typeof getExportsForProps(m.exports, args as P[]) !== "undefined";
 };
 
 /**

src/renderer/modules/webpack/get-modules.ts

@@ -22,44 +22,66 @@ export function getExports<T>(m: RawModule): T | undefined {
 }
 
 /**
- * Iterates over an object and its top-level children that could have properties
+ * Iterates over an object and its top-level and second-level (if specified) children that could have properties
  * @param m Object (module exports) to iterate over
+ * @param secondLevel Boolean on whether to iterate over second level children in object
  */
-function* iterateModuleExports(m: unknown): IterableIterator<Record<PropertyKey, unknown>> {
+function* iterateModuleExports(
+  m: unknown,
+  secondLevel?: boolean,
+): IterableIterator<Record<PropertyKey, unknown>> {
   // if m is null or not an object/function, then it will obviously not have the props
-  // if if has no props, then it definitely has no children either
-  if (m && (typeof m === "object" || typeof m === "function")) {
-    yield m as Record<PropertyKey, unknown>;
-    for (const key in m) {
-      try {
+  // if it has no props, then it definitely has no children either
+  try {
+    if (m && (typeof m === "object" || typeof m === "function")) {
+      yield m as Record<PropertyKey, unknown>;
+      for (const key in m) {
         // This could throw an error ("illegal invocation") if val === DOMTokenList.prototype
         // and key === "length"
         // There could be other cases too, hence this try-catch instead of a specific exclusion
         const val = (m as Record<PropertyKey, unknown>)[key];
         if (val && (typeof val === "object" || typeof val === "function")) {
           yield val as Record<PropertyKey, unknown>;
+          if (secondLevel && typeof val === "object") {
+            for (const subKey in val) {
+              const subVal = (val as Record<PropertyKey, unknown>)[subKey];
+              if (subVal && (typeof val === "object" || typeof val === "function")) {
+                yield subVal as Record<PropertyKey, unknown>;
+                continue;
+              }
+            }
+          }
         }
-      } catch {
-        // ignore this export
       }
     }
+  } catch {
+    // ignore this export
   }
 }
 
 /**
  * Find an object in a module that has all the given properties. You will usually not need this function.
  * @param m Module to search
  * @param props Array of prop names
+ * @param options object containing option on whether to look in prototype or not
  * @returns Object that contains all the given properties (and any others), or undefined if not found
  */
 export function getExportsForProps<T, P extends PropertyKey = keyof T>(
   m: unknown,
   props: P[],
+  options?: { byPrototype?: boolean },
 ): T | undefined {
   // Loop over the module and its exports at the top level
   // Return the first thing that has all the indicated props
-  for (const exported of iterateModuleExports(m)) {
-    if (props.every((p) => p in (exported as Record<P, unknown>))) {
+  // Checks only in prototypes if specified, usually to look for functions
+  for (const exported of iterateModuleExports(m, options?.byPrototype)) {
+    if (
+      props.every((p) =>
+        options?.byPrototype
+          ? (exported?.prototype as Record<P, unknown>)?.[p]
+          : p in (exported as Record<P, unknown>),
+      )
+    ) {
       return exported as T;
     }
   }

src/renderer/modules/webpack/helpers.ts

@@ -1,4 +1,4 @@
-import type { GetModuleOptions, RawModule, WaitForOptions } from "src/types";
+import type { GetModuleOptions, RawModule, WaitForOptions, byPropsOptions } from "src/types";
 import { getExportsForProps, getModule } from "./get-modules";
 import * as filters from "./filters";
 import Flux, { Store } from "../common/flux";
@@ -60,39 +60,39 @@ export function getBySource<T>(
 
 export function getByProps<T, P extends PropertyKey = keyof T>(
   props: P[],
-  options?: { all?: false; raw?: false },
+  options?: { byPrototype?: boolean; all?: false; raw?: false },
 ): T | undefined;
 export function getByProps<T, P extends PropertyKey = keyof T>(
   props: P[],
-  options: { all: true; raw?: false },
+  options: { byPrototype?: boolean; all: true; raw?: false },
 ): T[];
 export function getByProps<T, P extends PropertyKey = keyof T>(
   props: P[],
-  options: { all?: false; raw: true },
+  options: { byPrototype?: boolean; all?: false; raw: true },
 ): RawModule<T> | undefined;
 export function getByProps<T, P extends PropertyKey = keyof T>(
   props: P[],
-  options: { all: true; raw: true },
+  options: { byPrototype?: boolean; all: true; raw: true },
 ): Array<RawModule<T>>;
 export function getByProps<T, P extends PropertyKey = keyof T>(
   props: P[],
-  options?: { all: true; raw?: boolean },
+  options?: { byPrototype?: boolean; all: true; raw?: boolean },
 ): T[] | Array<RawModule<T>>;
 export function getByProps<T, P extends PropertyKey = keyof T>(
   props: P[],
-  options: { all?: false; raw?: boolean },
+  options: { byPrototype?: boolean; all?: false; raw?: boolean },
 ): T | RawModule<T> | undefined;
 export function getByProps<T, P extends PropertyKey = keyof T>(
   props: P[],
-  options: { all?: boolean; raw: true },
+  options: { byPrototype?: boolean; all?: boolean; raw: true },
 ): RawModule<T> | Array<RawModule<T>> | undefined;
 export function getByProps<T, P extends PropertyKey = keyof T>(
   props: P,
-  options: { all?: boolean; raw?: false },
+  options: { byPrototype?: boolean; all?: boolean; raw?: false },
 ): T | T[] | undefined;
 export function getByProps<T, P extends PropertyKey = keyof T>(
   props: P[],
-  options?: { all?: boolean; raw?: boolean },
+  options?: { byPrototype?: boolean; all?: boolean; raw?: boolean },
 ): T | T[] | RawModule<T> | Array<RawModule<T>> | undefined;
 export function getByProps<T, P extends PropertyKey[] = Array<keyof T>>(...props: P): T | undefined;
 
@@ -103,41 +103,42 @@ export function getByProps<T, P extends PropertyKey[] = Array<keyof T>>(...props
  * @see {@link getModule}
  */
 export function getByProps<T, P extends PropertyKey = keyof T>(
-  ...args: [P[], GetModuleOptions] | P[]
+  ...args: [P[], GetModuleOptions & byPropsOptions] | P[]
 ): T | T[] | RawModule<T> | Array<RawModule<T>> | undefined {
   const props = (typeof args[0] === "string" ? args : args[0]) as P[];
   const raw = typeof args[0] === "string" ? false : (args[1] as GetModuleOptions)?.raw;
-
+  const byPrototype =
+    typeof args[0] === "string" ? false : (args[1] as byPropsOptions)?.byPrototype;
   const result =
     typeof args.at(-1) === "object"
-      ? getModule<T>(filters.byProps(...props), args.at(-1) as GetModuleOptions)
-      : getModule<T>(filters.byProps(...props));
+      ? getModule<T>(filters.byProps(...props, { byPrototype }), args.at(-1) as GetModuleOptions)
+      : getModule<T>(filters.byProps(...props, { byPrototype }));
 
   if (raw || typeof result === "undefined") {
     return result as RawModule<T> | undefined;
   }
 
   if (result instanceof Array) {
     // @ts-expect-error TypeScript isn't going to infer types based on the raw variable, so this is fine
-    return result.map((m) => getExportsForProps(m, props));
+    return result.map((m) => getExportsForProps(m, props, { byPrototype }));
   }
 
-  return getExportsForProps<T, P>(result, props);
+  return getExportsForProps<T, P>(result, props, { byPrototype });
 }
 
 // Wait for props
 
 export function waitForProps<T, P extends PropertyKey = keyof T>(
   props: P[],
-  options: WaitForOptions & { raw?: false },
+  options: WaitForOptions & byPropsOptions & { raw?: false },
 ): Promise<T>;
 export function waitForProps<T, P extends PropertyKey = keyof T>(
   props: P[],
-  options: WaitForOptions & { raw: true },
+  options: WaitForOptions & byPropsOptions & { raw: true },
 ): Promise<RawModule<T>>;
 export function waitForProps<T, P extends PropertyKey = keyof T>(
   props: P[],
-  options?: WaitForOptions,
+  options?: WaitForOptions & byPropsOptions,
 ): Promise<T | RawModule<T>>;
 export function waitForProps<T, P extends PropertyKey = keyof T>(...props: P[]): Promise<T>;
 
@@ -148,21 +149,22 @@ export function waitForProps<T, P extends PropertyKey = keyof T>(...props: P[]):
  * @see {@link waitForModule}
  */
 export async function waitForProps<T, P extends PropertyKey = keyof T>(
-  ...args: [P[], WaitForOptions] | P[]
+  ...args: [P[], WaitForOptions & byPropsOptions] | P[]
 ): Promise<T | RawModule<T>> {
   const props = (typeof args[0] === "string" ? args : args[0]) as P[];
   const raw = typeof args[0] === "string" ? false : (args[1] as WaitForOptions)?.raw;
-
+  const byPrototype =
+    typeof args[0] === "string" ? false : (args[1] as byPropsOptions)?.byPrototype;
   const result = await (typeof args.at(-1) === "object"
-    ? waitForModule<T>(filters.byProps(...props), args.at(-1) as WaitForOptions)
-    : waitForModule<T>(filters.byProps(...props)));
+    ? waitForModule<T>(filters.byProps(...props, { byPrototype }), args.at(-1) as WaitForOptions)
+    : waitForModule<T>(filters.byProps(...props, { byPrototype })));
 
   if (raw) {
     return result as RawModule<T>;
   }
 
   // We know this will always exist since filters.byProps will always return a module that has the props
-  return getExportsForProps<T, P>(result as T, props)!;
+  return getExportsForProps<T, P>(result as T, props, { byPrototype })!;
 }
 
 // Get by value
@@ -246,7 +248,7 @@ export function getByValue<T>(
   return getModule<T>(filters.byValue(match), options);
 }
 
-export function getByStoreName<T extends Store>(name: string): T | undefined {
+export function getByStoreName<T>(name: string): (T & Store) | undefined {
   const stores = Flux.Store.getAll();
-  return stores.find((store) => store.getName() === name) as T | undefined;
+  return stores.find((store) => store.getName() === name) as (T & Store) | undefined;
 }

src/types/webpack.ts

@@ -73,3 +73,8 @@ export interface WaitForOptions {
   /** If nothing is found after this delay (ms), stop and throw an error. */
   timeout?: number;
 }
+
+export interface byPropsOptions {
+  /** searches inside the prototype if getting by props */
+  byPrototype: boolean;
+}