commit bb86144f07c1a64ca4e79032afcf8b9c648104d8 · notnite.com/moonlight

+37

packages/core-extensions/src/contextMenu/index.tsx

···

       1
       +
       import { ExtensionWebpackModule, Patch } from "@moonlight-mod/types";

     

       2
       +
       

     

       3
       +
       export const patches: Patch[] = [

     

       4
       +
         {

     

       5
       +
           find: "Menu API only allows Items and groups of Items as children.",

     

       6
       +
           replace: [

     

       7
       +
             {

     

       8
       +
               match:

     

       9
       +
                 /(?<=let{navId[^}]+?}=(.),(.)=function .\(.\){.+(?=,.=function))/,

     

       10
       +
               replacement: (_, props, items) =>

     

       11
       +
                 `,__contextMenu=!${props}.__contextMenu_evilMenu&&require("contextMenu_contextMenu")._patchMenu(${props}, ${items})`

     

       12
       +
             }

     

       13
       +
           ]

     

       14
       +
         },

     

       15
       +
         {

     

       16
       +
           find: ".getContextMenu(",

     

       17
       +
           replace: [

     

       18
       +
             {

     

       19
       +
               match: /(?<=let\{[^}]+?\}=.;return ).\({[^}]+?}\)/,

     

       20
       +
               replacement: (render) =>

     

       21
       +
                 `require("contextMenu_contextMenu")._saveProps(${render})`

     

       22
       +
             }

     

       23
       +
           ]

     

       24
       +
         }

     

       25
       +
       ];

     

       26
       +
       

     

       27
       +
       export const webpackModules: Record<string, ExtensionWebpackModule> = {

     

       28
       +
         contextMenu: {

     

       29
       +
           dependencies: [{ ext: "spacepack", id: "spacepack" }, "MenuGroup:"]

     

       30
       +
         },

     

       31
       +
         evilMenu: {

     

       32
       +
           dependencies: [

     

       33
       +
             { ext: "spacepack", id: "spacepack" },

     

       34
       +
             "Menu API only allows Items and groups of Items as children."

     

       35
       +
           ]

     

       36
       +
         }

     

       37
       +
       };

packages/core-extensions/src/contextMenu/manifest.json

···

       1
       +
       {

     

       2
       +
         "id": "contextMenu",

     

       3
       +
         "meta": {

     

       4
       +
           "name": "Context Menu",

     

       5
       +
           "tagline": "A library for patching and creating context menus",

     

       6
       +
           "authors": ["redstonekasi"],

     

       7
       +
           "tags": ["library"]

     

       8
       +
         }

     

       9
       +
       }

+66

packages/core-extensions/src/contextMenu/webpackModules/contextMenu.ts

···

       1
       +
       import {

     

       2
       +
         InternalItem,

     

       3
       +
         MenuElement,

     

       4
       +
         MenuProps

     

       5
       +
       } from "@moonlight-mod/types/coreExtensions/contextMenu";

     

       6
       +
       import spacepack from "@moonlight-mod/wp/spacepack_spacepack";

     

       7
       +
       import parser from "@moonlight-mod/wp/contextMenu_evilMenu";

     

       8
       +
       

     

       9
       +
       type Patch = {

     

       10
       +
         navId: string;

     

       11
       +
         item: (

     

       12
       +
           props: any

     

       13
       +
         ) =>

     

       14
       +
           | React.ReactComponentElement<MenuElement>

     

       15
       +
           | React.ReactComponentElement<MenuElement>[];

     

       16
       +
         anchorId: string;

     

       17
       +
         before: boolean;

     

       18
       +
       };

     

       19
       +
       

     

       20
       +
       export function addItem<T>(

     

       21
       +
         navId: string,

     

       22
       +
         item: (

     

       23
       +
           props: T

     

       24
       +
         ) =>

     

       25
       +
           | React.ReactComponentElement<MenuElement>

     

       26
       +
           | React.ReactComponentElement<MenuElement>[],

     

       27
       +
         anchorId: string,

     

       28
       +
         before = false

     

       29
       +
       ) {

     

       30
       +
         patches.push({ navId, item, anchorId, before });

     

       31
       +
       }

     

       32
       +
       

     

       33
       +
       export const patches: Patch[] = [];

     

       34
       +
       function _patchMenu(props: MenuProps, items: InternalItem[]) {

     

       35
       +
         const matches = patches.filter((p) => p.navId === props.navId);

     

       36
       +
         if (!matches.length) return;

     

       37
       +
       

     

       38
       +
         for (const patch of matches) {

     

       39
       +
           const idx = items.findIndex((i) => i.key === patch.anchorId);

     

       40
       +
           if (idx === -1) continue;

     

       41
       +
           items.splice(idx + 1 - +patch.before, 0, ...parser(patch.item(menuProps)));

     

       42
       +
         }

     

       43
       +
       }

     

       44
       +
       

     

       45
       +
       let menuProps: any;

     

       46
       +
       function _saveProps(el: any) {

     

       47
       +
         menuProps = el.props;

     

       48
       +
       

     

       49
       +
         const original = el.props.config.onClose;

     

       50
       +
         el.props.config.onClose = function (...args: any[]) {

     

       51
       +
           menuProps = undefined;

     

       52
       +
           return original?.apply(this, args);

     

       53
       +
         };

     

       54
       +
       

     

       55
       +
         return el;

     

       56
       +
       }

     

       57
       +
       

     

       58
       +
       const MenuElements = spacepack.findByCode("return null", "MenuGroup:")[0]

     

       59
       +
         .exports;

     

       60
       +
       

     

       61
       +
       module.exports = {

     

       62
       +
         ...MenuElements,

     

       63
       +
         addItem,

     

       64
       +
         _patchMenu,

     

       65
       +
         _saveProps

     

       66
       +
       };

+24

packages/core-extensions/src/contextMenu/webpackModules/evilMenu.ts

···

       1
       +
       import spacepack from "@moonlight-mod/wp/spacepack_spacepack";

     

       2
       +
       

     

       3
       +
       let code =

     

       4
       +
         spacepack.require.m[

     

       5
       +
           spacepack.findByCode(

     

       6
       +
             "Menu API only allows Items and groups of Items as children."

     

       7
       +
           )[0].id

     

       8
       +
         ].toString();

     

       9
       +
       code = code.replace(/,.=(?=function .\(.\){.+?,.=function)/, ";return ");

     

       10
       +
       code = code.replace(/,(?=__contextMenu)/, ";let ");

     

       11
       +
       const mod = new Function(

     

       12
       +
         "module",

     

       13
       +
         "exports",

     

       14
       +
         "require",

     

       15
       +
         `(${code}).apply(this, arguments)`

     

       16
       +
       );

     

       17
       +
       const exp: any = {};

     

       18
       +
       mod({}, exp, require);

     

       19
       +
       module.exports = (el: any) => {

     

       20
       +
         return exp.Menu({

     

       21
       +
           children: el,

     

       22
       +
           __contextMenu_evilMenu: true

     

       23
       +
         });

     

       24
       +
       };

packages/types/src/coreExtensions.ts

···

       77
        
       export type CommonFluxDispatcher = Dispatcher<any>;

     

       78
        
       

     

       79
        
       export * as Markdown from "./coreExtensions/markdown";

     

       0

···

       77
        
       export type CommonFluxDispatcher = Dispatcher<any>;

     

       78
        
       

     

       79
        
       export * as Markdown from "./coreExtensions/markdown";

     

       80
       +
       export * as ContextMenu from "./coreExtensions/contextMenu";

+151

packages/types/src/coreExtensions/contextMenu.ts

···

       1
       +
       /* eslint-disable prettier/prettier */

     

       2
       +
       

     

       3
       +
       // TODO: Deduplicate common props

     

       4
       +
       

     

       5
       +
       export type Menu = React.FunctionComponent<{

     

       6
       +
         navId: string;

     

       7
       +
         variant?: string;

     

       8
       +
         hideScrollbar?: boolean;

     

       9
       +
         className?: string;

     

       10
       +
         children: React.ReactComponentElement<MenuElement>[];

     

       11
       +
         onClose?: () => void;

     

       12
       +
         onSelect?: () => void;

     

       13
       +
       }>;

     

       14
       +
       export type MenuProps = React.ComponentProps<Menu>;

     

       15
       +
       

     

       16
       +
       export type MenuElement =

     

       17
       +
         | MenuSeparator

     

       18
       +
         | MenuGroup

     

       19
       +
         | MenuItem

     

       20
       +
         | MenuCheckboxItem

     

       21
       +
         | MenuRadioItem

     

       22
       +
         | MenuControlItem;

     

       23
       +
       

     

       24
       +
       export type MenuSeparator = React.FunctionComponent;

     

       25
       +
       export type MenuGroup = React.FunctionComponent<{

     

       26
       +
         label?: string;

     

       27
       +
         className?: string;

     

       28
       +
         color?: string;

     

       29
       +
         children: React.ReactComponentElement<MenuElement>[];

     

       30
       +
       }>;

     

       31
       +
       export type MenuItem = React.FunctionComponent<{

     

       32
       +
         id: any;

     

       33
       +
         dontCloseOnActionIfHoldingShiftKey?: boolean;

     

       34
       +
       } & ({

     

       35
       +
         label: string;

     

       36
       +
         subtext?: string;

     

       37
       +
         color?: string;

     

       38
       +
         hint?: string;

     

       39
       +
         disabled?: boolean;

     

       40
       +
         icon?: any;

     

       41
       +
         showIconFirst?: boolean;

     

       42
       +
         imageUrl?: string;

     

       43
       +
       

     

       44
       +
         className?: string;

     

       45
       +
         focusedClassName?: string;

     

       46
       +
         subMenuIconClassName?: string;

     

       47
       +
       

     

       48
       +
         action?: () => void;

     

       49
       +
         onFocus?: () => void;

     

       50
       +
       

     

       51
       +
         iconProps?: any;

     

       52
       +
         sparkle?: any;

     

       53
       +
       

     

       54
       +
         children?: React.ReactComponentElement<MenuElement>[];

     

       55
       +
         onChildrenScroll?: any;

     

       56
       +
         childRowHeight?: any;

     

       57
       +
         listClassName?: string;

     

       58
       +
         subMenuClassName?: string;

     

       59
       +
       } | {

     

       60
       +
         color?: string;

     

       61
       +
         disabled?: boolean;

     

       62
       +
         keepItemStyles?: boolean;

     

       63
       +
       

     

       64
       +
         action?: () => void;

     

       65
       +
       

     

       66
       +
         render: any;

     

       67
       +
         navigable?: boolean;

     

       68
       +
       })>;

     

       69
       +
       export type MenuCheckboxItem = React.FunctionComponent<{

     

       70
       +
         id: any;

     

       71
       +
         label: string;

     

       72
       +
         subtext?: string;

     

       73
       +
         color?: string;

     

       74
       +
         className?: string;

     

       75
       +
         focusedClassName?: string;

     

       76
       +
         disabled?: boolean;

     

       77
       +
         checked: boolean;

     

       78
       +
         action?: () => void;

     

       79
       +
       }>;

     

       80
       +
       export type MenuRadioItem = React.FunctionComponent<{

     

       81
       +
         id: any;

     

       82
       +
         label: string;

     

       83
       +
         subtext?: string;

     

       84
       +
         color?: string;

     

       85
       +
         disabled?: boolean;

     

       86
       +
         action?: () => void;

     

       87
       +
       }>;

     

       88
       +
       export type MenuControlItem = React.FunctionComponent<{

     

       89
       +
         id: any;

     

       90
       +
         label: string;

     

       91
       +
         color?: string;

     

       92
       +
         disabled?: boolean;

     

       93
       +
         showDefaultFocus?: boolean;

     

       94
       +
       } & ({

     

       95
       +
         control: any;

     

       96
       +
       } | {

     

       97
       +
         control?: undefined;

     

       98
       +
         interactive?: boolean;

     

       99
       +
         children?: React.ReactComponentElement<MenuElement>[];

     

       100
       +
       })>;

     

       101
       +
       

     

       102
       +
       export type ContextMenu = {

     

       103
       +
         addItem: (

     

       104
       +
           navId: string,

     

       105
       +
           item: (props: any) => React.ReactComponentElement<MenuElement>,

     

       106
       +
           anchorId: string,

     

       107
       +
           before?: boolean

     

       108
       +
         ) => void;

     

       109
       +
       

     

       110
       +
         MenuCheckboxItem: MenuCheckboxItem;

     

       111
       +
         MenuControlItem: MenuControlItem;

     

       112
       +
         MenuGroup: MenuGroup;

     

       113
       +
         MenuItem: MenuItem;

     

       114
       +
         MenuRadioItem: MenuRadioItem;

     

       115
       +
         MenuSeparator: MenuSeparator;

     

       116
       +
       };

     

       117
       +
       

     

       118
       +
       export type InternalItem = {

     

       119
       +
         type: string;

     

       120
       +
         key?: string;

     

       121
       +
       };

     

       122
       +
       

     

       123
       +
       export type InternalSeparator = {

     

       124
       +
         type: "separator";

     

       125
       +
         navigable: false;

     

       126
       +
       }

     

       127
       +
       export type InternalGroupStart = {

     

       128
       +
         type: "groupstart";

     

       129
       +
         length: number;

     

       130
       +
         navigable: false;

     

       131
       +
         props: React.ComponentProps<MenuGroup>;

     

       132
       +
       }

     

       133
       +
       export type InternalGroupEnd = {

     

       134
       +
         type: "groupend";

     

       135
       +
       } & Omit<InternalGroupStart, "type">;

     

       136
       +
       export type InternalCustomItem = {

     

       137
       +
         type: "customitem";

     

       138
       +
         key: any;

     

       139
       +
         navigable?: boolean;

     

       140
       +
         render: any;

     

       141
       +
         props: Extract<React.ComponentProps<MenuItem>, { render: any }>;

     

       142
       +
       } 

     

       143
       +
       export type InternalItem_ = {

     

       144
       +
         type: "item";

     

       145
       +
         key: any;

     

       146
       +
         navigable: true;

     

       147
       +
         label: string;

     

       148
       +
         

     

       149
       +
       }

     

       150
       +
       

     

       151
       +
       export type EvilItemParser = (el: React.ReactComponentElement<MenuElement> | React.ReactComponentElement<MenuElement>[]) => InternalItem[];

packages/types/src/discord/require.ts

···

       6
        
         CommonComponents,

     

       7
        
         CommonFluxDispatcher

     

       8
        
       } from "../coreExtensions";

     

       0
        
       
     

       9
        
       import { Markdown } from "../coreExtensions/markdown";

     

       10
        
       

     

       11
        
       declare function WebpackRequire(id: string): any;

     
···

       27
        
       };

     

       28
        
       

     

       29
        
       declare function WebpackRequire(id: "markdown_markdown"): Markdown;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       30
        
       

     

       31
        
       export default WebpackRequire;

···

       6
        
         CommonComponents,

     

       7
        
         CommonFluxDispatcher

     

       8
        
       } from "../coreExtensions";

     

       9
       +
       import { ContextMenu, EvilItemParser } from "../coreExtensions/contextMenu";

     

       10
        
       import { Markdown } from "../coreExtensions/markdown";

     

       11
        
       

     

       12
        
       declare function WebpackRequire(id: string): any;

     
···

       28
        
       };

     

       29
        
       

     

       30
        
       declare function WebpackRequire(id: "markdown_markdown"): Markdown;

     

       31
       +
       

     

       32
       +
       declare function WebpackRequire(id: "contextMenu_evilMenu"): EvilItemParser;

     

       33
       +
       declare function WebpackRequire(id: "contextMenu_contextMenu"): ContextMenu;

     

       34
        
       

     

       35
        
       export default WebpackRequire;

+12

packages/types/src/import.d.ts

···

       41
        
         const Markdown: CoreExtensions.Markdown.Markdown;

     

       42
        
         export = Markdown;

     

       43
        
       }

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

       41
        
         const Markdown: CoreExtensions.Markdown.Markdown;

     

       42
        
         export = Markdown;

     

       43
        
       }

     

       44
       +
       

     

       45
       +
       declare module "@moonlight-mod/wp/contextMenu_evilMenu" {

     

       46
       +
         import { CoreExtensions } from "@moonlight-mod/types";

     

       47
       +
         const EvilParser: CoreExtensions.ContextMenu.EvilItemParser;

     

       48
       +
         export = EvilParser;

     

       49
       +
       }

     

       50
       +
       

     

       51
       +
       declare module "@moonlight-mod/wp/contextMenu_contextMenu" {

     

       52
       +
         import { CoreExtensions } from "@moonlight-mod/types";

     

       53
       +
         const ContextMenu: CoreExtensions.ContextMenu.ContextMenu;

     

       54
       +
         export = ContextMenu;

     

       55
       +
       }