commit 6e3b8640542cd1073d84c7c1379f3d3a24c59563 · notnite.com/moonlight

+3 -4

CHANGELOG.md

···

       1
       1
       -
       - Add `spacepack.filterReal`

     

       2
       2
       -
       - More dependency resolver stages

     

       3
       3
       -
       - Injector now supports "other patch methods"

     

       4
       4
       -
       - OpenAsar fixes

     

       1
       1
       +
       - Added multiline string input for extension settings

     

       2
       2
       +
       - Fixed conflicting extensions in Moonbase

     

       3
       3
       +
       - Fixes for latest Discord

+125 -621

LICENSE

···

       1
       1
       -
                           GNU AFFERO GENERAL PUBLIC LICENSE

     

       2
       2
       -
                              Version 3, 19 November 2007

     

       1
       1
       +
                          GNU LESSER GENERAL PUBLIC LICENSE

     

       2
       2
       +
                              Version 3, 29 June 2007

     

       3
       3
        
       

     

       4
       4
        
        Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>

     

       5
       5
        
        Everyone is permitted to copy and distribute verbatim copies

     

       6
       6
        
        of this license document, but changing it is not allowed.

     

       7
       7
        
       

     

       8
       8
       -
                                   Preamble

     

       9
       8
        
       

     

       10
       10
       -
         The GNU Affero General Public License is a free, copyleft license for

     

       11
       11
       -
       software and other kinds of works, specifically designed to ensure

     

       12
       12
       -
       cooperation with the community in the case of network server software.

     

       13
       13
       -
       

     

       14
       14
       -
         The licenses for most software and other practical works are designed

     

       15
       15
       -
       to take away your freedom to share and change the works.  By contrast,

     

       16
       16
       -
       our General Public Licenses are intended to guarantee your freedom to

     

       17
       17
       -
       share and change all versions of a program--to make sure it remains free

     

       18
       18
       -
       software for all its users.

     

       19
       19
       -
       

     

       20
       20
       -
         When we speak of free software, we are referring to freedom, not

     

       21
       21
       -
       price.  Our General Public Licenses are designed to make sure that you

     

       22
       22
       -
       have the freedom to distribute copies of free software (and charge for

     

       23
       23
       -
       them if you wish), that you receive source code or can get it if you

     

       24
       24
       -
       want it, that you can change the software or use pieces of it in new

     

       25
       25
       -
       free programs, and that you know you can do these things.

     

       26
       26
       -
       

     

       27
       27
       -
         Developers that use our General Public Licenses protect your rights

     

       28
       28
       -
       with two steps: (1) assert copyright on the software, and (2) offer

     

       29
       29
       -
       you this License which gives you legal permission to copy, distribute

     

       30
       30
       -
       and/or modify the software.

     

       31
       31
       -
       

     

       32
       32
       -
         A secondary benefit of defending all users' freedom is that

     

       33
       33
       -
       improvements made in alternate versions of the program, if they

     

       34
       34
       -
       receive widespread use, become available for other developers to

     

       35
       35
       -
       incorporate.  Many developers of free software are heartened and

     

       36
       36
       -
       encouraged by the resulting cooperation.  However, in the case of

     

       37
       37
       -
       software used on network servers, this result may fail to come about.

     

       38
       38
       -
       The GNU General Public License permits making a modified version and

     

       39
       39
       -
       letting the public access it on a server without ever releasing its

     

       40
       40
       -
       source code to the public.

     

       41
       41
       -
       

     

       42
       42
       -
         The GNU Affero General Public License is designed specifically to

     

       43
       43
       -
       ensure that, in such cases, the modified source code becomes available

     

       44
       44
       -
       to the community.  It requires the operator of a network server to

     

       45
       45
       -
       provide the source code of the modified version running there to the

     

       46
       46
       -
       users of that server.  Therefore, public use of a modified version, on

     

       47
       47
       -
       a publicly accessible server, gives the public access to the source

     

       48
       48
       -
       code of the modified version.

     

       49
       49
       -
       

     

       50
       50
       -
         An older license, called the Affero General Public License and

     

       51
       51
       -
       published by Affero, was designed to accomplish similar goals.  This is

     

       52
       52
       -
       a different license, not a version of the Affero GPL, but Affero has

     

       53
       53
       -
       released a new version of the Affero GPL which permits relicensing under

     

       54
       54
       -
       this license.

     

       55
       55
       -
       

     

       56
       56
       -
         The precise terms and conditions for copying, distribution and

     

       57
       57
       -
       modification follow.

     

       58
       58
       -
       

     

       59
       59
       -
                              TERMS AND CONDITIONS

     

       60
       60
       -
       

     

       61
       61
       -
         0. Definitions.

     

       62
       62
       -
       

     

       63
       63
       -
         "This License" refers to version 3 of the GNU Affero General Public License.

     

       64
       64
       -
       

     

       65
       65
       -
         "Copyright" also means copyright-like laws that apply to other kinds of

     

       66
       66
       -
       works, such as semiconductor masks.

     

       67
       67
       -
       

     

       68
       68
       -
         "The Program" refers to any copyrightable work licensed under this

     

       69
       69
       -
       License.  Each licensee is addressed as "you".  "Licensees" and

     

       70
       70
       -
       "recipients" may be individuals or organizations.

     

       71
       71
       -
       

     

       72
       72
       -
         To "modify" a work means to copy from or adapt all or part of the work

     

       73
       73
       -
       in a fashion requiring copyright permission, other than the making of an

     

       74
       74
       -
       exact copy.  The resulting work is called a "modified version" of the

     

       75
       75
       -
       earlier work or a work "based on" the earlier work.

     

       76
       76
       -
       

     

       77
       77
       -
         A "covered work" means either the unmodified Program or a work based

     

       78
       78
       -
       on the Program.

     

       79
       79
       -
       

     

       80
       80
       -
         To "propagate" a work means to do anything with it that, without

     

       81
       81
       -
       permission, would make you directly or secondarily liable for

     

       82
       82
       -
       infringement under applicable copyright law, except executing it on a

     

       83
       83
       -
       computer or modifying a private copy.  Propagation includes copying,

     

       84
       84
       -
       distribution (with or without modification), making available to the

     

       85
       85
       -
       public, and in some countries other activities as well.

     

       86
       86
       -
       

     

       87
       87
       -
         To "convey" a work means any kind of propagation that enables other

     

       88
       88
       -
       parties to make or receive copies.  Mere interaction with a user through

     

       89
       89
       -
       a computer network, with no transfer of a copy, is not conveying.

     

       90
       90
       -
       

     

       91
       91
       -
         An interactive user interface displays "Appropriate Legal Notices"

     

       92
       92
       -
       to the extent that it includes a convenient and prominently visible

     

       93
       93
       -
       feature that (1) displays an appropriate copyright notice, and (2)

     

       94
       94
       -
       tells the user that there is no warranty for the work (except to the

     

       95
       95
       -
       extent that warranties are provided), that licensees may convey the

     

       96
       96
       -
       work under this License, and how to view a copy of this License.  If

     

       97
       97
       -
       the interface presents a list of user commands or options, such as a

     

       98
       98
       -
       menu, a prominent item in the list meets this criterion.

     

       99
       99
       -
       

     

       100
       100
       -
         1. Source Code.

     

       101
       101
       -
       

     

       102
       102
       -
         The "source code" for a work means the preferred form of the work

     

       103
       103
       -
       for making modifications to it.  "Object code" means any non-source

     

       104
       104
       -
       form of a work.

     

       105
       105
       -
       

     

       106
       106
       -
         A "Standard Interface" means an interface that either is an official

     

       107
       107
       -
       standard defined by a recognized standards body, or, in the case of

     

       108
       108
       -
       interfaces specified for a particular programming language, one that

     

       109
       109
       -
       is widely used among developers working in that language.

     

       110
       110
       -
       

     

       111
       111
       -
         The "System Libraries" of an executable work include anything, other

     

       112
       112
       -
       than the work as a whole, that (a) is included in the normal form of

     

       113
       113
       -
       packaging a Major Component, but which is not part of that Major

     

       114
       114
       -
       Component, and (b) serves only to enable use of the work with that

     

       115
       115
       -
       Major Component, or to implement a Standard Interface for which an

     

       116
       116
       -
       implementation is available to the public in source code form.  A

     

       117
       117
       -
       "Major Component", in this context, means a major essential component

     

       118
       118
       -
       (kernel, window system, and so on) of the specific operating system

     

       119
       119
       -
       (if any) on which the executable work runs, or a compiler used to

     

       120
       120
       -
       produce the work, or an object code interpreter used to run it.

     

       121
       121
       -
       

     

       122
       122
       -
         The "Corresponding Source" for a work in object code form means all

     

       123
       123
       -
       the source code needed to generate, install, and (for an executable

     

       124
       124
       -
       work) run the object code and to modify the work, including scripts to

     

       125
       125
       -
       control those activities.  However, it does not include the work's

     

       126
       126
       -
       System Libraries, or general-purpose tools or generally available free

     

       127
       127
       -
       programs which are used unmodified in performing those activities but

     

       128
       128
       -
       which are not part of the work.  For example, Corresponding Source

     

       129
       129
       -
       includes interface definition files associated with source files for

     

       130
       130
       -
       the work, and the source code for shared libraries and dynamically

     

       131
       131
       -
       linked subprograms that the work is specifically designed to require,

     

       132
       132
       -
       such as by intimate data communication or control flow between those

     

       133
       133
       -
       subprograms and other parts of the work.

     

       134
       134
       -
       

     

       135
       135
       -
         The Corresponding Source need not include anything that users

     

       136
       136
       -
       can regenerate automatically from other parts of the Corresponding

     

       137
       137
       -
       Source.

     

       138
       138
       -
       

     

       139
       139
       -
         The Corresponding Source for a work in source code form is that

     

       140
       140
       -
       same work.

     

       141
       141
       -
       

     

       142
       142
       -
         2. Basic Permissions.

     

       143
       143
       -
       

     

       144
       144
       -
         All rights granted under this License are granted for the term of

     

       145
       145
       -
       copyright on the Program, and are irrevocable provided the stated

     

       146
       146
       -
       conditions are met.  This License explicitly affirms your unlimited

     

       147
       147
       -
       permission to run the unmodified Program.  The output from running a

     

       148
       148
       -
       covered work is covered by this License only if the output, given its

     

       149
       149
       -
       content, constitutes a covered work.  This License acknowledges your

     

       150
       150
       -
       rights of fair use or other equivalent, as provided by copyright law.

     

       151
       151
       -
       

     

       152
       152
       -
         You may make, run and propagate covered works that you do not

     

       153
       153
       -
       convey, without conditions so long as your license otherwise remains

     

       154
       154
       -
       in force.  You may convey covered works to others for the sole purpose

     

       155
       155
       -
       of having them make modifications exclusively for you, or provide you

     

       156
       156
       -
       with facilities for running those works, provided that you comply with

     

       157
       157
       -
       the terms of this License in conveying all material for which you do

     

       158
       158
       -
       not control copyright.  Those thus making or running the covered works

     

       159
       159
       -
       for you must do so exclusively on your behalf, under your direction

     

       160
       160
       -
       and control, on terms that prohibit them from making any copies of

     

       161
       161
       -
       your copyrighted material outside their relationship with you.

     

       162
       162
       -
       

     

       163
       163
       -
         Conveying under any other circumstances is permitted solely under

     

       164
       164
       -
       the conditions stated below.  Sublicensing is not allowed; section 10

     

       165
       165
       -
       makes it unnecessary.

     

       166
       166
       -
       

     

       167
       167
       -
         3. Protecting Users' Legal Rights From Anti-Circumvention Law.

     

       168
       168
       -
       

     

       169
       169
       -
         No covered work shall be deemed part of an effective technological

     

       170
       170
       -
       measure under any applicable law fulfilling obligations under article

     

       171
       171
       -
       11 of the WIPO copyright treaty adopted on 20 December 1996, or

     

       172
       172
       -
       similar laws prohibiting or restricting circumvention of such

     

       173
       173
       -
       measures.

     

       174
       174
       -
       

     

       175
       175
       -
         When you convey a covered work, you waive any legal power to forbid

     

       176
       176
       -
       circumvention of technological measures to the extent such circumvention

     

       177
       177
       -
       is effected by exercising rights under this License with respect to

     

       178
       178
       -
       the covered work, and you disclaim any intention to limit operation or

     

       179
       179
       -
       modification of the work as a means of enforcing, against the work's

     

       180
       180
       -
       users, your or third parties' legal rights to forbid circumvention of

     

       181
       181
       -
       technological measures.

     

       182
       182
       -
       

     

       183
       183
       -
         4. Conveying Verbatim Copies.

     

       184
       184
       -
       

     

       185
       185
       -
         You may convey verbatim copies of the Program's source code as you

     

       186
       186
       -
       receive it, in any medium, provided that you conspicuously and

     

       187
       187
       -
       appropriately publish on each copy an appropriate copyright notice;

     

       188
       188
       -
       keep intact all notices stating that this License and any

     

       189
       189
       -
       non-permissive terms added in accord with section 7 apply to the code;

     

       190
       190
       -
       keep intact all notices of the absence of any warranty; and give all

     

       191
       191
       -
       recipients a copy of this License along with the Program.

     

       192
       192
       -
       

     

       193
       193
       -
         You may charge any price or no price for each copy that you convey,

     

       194
       194
       -
       and you may offer support or warranty protection for a fee.

     

       195
       195
       -
       

     

       196
       196
       -
         5. Conveying Modified Source Versions.

     

       197
       197
       -
       

     

       198
       198
       -
         You may convey a work based on the Program, or the modifications to

     

       199
       199
       -
       produce it from the Program, in the form of source code under the

     

       200
       200
       -
       terms of section 4, provided that you also meet all of these conditions:

     

       201
       201
       -
       

     

       202
       202
       -
           a) The work must carry prominent notices stating that you modified

     

       203
       203
       -
           it, and giving a relevant date.

     

       204
       204
       -
       

     

       205
       205
       -
           b) The work must carry prominent notices stating that it is

     

       206
       206
       -
           released under this License and any conditions added under section

     

       207
       207
       -
           7.  This requirement modifies the requirement in section 4 to

     

       208
       208
       -
           "keep intact all notices".

     

       209
       209
       -
       

     

       210
       210
       -
           c) You must license the entire work, as a whole, under this

     

       211
       211
       -
           License to anyone who comes into possession of a copy.  This

     

       212
       212
       -
           License will therefore apply, along with any applicable section 7

     

       213
       213
       -
           additional terms, to the whole of the work, and all its parts,

     

       214
       214
       -
           regardless of how they are packaged.  This License gives no

     

       215
       215
       -
           permission to license the work in any other way, but it does not

     

       216
       216
       -
           invalidate such permission if you have separately received it.

     

       217
       217
       -
       

     

       218
       218
       -
           d) If the work has interactive user interfaces, each must display

     

       219
       219
       -
           Appropriate Legal Notices; however, if the Program has interactive

     

       220
       220
       -
           interfaces that do not display Appropriate Legal Notices, your

     

       221
       221
       -
           work need not make them do so.

     

       222
       222
       -
       

     

       223
       223
       -
         A compilation of a covered work with other separate and independent

     

       224
       224
       -
       works, which are not by their nature extensions of the covered work,

     

       225
       225
       -
       and which are not combined with it such as to form a larger program,

     

       226
       226
       -
       in or on a volume of a storage or distribution medium, is called an

     

       227
       227
       -
       "aggregate" if the compilation and its resulting copyright are not

     

       228
       228
       -
       used to limit the access or legal rights of the compilation's users

     

       229
       229
       -
       beyond what the individual works permit.  Inclusion of a covered work

     

       230
       230
       -
       in an aggregate does not cause this License to apply to the other

     

       231
       231
       -
       parts of the aggregate.

     

       232
       232
       -
       

     

       233
       233
       -
         6. Conveying Non-Source Forms.

     

       234
       234
       -
       

     

       235
       235
       -
         You may convey a covered work in object code form under the terms

     

       236
       236
       -
       of sections 4 and 5, provided that you also convey the

     

       237
       237
       -
       machine-readable Corresponding Source under the terms of this License,

     

       238
       238
       -
       in one of these ways:

     

       239
       239
       -
       

     

       240
       240
       -
           a) Convey the object code in, or embodied in, a physical product

     

       241
       241
       -
           (including a physical distribution medium), accompanied by the

     

       242
       242
       -
           Corresponding Source fixed on a durable physical medium

     

       243
       243
       -
           customarily used for software interchange.

     

       244
       244
       -
       

     

       245
       245
       -
           b) Convey the object code in, or embodied in, a physical product

     

       246
       246
       -
           (including a physical distribution medium), accompanied by a

     

       247
       247
       -
           written offer, valid for at least three years and valid for as

     

       248
       248
       -
           long as you offer spare parts or customer support for that product

     

       249
       249
       -
           model, to give anyone who possesses the object code either (1) a

     

       250
       250
       -
           copy of the Corresponding Source for all the software in the

     

       251
       251
       -
           product that is covered by this License, on a durable physical

     

       252
       252
       -
           medium customarily used for software interchange, for a price no

     

       253
       253
       -
           more than your reasonable cost of physically performing this

     

       254
       254
       -
           conveying of source, or (2) access to copy the

     

       255
       255
       -
           Corresponding Source from a network server at no charge.

     

       256
       256
       -
       

     

       257
       257
       -
           c) Convey individual copies of the object code with a copy of the

     

       258
       258
       -
           written offer to provide the Corresponding Source.  This

     

       259
       259
       -
           alternative is allowed only occasionally and noncommercially, and

     

       260
       260
       -
           only if you received the object code with such an offer, in accord

     

       261
       261
       -
           with subsection 6b.

     

       262
       262
       -
       

     

       263
       263
       -
           d) Convey the object code by offering access from a designated

     

       264
       264
       -
           place (gratis or for a charge), and offer equivalent access to the

     

       265
       265
       -
           Corresponding Source in the same way through the same place at no

     

       266
       266
       -
           further charge.  You need not require recipients to copy the

     

       267
       267
       -
           Corresponding Source along with the object code.  If the place to

     

       268
       268
       -
           copy the object code is a network server, the Corresponding Source

     

       269
       269
       -
           may be on a different server (operated by you or a third party)

     

       270
       270
       -
           that supports equivalent copying facilities, provided you maintain

     

       271
       271
       -
           clear directions next to the object code saying where to find the

     

       272
       272
       -
           Corresponding Source.  Regardless of what server hosts the

     

       273
       273
       -
           Corresponding Source, you remain obligated to ensure that it is

     

       274
       274
       -
           available for as long as needed to satisfy these requirements.

     

       275
       275
       -
       

     

       276
       276
       -
           e) Convey the object code using peer-to-peer transmission, provided

     

       277
       277
       -
           you inform other peers where the object code and Corresponding

     

       278
       278
       -
           Source of the work are being offered to the general public at no

     

       279
       279
       -
           charge under subsection 6d.

     

       280
       280
       -
       

     

       281
       281
       -
         A separable portion of the object code, whose source code is excluded

     

       282
       282
       -
       from the Corresponding Source as a System Library, need not be

     

       283
       283
       -
       included in conveying the object code work.

     

       284
       284
       -
       

     

       285
       285
       -
         A "User Product" is either (1) a "consumer product", which means any

     

       286
       286
       -
       tangible personal property which is normally used for personal, family,

     

       287
       287
       -
       or household purposes, or (2) anything designed or sold for incorporation

     

       288
       288
       -
       into a dwelling.  In determining whether a product is a consumer product,

     

       289
       289
       -
       doubtful cases shall be resolved in favor of coverage.  For a particular

     

       290
       290
       -
       product received by a particular user, "normally used" refers to a

     

       291
       291
       -
       typical or common use of that class of product, regardless of the status

     

       292
       292
       -
       of the particular user or of the way in which the particular user

     

       293
       293
       -
       actually uses, or expects or is expected to use, the product.  A product

     

       294
       294
       -
       is a consumer product regardless of whether the product has substantial

     

       295
       295
       -
       commercial, industrial or non-consumer uses, unless such uses represent

     

       296
       296
       -
       the only significant mode of use of the product.

     

       297
       297
       -
       

     

       298
       298
       -
         "Installation Information" for a User Product means any methods,

     

       299
       299
       -
       procedures, authorization keys, or other information required to install

     

       300
       300
       -
       and execute modified versions of a covered work in that User Product from

     

       301
       301
       -
       a modified version of its Corresponding Source.  The information must

     

       302
       302
       -
       suffice to ensure that the continued functioning of the modified object

     

       303
       303
       -
       code is in no case prevented or interfered with solely because

     

       304
       304
       -
       modification has been made.

     

       305
       305
       -
       

     

       306
       306
       -
         If you convey an object code work under this section in, or with, or

     

       307
       307
       -
       specifically for use in, a User Product, and the conveying occurs as

     

       308
       308
       -
       part of a transaction in which the right of possession and use of the

     

       309
       309
       -
       User Product is transferred to the recipient in perpetuity or for a

     

       310
       310
       -
       fixed term (regardless of how the transaction is characterized), the

     

       311
       311
       -
       Corresponding Source conveyed under this section must be accompanied

     

       312
       312
       -
       by the Installation Information.  But this requirement does not apply

     

       313
       313
       -
       if neither you nor any third party retains the ability to install

     

       314
       314
       -
       modified object code on the User Product (for example, the work has

     

       315
       315
       -
       been installed in ROM).

     

       316
       316
       -
       

     

       317
       317
       -
         The requirement to provide Installation Information does not include a

     

       318
       318
       -
       requirement to continue to provide support service, warranty, or updates

     

       319
       319
       -
       for a work that has been modified or installed by the recipient, or for

     

       320
       320
       -
       the User Product in which it has been modified or installed.  Access to a

     

       321
       321
       -
       network may be denied when the modification itself materially and

     

       322
       322
       -
       adversely affects the operation of the network or violates the rules and

     

       323
       323
       -
       protocols for communication across the network.

     

       324
       324
       -
       

     

       325
       325
       -
         Corresponding Source conveyed, and Installation Information provided,

     

       326
       326
       -
       in accord with this section must be in a format that is publicly

     

       327
       327
       -
       documented (and with an implementation available to the public in

     

       328
       328
       -
       source code form), and must require no special password or key for

     

       329
       329
       -
       unpacking, reading or copying.

     

       330
       330
       -
       

     

       331
       331
       -
         7. Additional Terms.

     

       332
       332
       -
       

     

       333
       333
       -
         "Additional permissions" are terms that supplement the terms of this

     

       334
       334
       -
       License by making exceptions from one or more of its conditions.

     

       335
       335
       -
       Additional permissions that are applicable to the entire Program shall

     

       336
       336
       -
       be treated as though they were included in this License, to the extent

     

       337
       337
       -
       that they are valid under applicable law.  If additional permissions

     

       338
       338
       -
       apply only to part of the Program, that part may be used separately

     

       339
       339
       -
       under those permissions, but the entire Program remains governed by

     

       340
       340
       -
       this License without regard to the additional permissions.

     

       341
       341
       -
       

     

       342
       342
       -
         When you convey a copy of a covered work, you may at your option

     

       343
       343
       -
       remove any additional permissions from that copy, or from any part of

     

       344
       344
       -
       it.  (Additional permissions may be written to require their own

     

       345
       345
       -
       removal in certain cases when you modify the work.)  You may place

     

       346
       346
       -
       additional permissions on material, added by you to a covered work,

     

       347
       347
       -
       for which you have or can give appropriate copyright permission.

     

       348
       348
       -
       

     

       349
       349
       -
         Notwithstanding any other provision of this License, for material you

     

       350
       350
       -
       add to a covered work, you may (if authorized by the copyright holders of

     

       351
       351
       -
       that material) supplement the terms of this License with terms:

     

       352
       352
       -
       

     

       353
       353
       -
           a) Disclaiming warranty or limiting liability differently from the

     

       354
       354
       -
           terms of sections 15 and 16 of this License; or

     

       355
       355
       -
       

     

       356
       356
       -
           b) Requiring preservation of specified reasonable legal notices or

     

       357
       357
       -
           author attributions in that material or in the Appropriate Legal

     

       358
       358
       -
           Notices displayed by works containing it; or

     

       359
       359
       -
       

     

       360
       360
       -
           c) Prohibiting misrepresentation of the origin of that material, or

     

       361
       361
       -
           requiring that modified versions of such material be marked in

     

       362
       362
       -
           reasonable ways as different from the original version; or

     

       363
       363
       -
       

     

       364
       364
       -
           d) Limiting the use for publicity purposes of names of licensors or

     

       365
       365
       -
           authors of the material; or

     

       366
       366
       -
       

     

       367
       367
       -
           e) Declining to grant rights under trademark law for use of some

     

       368
       368
       -
           trade names, trademarks, or service marks; or

     

       369
       369
       -
       

     

       370
       370
       -
           f) Requiring indemnification of licensors and authors of that

     

       371
       371
       -
           material by anyone who conveys the material (or modified versions of

     

       372
       372
       -
           it) with contractual assumptions of liability to the recipient, for

     

       373
       373
       -
           any liability that these contractual assumptions directly impose on

     

       374
       374
       -
           those licensors and authors.

     

       375
       375
       -
       

     

       376
       376
       -
         All other non-permissive additional terms are considered "further

     

       377
       377
       -
       restrictions" within the meaning of section 10.  If the Program as you

     

       378
       378
       -
       received it, or any part of it, contains a notice stating that it is

     

       379
       379
       -
       governed by this License along with a term that is a further

     

       380
       380
       -
       restriction, you may remove that term.  If a license document contains

     

       381
       381
       -
       a further restriction but permits relicensing or conveying under this

     

       382
       382
       -
       License, you may add to a covered work material governed by the terms

     

       383
       383
       -
       of that license document, provided that the further restriction does

     

       384
       384
       -
       not survive such relicensing or conveying.

     

       9
       9
       +
         This version of the GNU Lesser General Public License incorporates

     

       10
       10
       +
       the terms and conditions of version 3 of the GNU General Public

     

       11
       11
       +
       License, supplemented by the additional permissions listed below.

     

       385
       12
        
       

     

       386
       386
       -
         If you add terms to a covered work in accord with this section, you

     

       387
       387
       -
       must place, in the relevant source files, a statement of the

     

       388
       388
       -
       additional terms that apply to those files, or a notice indicating

     

       389
       389
       -
       where to find the applicable terms.

     

       13
       13
       +
         0. Additional Definitions.

     

       390
       14
        
       

     

       391
       391
       -
         Additional terms, permissive or non-permissive, may be stated in the

     

       392
       392
       -
       form of a separately written license, or stated as exceptions;

     

       393
       393
       -
       the above requirements apply either way.

     

       15
       15
       +
         As used herein, "this License" refers to version 3 of the GNU Lesser

     

       16
       16
       +
       General Public License, and the "GNU GPL" refers to version 3 of the GNU

     

       17
       17
       +
       General Public License.

     

       394
       18
        
       

     

       395
       395
       -
         8. Termination.

     

       19
       19
       +
         "The Library" refers to a covered work governed by this License,

     

       20
       20
       +
       other than an Application or a Combined Work as defined below.

     

       396
       21
        
       

     

       397
       397
       -
         You may not propagate or modify a covered work except as expressly

     

       398
       398
       -
       provided under this License.  Any attempt otherwise to propagate or

     

       399
       399
       -
       modify it is void, and will automatically terminate your rights under

     

       400
       400
       -
       this License (including any patent licenses granted under the third

     

       401
       401
       -
       paragraph of section 11).

     

       22
       22
       +
         An "Application" is any work that makes use of an interface provided

     

       23
       23
       +
       by the Library, but which is not otherwise based on the Library.

     

       24
       24
       +
       Defining a subclass of a class defined by the Library is deemed a mode

     

       25
       25
       +
       of using an interface provided by the Library.

     

       402
       26
        
       

     

       403
       403
       -
         However, if you cease all violation of this License, then your

     

       404
       404
       -
       license from a particular copyright holder is reinstated (a)

     

       405
       405
       -
       provisionally, unless and until the copyright holder explicitly and

     

       406
       406
       -
       finally terminates your license, and (b) permanently, if the copyright

     

       407
       407
       -
       holder fails to notify you of the violation by some reasonable means

     

       408
       408
       -
       prior to 60 days after the cessation.

     

       27
       27
       +
         A "Combined Work" is a work produced by combining or linking an

     

       28
       28
       +
       Application with the Library.  The particular version of the Library

     

       29
       29
       +
       with which the Combined Work was made is also called the "Linked

     

       30
       30
       +
       Version".

     

       409
       31
        
       

     

       410
       410
       -
         Moreover, your license from a particular copyright holder is

     

       411
       411
       -
       reinstated permanently if the copyright holder notifies you of the

     

       412
       412
       -
       violation by some reasonable means, this is the first time you have

     

       413
       413
       -
       received notice of violation of this License (for any work) from that

     

       414
       414
       -
       copyright holder, and you cure the violation prior to 30 days after

     

       415
       415
       -
       your receipt of the notice.

     

       32
       32
       +
         The "Minimal Corresponding Source" for a Combined Work means the

     

       33
       33
       +
       Corresponding Source for the Combined Work, excluding any source code

     

       34
       34
       +
       for portions of the Combined Work that, considered in isolation, are

     

       35
       35
       +
       based on the Application, and not on the Linked Version.

     

       416
       36
        
       

     

       417
       417
       -
         Termination of your rights under this section does not terminate the

     

       418
       418
       -
       licenses of parties who have received copies or rights from you under

     

       419
       419
       -
       this License.  If your rights have been terminated and not permanently

     

       420
       420
       -
       reinstated, you do not qualify to receive new licenses for the same

     

       421
       421
       -
       material under section 10.

     

       37
       37
       +
         The "Corresponding Application Code" for a Combined Work means the

     

       38
       38
       +
       object code and/or source code for the Application, including any data

     

       39
       39
       +
       and utility programs needed for reproducing the Combined Work from the

     

       40
       40
       +
       Application, but excluding the System Libraries of the Combined Work.

     

       422
       41
        
       

     

       423
       423
       -
         9. Acceptance Not Required for Having Copies.

     

       42
       42
       +
         1. Exception to Section 3 of the GNU GPL.

     

       424
       43
        
       

     

       425
       425
       -
         You are not required to accept this License in order to receive or

     

       426
       426
       -
       run a copy of the Program.  Ancillary propagation of a covered work

     

       427
       427
       -
       occurring solely as a consequence of using peer-to-peer transmission

     

       428
       428
       -
       to receive a copy likewise does not require acceptance.  However,

     

       429
       429
       -
       nothing other than this License grants you permission to propagate or

     

       430
       430
       -
       modify any covered work.  These actions infringe copyright if you do

     

       431
       431
       -
       not accept this License.  Therefore, by modifying or propagating a

     

       432
       432
       -
       covered work, you indicate your acceptance of this License to do so.

     

       44
       44
       +
         You may convey a covered work under sections 3 and 4 of this License

     

       45
       45
       +
       without being bound by section 3 of the GNU GPL.

     

       433
       46
        
       

     

       434
       434
       -
         10. Automatic Licensing of Downstream Recipients.

     

       47
       47
       +
         2. Conveying Modified Versions.

     

       435
       48
        
       

     

       436
       436
       -
         Each time you convey a covered work, the recipient automatically

     

       437
       437
       -
       receives a license from the original licensors, to run, modify and

     

       438
       438
       -
       propagate that work, subject to this License.  You are not responsible

     

       439
       439
       -
       for enforcing compliance by third parties with this License.

     

       49
       49
       +
         If you modify a copy of the Library, and, in your modifications, a

     

       50
       50
       +
       facility refers to a function or data to be supplied by an Application

     

       51
       51
       +
       that uses the facility (other than as an argument passed when the

     

       52
       52
       +
       facility is invoked), then you may convey a copy of the modified

     

       53
       53
       +
       version:

     

       440
       54
        
       

     

       441
       441
       -
         An "entity transaction" is a transaction transferring control of an

     

       442
       442
       -
       organization, or substantially all assets of one, or subdividing an

     

       443
       443
       -
       organization, or merging organizations.  If propagation of a covered

     

       444
       444
       -
       work results from an entity transaction, each party to that

     

       445
       445
       -
       transaction who receives a copy of the work also receives whatever

     

       446
       446
       -
       licenses to the work the party's predecessor in interest had or could

     

       447
       447
       -
       give under the previous paragraph, plus a right to possession of the

     

       448
       448
       -
       Corresponding Source of the work from the predecessor in interest, if

     

       449
       449
       -
       the predecessor has it or can get it with reasonable efforts.

     

       55
       55
       +
          a) under this License, provided that you make a good faith effort to

     

       56
       56
       +
          ensure that, in the event an Application does not supply the

     

       57
       57
       +
          function or data, the facility still operates, and performs

     

       58
       58
       +
          whatever part of its purpose remains meaningful, or

     

       450
       59
        
       

     

       451
       451
       -
         You may not impose any further restrictions on the exercise of the

     

       452
       452
       -
       rights granted or affirmed under this License.  For example, you may

     

       453
       453
       -
       not impose a license fee, royalty, or other charge for exercise of

     

       454
       454
       -
       rights granted under this License, and you may not initiate litigation

     

       455
       455
       -
       (including a cross-claim or counterclaim in a lawsuit) alleging that

     

       456
       456
       -
       any patent claim is infringed by making, using, selling, offering for

     

       457
       457
       -
       sale, or importing the Program or any portion of it.

     

       60
       60
       +
          b) under the GNU GPL, with none of the additional permissions of

     

       61
       61
       +
          this License applicable to that copy.

     

       458
       62
        
       

     

       459
       459
       -
         11. Patents.

     

       63
       63
       +
         3. Object Code Incorporating Material from Library Header Files.

     

       460
       64
        
       

     

       461
       461
       -
         A "contributor" is a copyright holder who authorizes use under this

     

       462
       462
       -
       License of the Program or a work on which the Program is based.  The

     

       463
       463
       -
       work thus licensed is called the contributor's "contributor version".

     

       65
       65
       +
         The object code form of an Application may incorporate material from

     

       66
       66
       +
       a header file that is part of the Library.  You may convey such object

     

       67
       67
       +
       code under terms of your choice, provided that, if the incorporated

     

       68
       68
       +
       material is not limited to numerical parameters, data structure

     

       69
       69
       +
       layouts and accessors, or small macros, inline functions and templates

     

       70
       70
       +
       (ten or fewer lines in length), you do both of the following:

     

       464
       71
        
       

     

       465
       465
       -
         A contributor's "essential patent claims" are all patent claims

     

       466
       466
       -
       owned or controlled by the contributor, whether already acquired or

     

       467
       467
       -
       hereafter acquired, that would be infringed by some manner, permitted

     

       468
       468
       -
       by this License, of making, using, or selling its contributor version,

     

       469
       469
       -
       but do not include claims that would be infringed only as a

     

       470
       470
       -
       consequence of further modification of the contributor version.  For

     

       471
       471
       -
       purposes of this definition, "control" includes the right to grant

     

       472
       472
       -
       patent sublicenses in a manner consistent with the requirements of

     

       473
       473
       -
       this License.

     

       72
       72
       +
          a) Give prominent notice with each copy of the object code that the

     

       73
       73
       +
          Library is used in it and that the Library and its use are

     

       74
       74
       +
          covered by this License.

     

       474
       75
        
       

     

       475
       475
       -
         Each contributor grants you a non-exclusive, worldwide, royalty-free

     

       476
       476
       -
       patent license under the contributor's essential patent claims, to

     

       477
       477
       -
       make, use, sell, offer for sale, import and otherwise run, modify and

     

       478
       478
       -
       propagate the contents of its contributor version.

     

       76
       76
       +
          b) Accompany the object code with a copy of the GNU GPL and this license

     

       77
       77
       +
          document.

     

       479
       78
        
       

     

       480
       480
       -
         In the following three paragraphs, a "patent license" is any express

     

       481
       481
       -
       agreement or commitment, however denominated, not to enforce a patent

     

       482
       482
       -
       (such as an express permission to practice a patent or covenant not to

     

       483
       483
       -
       sue for patent infringement).  To "grant" such a patent license to a

     

       484
       484
       -
       party means to make such an agreement or commitment not to enforce a

     

       485
       485
       -
       patent against the party.

     

       79
       79
       +
         4. Combined Works.

     

       486
       80
        
       

     

       487
       487
       -
         If you convey a covered work, knowingly relying on a patent license,

     

       488
       488
       -
       and the Corresponding Source of the work is not available for anyone

     

       489
       489
       -
       to copy, free of charge and under the terms of this License, through a

     

       490
       490
       -
       publicly available network server or other readily accessible means,

     

       491
       491
       -
       then you must either (1) cause the Corresponding Source to be so

     

       492
       492
       -
       available, or (2) arrange to deprive yourself of the benefit of the

     

       493
       493
       -
       patent license for this particular work, or (3) arrange, in a manner

     

       494
       494
       -
       consistent with the requirements of this License, to extend the patent

     

       495
       495
       -
       license to downstream recipients.  "Knowingly relying" means you have

     

       496
       496
       -
       actual knowledge that, but for the patent license, your conveying the

     

       497
       497
       -
       covered work in a country, or your recipient's use of the covered work

     

       498
       498
       -
       in a country, would infringe one or more identifiable patents in that

     

       499
       499
       -
       country that you have reason to believe are valid.

     

       81
       81
       +
         You may convey a Combined Work under terms of your choice that,

     

       82
       82
       +
       taken together, effectively do not restrict modification of the

     

       83
       83
       +
       portions of the Library contained in the Combined Work and reverse

     

       84
       84
       +
       engineering for debugging such modifications, if you also do each of

     

       85
       85
       +
       the following:

     

       500
       86
        
       

     

       501
       501
       -
         If, pursuant to or in connection with a single transaction or

     

       502
       502
       -
       arrangement, you convey, or propagate by procuring conveyance of, a

     

       503
       503
       -
       covered work, and grant a patent license to some of the parties

     

       504
       504
       -
       receiving the covered work authorizing them to use, propagate, modify

     

       505
       505
       -
       or convey a specific copy of the covered work, then the patent license

     

       506
       506
       -
       you grant is automatically extended to all recipients of the covered

     

       507
       507
       -
       work and works based on it.

     

       87
       87
       +
          a) Give prominent notice with each copy of the Combined Work that

     

       88
       88
       +
          the Library is used in it and that the Library and its use are

     

       89
       89
       +
          covered by this License.

     

       508
       90
        
       

     

       509
       509
       -
         A patent license is "discriminatory" if it does not include within

     

       510
       510
       -
       the scope of its coverage, prohibits the exercise of, or is

     

       511
       511
       -
       conditioned on the non-exercise of one or more of the rights that are

     

       512
       512
       -
       specifically granted under this License.  You may not convey a covered

     

       513
       513
       -
       work if you are a party to an arrangement with a third party that is

     

       514
       514
       -
       in the business of distributing software, under which you make payment

     

       515
       515
       -
       to the third party based on the extent of your activity of conveying

     

       516
       516
       -
       the work, and under which the third party grants, to any of the

     

       517
       517
       -
       parties who would receive the covered work from you, a discriminatory

     

       518
       518
       -
       patent license (a) in connection with copies of the covered work

     

       519
       519
       -
       conveyed by you (or copies made from those copies), or (b) primarily

     

       520
       520
       -
       for and in connection with specific products or compilations that

     

       521
       521
       -
       contain the covered work, unless you entered into that arrangement,

     

       522
       522
       -
       or that patent license was granted, prior to 28 March 2007.

     

       91
       91
       +
          b) Accompany the Combined Work with a copy of the GNU GPL and this license

     

       92
       92
       +
          document.

     

       523
       93
        
       

     

       524
       524
       -
         Nothing in this License shall be construed as excluding or limiting

     

       525
       525
       -
       any implied license or other defenses to infringement that may

     

       526
       526
       -
       otherwise be available to you under applicable patent law.

     

       527
       527
       -
       

     

       528
       528
       -
         12. No Surrender of Others' Freedom.

     

       529
       529
       -
       

     

       530
       530
       -
         If conditions are imposed on you (whether by court order, agreement or

     

       531
       531
       -
       otherwise) that contradict the conditions of this License, they do not

     

       532
       532
       -
       excuse you from the conditions of this License.  If you cannot convey a

     

       533
       533
       -
       covered work so as to satisfy simultaneously your obligations under this

     

       534
       534
       -
       License and any other pertinent obligations, then as a consequence you may

     

       535
       535
       -
       not convey it at all.  For example, if you agree to terms that obligate you

     

       536
       536
       -
       to collect a royalty for further conveying from those to whom you convey

     

       537
       537
       -
       the Program, the only way you could satisfy both those terms and this

     

       538
       538
       -
       License would be to refrain entirely from conveying the Program.

     

       539
       539
       -
       

     

       540
       540
       -
         13. Remote Network Interaction; Use with the GNU General Public License.

     

       541
       541
       -
       

     

       542
       542
       -
         Notwithstanding any other provision of this License, if you modify the

     

       543
       543
       -
       Program, your modified version must prominently offer all users

     

       544
       544
       -
       interacting with it remotely through a computer network (if your version

     

       545
       545
       -
       supports such interaction) an opportunity to receive the Corresponding

     

       546
       546
       -
       Source of your version by providing access to the Corresponding Source

     

       547
       547
       -
       from a network server at no charge, through some standard or customary

     

       548
       548
       -
       means of facilitating copying of software.  This Corresponding Source

     

       549
       549
       -
       shall include the Corresponding Source for any work covered by version 3

     

       550
       550
       -
       of the GNU General Public License that is incorporated pursuant to the

     

       551
       551
       -
       following paragraph.

     

       552
       552
       -
       

     

       553
       553
       -
         Notwithstanding any other provision of this License, you have

     

       554
       554
       -
       permission to link or combine any covered work with a work licensed

     

       555
       555
       -
       under version 3 of the GNU General Public License into a single

     

       556
       556
       -
       combined work, and to convey the resulting work.  The terms of this

     

       557
       557
       -
       License will continue to apply to the part which is the covered work,

     

       558
       558
       -
       but the work with which it is combined will remain governed by version

     

       559
       559
       -
       3 of the GNU General Public License.

     

       560
       560
       -
       

     

       561
       561
       -
         14. Revised Versions of this License.

     

       562
       562
       -
       

     

       563
       563
       -
         The Free Software Foundation may publish revised and/or new versions of

     

       564
       564
       -
       the GNU Affero General Public License from time to time.  Such new versions

     

       565
       565
       -
       will be similar in spirit to the present version, but may differ in detail to

     

       566
       566
       -
       address new problems or concerns.

     

       94
       94
       +
          c) For a Combined Work that displays copyright notices during

     

       95
       95
       +
          execution, include the copyright notice for the Library among

     

       96
       96
       +
          these notices, as well as a reference directing the user to the

     

       97
       97
       +
          copies of the GNU GPL and this license document.

     

       567
       98
        
       

     

       568
       568
       -
         Each version is given a distinguishing version number.  If the

     

       569
       569
       -
       Program specifies that a certain numbered version of the GNU Affero General

     

       570
       570
       -
       Public License "or any later version" applies to it, you have the

     

       571
       571
       -
       option of following the terms and conditions either of that numbered

     

       572
       572
       -
       version or of any later version published by the Free Software

     

       573
       573
       -
       Foundation.  If the Program does not specify a version number of the

     

       574
       574
       -
       GNU Affero General Public License, you may choose any version ever published

     

       575
       575
       -
       by the Free Software Foundation.

     

       576
       576
       -
       

     

       577
       577
       -
         If the Program specifies that a proxy can decide which future

     

       578
       578
       -
       versions of the GNU Affero General Public License can be used, that proxy's

     

       579
       579
       -
       public statement of acceptance of a version permanently authorizes you

     

       580
       580
       -
       to choose that version for the Program.

     

       581
       581
       -
       

     

       582
       582
       -
         Later license versions may give you additional or different

     

       583
       583
       -
       permissions.  However, no additional obligations are imposed on any

     

       584
       584
       -
       author or copyright holder as a result of your choosing to follow a

     

       585
       585
       -
       later version.

     

       586
       586
       -
       

     

       587
       587
       -
         15. Disclaimer of Warranty.

     

       588
       588
       -
       

     

       589
       589
       -
         THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY

     

       590
       590
       -
       APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT

     

       591
       591
       -
       HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY

     

       592
       592
       -
       OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,

     

       593
       593
       -
       THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

     

       594
       594
       -
       PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM

     

       595
       595
       -
       IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF

     

       596
       596
       -
       ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

     

       597
       597
       -
       

     

       598
       598
       -
         16. Limitation of Liability.

     

       599
       599
       -
       

     

       600
       600
       -
         IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING

     

       601
       601
       -
       WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS

     

       602
       602
       -
       THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY

     

       603
       603
       -
       GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE

     

       604
       604
       -
       USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF

     

       605
       605
       -
       DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD

     

       606
       606
       -
       PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),

     

       607
       607
       -
       EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF

     

       608
       608
       -
       SUCH DAMAGES.

     

       609
       609
       -
       

     

       610
       610
       -
         17. Interpretation of Sections 15 and 16.

     

       611
       611
       -
       

     

       612
       612
       -
         If the disclaimer of warranty and limitation of liability provided

     

       613
       613
       -
       above cannot be given local legal effect according to their terms,

     

       614
       614
       -
       reviewing courts shall apply local law that most closely approximates

     

       615
       615
       -
       an absolute waiver of all civil liability in connection with the

     

       616
       616
       -
       Program, unless a warranty or assumption of liability accompanies a

     

       617
       617
       -
       copy of the Program in return for a fee.

     

       99
       99
       +
          d) Do one of the following:

     

       618
       100
        
       

     

       619
       619
       -
                            END OF TERMS AND CONDITIONS

     

       101
       101
       +
              0) Convey the Minimal Corresponding Source under the terms of this

     

       102
       102
       +
              License, and the Corresponding Application Code in a form

     

       103
       103
       +
              suitable for, and under terms that permit, the user to

     

       104
       104
       +
              recombine or relink the Application with a modified version of

     

       105
       105
       +
              the Linked Version to produce a modified Combined Work, in the

     

       106
       106
       +
              manner specified by section 6 of the GNU GPL for conveying

     

       107
       107
       +
              Corresponding Source.

     

       620
       108
        
       

     

       621
       621
       -
                   How to Apply These Terms to Your New Programs

     

       109
       109
       +
              1) Use a suitable shared library mechanism for linking with the

     

       110
       110
       +
              Library.  A suitable mechanism is one that (a) uses at run time

     

       111
       111
       +
              a copy of the Library already present on the user's computer

     

       112
       112
       +
              system, and (b) will operate properly with a modified version

     

       113
       113
       +
              of the Library that is interface-compatible with the Linked

     

       114
       114
       +
              Version.

     

       622
       115
        
       

     

       623
       623
       -
         If you develop a new program, and you want it to be of the greatest

     

       624
       624
       -
       possible use to the public, the best way to achieve this is to make it

     

       625
       625
       -
       free software which everyone can redistribute and change under these terms.

     

       116
       116
       +
          e) Provide Installation Information, but only if you would otherwise

     

       117
       117
       +
          be required to provide such information under section 6 of the

     

       118
       118
       +
          GNU GPL, and only to the extent that such information is

     

       119
       119
       +
          necessary to install and execute a modified version of the

     

       120
       120
       +
          Combined Work produced by recombining or relinking the

     

       121
       121
       +
          Application with a modified version of the Linked Version. (If

     

       122
       122
       +
          you use option 4d0, the Installation Information must accompany

     

       123
       123
       +
          the Minimal Corresponding Source and Corresponding Application

     

       124
       124
       +
          Code. If you use option 4d1, you must provide the Installation

     

       125
       125
       +
          Information in the manner specified by section 6 of the GNU GPL

     

       126
       126
       +
          for conveying Corresponding Source.)

     

       626
       127
        
       

     

       627
       627
       -
         To do so, attach the following notices to the program.  It is safest

     

       628
       628
       -
       to attach them to the start of each source file to most effectively

     

       629
       629
       -
       state the exclusion of warranty; and each file should have at least

     

       630
       630
       -
       the "copyright" line and a pointer to where the full notice is found.

     

       128
       128
       +
         5. Combined Libraries.

     

       631
       129
        
       

     

       632
       632
       -
           <one line to give the program's name and a brief idea of what it does.>

     

       633
       633
       -
           Copyright (C) <year>  <name of author>

     

       130
       130
       +
         You may place library facilities that are a work based on the

     

       131
       131
       +
       Library side by side in a single library together with other library

     

       132
       132
       +
       facilities that are not Applications and are not covered by this

     

       133
       133
       +
       License, and convey such a combined library under terms of your

     

       134
       134
       +
       choice, if you do both of the following:

     

       634
       135
        
       

     

       635
       635
       -
           This program is free software: you can redistribute it and/or modify

     

       636
       636
       -
           it under the terms of the GNU Affero General Public License as published by

     

       637
       637
       -
           the Free Software Foundation, either version 3 of the License, or

     

       638
       638
       -
           (at your option) any later version.

     

       136
       136
       +
          a) Accompany the combined library with a copy of the same work based

     

       137
       137
       +
          on the Library, uncombined with any other library facilities,

     

       138
       138
       +
          conveyed under the terms of this License.

     

       639
       139
        
       

     

       640
       640
       -
           This program is distributed in the hope that it will be useful,

     

       641
       641
       -
           but WITHOUT ANY WARRANTY; without even the implied warranty of

     

       642
       642
       -
           MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

     

       643
       643
       -
           GNU Affero General Public License for more details.

     

       140
       140
       +
          b) Give prominent notice with the combined library that part of it

     

       141
       141
       +
          is a work based on the Library, and explaining where to find the

     

       142
       142
       +
          accompanying uncombined form of the same work.

     

       644
       143
        
       

     

       645
       645
       -
           You should have received a copy of the GNU Affero General Public License

     

       646
       646
       -
           along with this program.  If not, see <https://www.gnu.org/licenses/>.

     

       144
       144
       +
         6. Revised Versions of the GNU Lesser General Public License.

     

       647
       145
        
       

     

       648
       648
       -
       Also add information on how to contact you by electronic and paper mail.

     

       146
       146
       +
         The Free Software Foundation may publish revised and/or new versions

     

       147
       147
       +
       of the GNU Lesser General Public License from time to time. Such new

     

       148
       148
       +
       versions will be similar in spirit to the present version, but may

     

       149
       149
       +
       differ in detail to address new problems or concerns.

     

       649
       150
        
       

     

       650
       650
       -
         If your software can interact with users remotely through a computer

     

       651
       651
       -
       network, you should also make sure that it provides a way for users to

     

       652
       652
       -
       get its source.  For example, if your program is a web application, its

     

       653
       653
       -
       interface could display a "Source" link that leads users to an archive

     

       654
       654
       -
       of the code.  There are many ways you could offer source, and different

     

       655
       655
       -
       solutions will be better for different programs; see section 13 for the

     

       656
       656
       -
       specific requirements.

     

       151
       151
       +
         Each version is given a distinguishing version number. If the

     

       152
       152
       +
       Library as you received it specifies that a certain numbered version

     

       153
       153
       +
       of the GNU Lesser General Public License "or any later version"

     

       154
       154
       +
       applies to it, you have the option of following the terms and

     

       155
       155
       +
       conditions either of that published version or of any later version

     

       156
       156
       +
       published by the Free Software Foundation. If the Library as you

     

       157
       157
       +
       received it does not specify a version number of the GNU Lesser

     

       158
       158
       +
       General Public License, you may choose any version of the GNU Lesser

     

       159
       159
       +
       General Public License ever published by the Free Software Foundation.

     

       657
       160
        
       

     

       658
       658
       -
         You should also get your employer (if you work as a programmer) or school,

     

       659
       659
       -
       if any, to sign a "copyright disclaimer" for the program, if necessary.

     

       660
       660
       -
       For more information on this, and how to apply and follow the GNU AGPL, see

     

       661
       661
       -
       <https://www.gnu.org/licenses/>.

     

       161
       161
       +
         If the Library as you received it specifies that a proxy can decide

     

       162
       162
       +
       whether future versions of the GNU Lesser General Public License shall

     

       163
       163
       +
       apply, that proxy's public statement of acceptance of any version is

     

       164
       164
       +
       permanent authorization for you to choose that version for the

     

       165
       165
       +
       Library.

+1 -1

README.md

···

       14
       14
        
       

     

       15
       15
        
       **_This is an experimental passion project._** moonlight was not created out of malicious intent nor intended to seriously compete with other mods. Anything and everything is subject to change.

     

       16
       16
        
       

     

       17
       17
       -
       moonlight is licensed under the [GNU Affero General Public License](https://www.gnu.org/licenses/agpl-3.0.html) (`AGPL-3.0-or-later`). See [the documentation](https://moonlight-mod.github.io/) for more information.

     

       17
       17
       +
       moonlight is licensed under the [GNU Lesser General Public License](https://www.gnu.org/licenses/lgpl-3.0.html) (`LGPL-3.0-or-later`). See [the documentation](https://moonlight-mod.github.io/) for more information.

+17 -5

build.mjs

···

       135
       135
        
       

     

       136
       136
        
         const wpModulesDir = `packages/core-extensions/src/${ext}/webpackModules`;

     

       137
       137
        
         if (fs.existsSync(wpModulesDir) && side === "index") {

     

       138
       138
       -
           const wpModules = fs.readdirSync(wpModulesDir);

     

       139
       139
       -
           for (const wpModule of wpModules) {

     

       140
       140
       -
             entryPoints.push(

     

       141
       141
       -
               `packages/core-extensions/src/${ext}/webpackModules/${wpModule}`

     

       142
       142
       -
             );

     

       138
       138
       +
           const wpModules = fs.opendirSync(wpModulesDir);

     

       139
       139
       +
           for await (const wpModule of wpModules) {

     

       140
       140
       +
             if (wpModule.isFile()) {

     

       141
       141
       +
               entryPoints.push(

     

       142
       142
       +
                 `packages/core-extensions/src/${ext}/webpackModules/${wpModule.name}`

     

       143
       143
       +
               );

     

       144
       144
       +
             } else {

     

       145
       145
       +
               for (const fileExt of ["ts", "tsx"]) {

     

       146
       146
       +
                 const path = `packages/core-extensions/src/${ext}/webpackModules/${wpModule.name}/index.${fileExt}`;

     

       147
       147
       +
                 if (fs.existsSync(path)) {

     

       148
       148
       +
                   entryPoints.push({

     

       149
       149
       +
                     in: path,

     

       150
       150
       +
                     out: `webpackModules/${wpModule.name}`

     

       151
       151
       +
                   });

     

       152
       152
       +
                 }

     

       153
       153
       +
               }

     

       154
       154
       +
             }

     

       143
       155
        
           }

     

       144
       156
        
         }

     

       145
       157

-1

env.d.ts

···

       1
       1
       -
       /// <reference types="./packages/types/src/index" />

+2 -1

package.json

···

       1
       1
        
       {

     

       2
       2
        
         "name": "moonlight",

     

       3
       3
       -
         "version": "1.0.7",

     

       3
       3
       +
         "version": "1.0.8",

     

       4
       4
        
         "description": "Yet another Discord mod",

     

       5
       5
        
         "homepage": "https://moonlight-mod.github.io/",

     

       6
       6
       +
         "license": "LGPL-3.0-or-later",

     

       6
       7
        
         "repository": {

     

       7
       8
        
           "type": "git",

     

       8
       9
        
           "url": "git+https://github.com/moonlight-mod/moonlight.git"

+1 -1

packages/core-extensions/src/common/webpackModules/components.ts

···

       6
       6
        
       )[0].exports.default;

     

       7
       7
        
       const LegacyText = spacepack.findByCode(".selectable", ".colorStandard")[0]

     

       8
       8
        
         .exports.default;

     

       9
       9
       -
       const Flex = spacepack.findByCode(".flex" + "GutterSmall,")[0].exports.default;

     

       9
       9
       +
       const Flex = spacepack.findByCode(".flex" + "GutterSmall,")[0].exports.Flex;

     

       10
       10
        
       const CardClasses = spacepack.findByCode("card", "cardHeader", "inModal")[0]

     

       11
       11
        
         .exports;

     

       12
       12
        
       const ControlClasses = spacepack.findByCode(

+2 -1

packages/core-extensions/src/common/webpackModules/flux.ts

···

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

     

       2
       2
        
       

     

       3
       3
        
       module.exports = spacepack.findByCode(

     

       4
       4
       -
         ["useStateFromStores", ":function"].join("")

     

       4
       4
       +
         ["useStateFromStores", ":function"].join(""),

     

       5
       5
       +
         "Store:"

     

       5
       6
        
       )[0].exports;

+37

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

···

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

     

       2
       2
       +
       

     

       3
       3
       +
       export const patches: Patch[] = [

     

       4
       4
       +
         {

     

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

     

       6
       6
       +
           replace: [

     

       7
       7
       +
             {

     

       8
       8
       +
               match:

     

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

     

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

     

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

     

       12
       12
       +
             }

     

       13
       13
       +
           ]

     

       14
       14
       +
         },

     

       15
       15
       +
         {

     

       16
       16
       +
           find: ".getContextMenu(",

     

       17
       17
       +
           replace: [

     

       18
       18
       +
             {

     

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

     

       20
       20
       +
               replacement: (render) =>

     

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

     

       22
       22
       +
             }

     

       23
       23
       +
           ]

     

       24
       24
       +
         }

     

       25
       25
       +
       ];

     

       26
       26
       +
       

     

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

     

       28
       28
       +
         contextMenu: {

     

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

     

       30
       30
       +
         },

     

       31
       31
       +
         evilMenu: {

     

       32
       32
       +
           dependencies: [

     

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

     

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

     

       35
       35
       +
           ]

     

       36
       36
       +
         }

     

       37
       37
       +
       };

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

···

       1
       1
       +
       {

     

       2
       2
       +
         "id": "contextMenu",

     

       3
       3
       +
         "meta": {

     

       4
       4
       +
           "name": "Context Menu",

     

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

     

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

     

       7
       7
       +
           "tags": ["library"]

     

       8
       8
       +
         }

     

       9
       9
       +
       }

+66

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

···

       1
       1
       +
       import {

     

       2
       2
       +
         InternalItem,

     

       3
       3
       +
         MenuElement,

     

       4
       4
       +
         MenuProps

     

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

     

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

     

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

     

       8
       8
       +
       

     

       9
       9
       +
       type Patch = {

     

       10
       10
       +
         navId: string;

     

       11
       11
       +
         item: (

     

       12
       12
       +
           props: any

     

       13
       13
       +
         ) =>

     

       14
       14
       +
           | React.ReactComponentElement<MenuElement>

     

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

     

       16
       16
       +
         anchorId: string;

     

       17
       17
       +
         before: boolean;

     

       18
       18
       +
       };

     

       19
       19
       +
       

     

       20
       20
       +
       export function addItem<T>(

     

       21
       21
       +
         navId: string,

     

       22
       22
       +
         item: (

     

       23
       23
       +
           props: T

     

       24
       24
       +
         ) =>

     

       25
       25
       +
           | React.ReactComponentElement<MenuElement>

     

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

     

       27
       27
       +
         anchorId: string,

     

       28
       28
       +
         before = false

     

       29
       29
       +
       ) {

     

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

     

       31
       31
       +
       }

     

       32
       32
       +
       

     

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

     

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

     

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

     

       36
       36
       +
         if (!matches.length) return;

     

       37
       37
       +
       

     

       38
       38
       +
         for (const patch of matches) {

     

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

     

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

     

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

     

       42
       42
       +
         }

     

       43
       43
       +
       }

     

       44
       44
       +
       

     

       45
       45
       +
       let menuProps: any;

     

       46
       46
       +
       function _saveProps(self: any, el: any) {

     

       47
       47
       +
         menuProps = el.props;

     

       48
       48
       +
       

     

       49
       49
       +
         const original = self.props.closeContextMenu;

     

       50
       50
       +
         self.props.closeContextMenu = function (...args: any[]) {

     

       51
       51
       +
           menuProps = undefined;

     

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

     

       53
       53
       +
         };

     

       54
       54
       +
       

     

       55
       55
       +
         return el;

     

       56
       56
       +
       }

     

       57
       57
       +
       

     

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

     

       59
       59
       +
         .exports;

     

       60
       60
       +
       

     

       61
       61
       +
       module.exports = {

     

       62
       62
       +
         ...MenuElements,

     

       63
       63
       +
         addItem,

     

       64
       64
       +
         _patchMenu,

     

       65
       65
       +
         _saveProps

     

       66
       66
       +
       };

+24

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

···

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

     

       2
       2
       +
       

     

       3
       3
       +
       let code =

     

       4
       4
       +
         spacepack.require.m[

     

       5
       5
       +
           spacepack.findByCode(

     

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

     

       7
       7
       +
           )[0].id

     

       8
       8
       +
         ].toString();

     

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

     

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

     

       11
       11
       +
       const mod = new Function(

     

       12
       12
       +
         "module",

     

       13
       13
       +
         "exports",

     

       14
       14
       +
         "require",

     

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

     

       16
       16
       +
       );

     

       17
       17
       +
       const exp: any = {};

     

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

     

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

     

       20
       20
       +
         return exp.Menu({

     

       21
       21
       +
           children: el,

     

       22
       22
       +
           __contextMenu_evilMenu: true

     

       23
       23
       +
         });

     

       24
       24
       +
       };

+4 -5

packages/core-extensions/src/disableSentry/index.ts

···

       6
       6
        
           find: "DSN:function",

     

       7
       7
        
           replace: {

     

       8
       8
        
             type: PatchReplaceType.Normal,

     

       9
       9
       -
             match: /default:function\(\){return .}/,

     

       10
       10
       -
             replacement:

     

       11
       11
       -
               'default:function(){return require("disableSentry_stub").proxy()}'

     

       9
       9
       +
             match: /(?<=\.default=){.+?}}/,

     

       10
       10
       +
             replacement: 'require("disableSentry_stub").proxy()'

     

       12
       11
        
           }

     

       13
       12
        
         },

     

       14
       13
        
         {

     
···

       32
       31
        
           find: "window.DiscordErrors=",

     

       33
       32
        
           replace: {

     

       34
       33
        
             type: PatchReplaceType.Normal,

     

       35
       35
       -
             match: /uses_client_mods:\(0,.\.usesClientMods\)\(\)/,

     

       36
       36
       -
             replacement: "uses_client_mods:false"

     

       34
       34
       +
             match: /\(0,.\.usesClientMods\)\(\)/,

     

       35
       35
       +
             replacement: "false"

     

       37
       36
        
           }

     

       38
       37
        
         }

     

       39
       38
        
       ];

+9 -2

packages/core-extensions/src/experiments/index.ts

···

       2
       2
        
       

     

       3
       3
        
       export const patches: Patch[] = [

     

       4
       4
        
         {

     

       5
       5
       -
           find: "isStaffEnv:",

     

       5
       5
       +
           find: "isStaffPersonal:",

     

       6
       6
       +
           replace: {

     

       7
       7
       +
             match: /&&null!=this\.personalConnectionId/,

     

       8
       8
       +
             replacement: "||!0"

     

       9
       9
       +
           }

     

       10
       10
       +
         },

     

       11
       11
       +
         {

     

       12
       12
       +
           find: '"scientist:triggered"', // Scientist? Triggered.

     

       6
       13
        
           replace: {

     

       7
       7
       -
             match: /.\.isStaff\(\)/,

     

       14
       14
       +
             match: /(?<=personal_connection_id\|\|)!1/,

     

       8
       15
        
             replacement: "!0"

     

       9
       16
        
           }

     

       10
       17
        
         }

+7 -1

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

···

       3
       3
        
         "meta": {

     

       4
       4
        
           "name": "Experiments",

     

       5
       5
        
           "tagline": "Allows you to configure Discord's internal A/B testing features",

     

       6
       6
       -
           "authors": ["NotNite"],

     

       6
       6
       +
           "authors": ["NotNite", "Cynosphere"],

     

       7
       7
        
           "tags": ["dangerZone"]

     

       8
       8
       +
         },

     

       9
       9
       +
         "settings": {

     

       10
       10
       +
           "sections": {

     

       11
       11
       +
             "displayName": "Allow access to other staff settings elsewhere",

     

       12
       12
       +
             "type": "boolean"

     

       13
       13
       +
           }

     

       8
       14
        
         }

     

       9
       15
        
       }

+14 -79

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

···

       1
       1
       -
       import { ExtensionWebExports, WebpackRequireType } from "@moonlight-mod/types";

     

       2
       2
       -
       import extensionsPage from "./ui/extensions";

     

       3
       3
       -
       import configPage from "./ui/config";

     

       1
       1
       +
       import { ExtensionWebExports } from "@moonlight-mod/types";

     

       4
       2
        
       

     

       5
       3
        
       import { CircleXIconSVG, DownloadIconSVG, TrashIconSVG } from "./types";

     

       6
       6
       -
       import ui from "./ui";

     

       7
       7
       -
       

     

       8
       8
       -
       export const pageModules: (require: WebpackRequireType) => Record<

     

       9
       9
       -
         string,

     

       10
       10
       -
         {

     

       11
       11
       -
           name: string;

     

       12
       12
       -
           element: React.FunctionComponent;

     

       13
       13
       -
         }

     

       14
       14
       -
       > = (require) => ({

     

       15
       15
       -
         extensions: {

     

       16
       16
       -
           name: "Extensions",

     

       17
       17
       -
           element: extensionsPage(require)

     

       18
       18
       -
         },

     

       19
       19
       -
         config: {

     

       20
       20
       -
           name: "Config",

     

       21
       21
       -
           element: configPage(require)

     

       22
       22
       -
         }

     

       23
       23
       -
       });

     

       24
       4
        
       

     

       25
       5
        
       export const webpackModules: ExtensionWebExports["webpackModules"] = {

     

       26
       6
        
         stores: {

     
···

       30
       10
        
           ]

     

       31
       11
        
         },

     

       32
       12
        
       

     

       33
       33
       -
         moonbase: {

     

       13
       13
       +
         ui: {

     

       34
       14
        
           dependencies: [

     

       35
       15
        
             { ext: "spacepack", id: "spacepack" },

     

       36
       36
       -
             { ext: "settings", id: "settings" },

     

       37
       16
        
             { ext: "common", id: "react" },

     

       38
       17
        
             { ext: "common", id: "components" },

     

       39
       18
        
             { ext: "moonbase", id: "stores" },

     
···

       44
       23
        
             "removeButtonContainer:",

     

       45
       24
        
             '"Missing channel in Channel.openChannelContextMenu"',

     

       46
       25
        
             ".default.HEADER_BAR"

     

       26
       26
       +
           ]

     

       27
       27
       +
         },

     

       28
       28
       +
       

     

       29
       29
       +
         moonbase: {

     

       30
       30
       +
           dependencies: [

     

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

     

       32
       32
       +
             { ext: "settings", id: "settings" },

     

       33
       33
       +
             { ext: "common", id: "react" },

     

       34
       34
       +
             { ext: "moonbase", id: "ui" }

     

       47
       35
        
           ],

     

       48
       48
       -
           entrypoint: true,

     

       49
       49
       -
           run: (module, exports, require) => {

     

       50
       50
       -
             const settings = require("settings_settings").Settings;

     

       51
       51
       -
             const React = require("common_react");

     

       52
       52
       -
             const spacepack = require("spacepack_spacepack").spacepack;

     

       53
       53
       -
             const { MoonbaseSettingsStore } =

     

       54
       54
       -
               require("moonbase_stores") as typeof import("./webpackModules/stores");

     

       55
       55
       -
       

     

       56
       56
       -
             const addSection = (name: string, element: React.FunctionComponent) => {

     

       57
       57
       -
               settings.addSection(name, name, element, null, -2, {

     

       58
       58
       -
                 stores: [MoonbaseSettingsStore],

     

       59
       59
       -
                 element: () => {

     

       60
       60
       -
                   // Require it here because lazy loading SUX

     

       61
       61
       -
                   const SettingsNotice =

     

       62
       62
       -
                     spacepack.findByCode("onSaveButtonColor")[0].exports.default;

     

       63
       63
       -
                   return (

     

       64
       64
       -
                     <SettingsNotice

     

       65
       65
       -
                       submitting={MoonbaseSettingsStore.submitting}

     

       66
       66
       -
                       onReset={() => {

     

       67
       67
       -
                         MoonbaseSettingsStore.reset();

     

       68
       68
       -
                       }}

     

       69
       69
       -
                       onSave={() => {

     

       70
       70
       -
                         MoonbaseSettingsStore.writeConfig();

     

       71
       71
       -
                       }}

     

       72
       72
       -
                     />

     

       73
       73
       -
                   );

     

       74
       74
       -
                 }

     

       75
       75
       -
               });

     

       76
       76
       -
             };

     

       77
       77
       -
       

     

       78
       78
       -
             if (moonlight.getConfigOption<boolean>("moonbase", "sections")) {

     

       79
       79
       -
               const pages = pageModules(require);

     

       80
       80
       -
       

     

       81
       81
       -
               const { Text } = require("common_components");

     

       82
       82
       -
               const Margins = spacepack.findByCode("marginCenterHorz:")[0].exports;

     

       83
       83
       -
       

     

       84
       84
       -
               settings.addHeader("Moonbase", -2);

     

       85
       85
       -
               for (const page of Object.values(pages)) {

     

       86
       86
       -
                 addSection(page.name, () => (

     

       87
       87
       -
                   <>

     

       88
       88
       -
                     <Text

     

       89
       89
       -
                       className={Margins.marginBottom20}

     

       90
       90
       -
                       variant="heading-lg/semibold"

     

       91
       91
       -
                       tag="h2"

     

       92
       92
       -
                     >

     

       93
       93
       -
                       Extensions

     

       94
       94
       -
                     </Text>

     

       95
       95
       -
                     <page.element />

     

       96
       96
       -
                   </>

     

       97
       97
       -
                 ));

     

       98
       98
       -
               }

     

       99
       99
       -
             } else {

     

       100
       100
       -
               addSection("Moonbase", ui(require));

     

       101
       101
       -
             }

     

       102
       102
       -
           }

     

       36
       36
       +
           entrypoint: true

     

       103
       37
        
         }

     

       104
       38
        
       };

     

       105
       39
        
       

     

       106
       40
        
       export const styles = [

     

       107
       107
       -
         ".moonbase-settings > :first-child { margin-top: 0px; }"

     

       41
       41
       +
         ".moonbase-settings > :first-child { margin-top: 0px; }",

     

       42
       42
       +
         "textarea.moonbase-resizeable  { resize: vertical }"

     

       108
       43
        
       ];

packages/core-extensions/src/moonbase/types.ts

···

       40
       40
        
       

     

       41
       41
        
       export type MoonbaseExtension = {

     

       42
       42
        
         id: string;

     

       43
       43
       +
         uniqueId: number;

     

       43
       44
        
         manifest: ExtensionManifest | RepositoryManifest;

     

       44
       45
        
         source: DetectedExtension["source"];

     

       45
       46
        
         state: ExtensionState;

-157

packages/core-extensions/src/moonbase/ui/config/index.tsx

···

       1
       1
       -
       import { LogLevel, WebpackRequireType } from "@moonlight-mod/types";

     

       2
       2
       -
       import { CircleXIconSVG } from "../../types";

     

       3
       3
       -
       

     

       4
       4
       -
       const logLevels = Object.values(LogLevel).filter(

     

       5
       5
       -
         (v) => typeof v === "string"

     

       6
       6
       -
       ) as string[];

     

       7
       7
       -
       

     

       8
       8
       -
       export default (require: WebpackRequireType) => {

     

       9
       9
       -
         const React = require("common_react");

     

       10
       10
       -
         const spacepack = require("spacepack_spacepack").spacepack;

     

       11
       11
       -
         const CommonComponents = require("common_components");

     

       12
       12
       -
         const {

     

       13
       13
       -
           FormDivider,

     

       14
       14
       -
           FormItem,

     

       15
       15
       -
           FormText,

     

       16
       16
       -
           FormSwitch,

     

       17
       17
       -
           TextInput,

     

       18
       18
       -
           Flex,

     

       19
       19
       -
           Button,

     

       20
       20
       -
           SingleSelect

     

       21
       21
       -
         } = CommonComponents;

     

       22
       22
       -
       

     

       23
       23
       -
         const { MoonbaseSettingsStore } =

     

       24
       24
       -
           require("moonbase_stores") as typeof import("../../webpackModules/stores");

     

       25
       25
       -
       

     

       26
       26
       -
         const FormClasses = spacepack.findByCode("dividerDefault:")[0].exports;

     

       27
       27
       -
         const Margins = spacepack.findByCode("marginCenterHorz:")[0].exports;

     

       28
       28
       -
       

     

       29
       29
       -
         const RemoveButtonClasses = spacepack.findByCode("removeButtonContainer")[0]

     

       30
       30
       -
           .exports;

     

       31
       31
       -
         const CircleXIcon = spacepack.findByCode(CircleXIconSVG)[0].exports.default;

     

       32
       32
       -
         function RemoveEntryButton({ onClick }: { onClick: () => void }) {

     

       33
       33
       -
           const { Tooltip, Clickable } = CommonComponents;

     

       34
       34
       -
           return (

     

       35
       35
       -
             <div className={RemoveButtonClasses.removeButtonContainer}>

     

       36
       36
       -
               <Tooltip text="Remove entry" position="top">

     

       37
       37
       -
                 {(props: any) => (

     

       38
       38
       -
                   <Clickable

     

       39
       39
       -
                     {...props}

     

       40
       40
       -
                     className={RemoveButtonClasses.removeButton}

     

       41
       41
       -
                     onClick={onClick}

     

       42
       42
       -
                   >

     

       43
       43
       -
                     <CircleXIcon width={24} height={24} />

     

       44
       44
       -
                   </Clickable>

     

       45
       45
       -
                 )}

     

       46
       46
       -
               </Tooltip>

     

       47
       47
       -
             </div>

     

       48
       48
       -
           );

     

       49
       49
       -
         }

     

       50
       50
       -
       

     

       51
       51
       -
         function ArrayFormItem({

     

       52
       52
       -
           config

     

       53
       53
       -
         }: {

     

       54
       54
       -
           config: "repositories" | "devSearchPaths";

     

       55
       55
       -
         }) {

     

       56
       56
       -
           const items = MoonbaseSettingsStore.getConfigOption(config) ?? [];

     

       57
       57
       -
           return (

     

       58
       58
       -
             <Flex

     

       59
       59
       -
               style={{

     

       60
       60
       -
                 gap: "20px"

     

       61
       61
       -
               }}

     

       62
       62
       -
               direction={Flex.Direction.VERTICAL}

     

       63
       63
       -
             >

     

       64
       64
       -
               {items.map((val, i) => (

     

       65
       65
       -
                 <div

     

       66
       66
       -
                   key={i}

     

       67
       67
       -
                   style={{

     

       68
       68
       -
                     display: "grid",

     

       69
       69
       -
                     height: "32px",

     

       70
       70
       -
                     gap: "8px",

     

       71
       71
       -
                     gridTemplateColumns: "1fr 32px",

     

       72
       72
       -
                     alignItems: "center"

     

       73
       73
       -
                   }}

     

       74
       74
       -
                 >

     

       75
       75
       -
                   <TextInput

     

       76
       76
       -
                     size={TextInput.Sizes.DEFAULT}

     

       77
       77
       -
                     value={val}

     

       78
       78
       -
                     onChange={(newVal: string) => {

     

       79
       79
       -
                       items[i] = newVal;

     

       80
       80
       -
                       MoonbaseSettingsStore.setConfigOption(config, items);

     

       81
       81
       -
                     }}

     

       82
       82
       -
                   />

     

       83
       83
       -
                   <RemoveEntryButton

     

       84
       84
       -
                     onClick={() => {

     

       85
       85
       -
                       items.splice(i, 1);

     

       86
       86
       -
                       MoonbaseSettingsStore.setConfigOption(config, items);

     

       87
       87
       -
                     }}

     

       88
       88
       -
                   />

     

       89
       89
       -
                 </div>

     

       90
       90
       -
               ))}

     

       91
       91
       -
       

     

       92
       92
       -
               <Button

     

       93
       93
       -
                 look={Button.Looks.FILLED}

     

       94
       94
       -
                 color={Button.Colors.GREEN}

     

       95
       95
       -
                 size={Button.Sizes.SMALL}

     

       96
       96
       -
                 style={{

     

       97
       97
       -
                   marginTop: "10px"

     

       98
       98
       -
                 }}

     

       99
       99
       -
                 onClick={() => {

     

       100
       100
       -
                   items.push("");

     

       101
       101
       -
                   MoonbaseSettingsStore.setConfigOption(config, items);

     

       102
       102
       -
                 }}

     

       103
       103
       -
               >

     

       104
       104
       -
                 Add new entry

     

       105
       105
       -
               </Button>

     

       106
       106
       -
             </Flex>

     

       107
       107
       -
           );

     

       108
       108
       -
         }

     

       109
       109
       -
       

     

       110
       110
       -
         return function ConfigPage() {

     

       111
       111
       -
           return (

     

       112
       112
       -
             <>

     

       113
       113
       -
               <FormItem title="Repositories">

     

       114
       114
       -
                 <FormText className={Margins.marginBottom4}>

     

       115
       115
       -
                   A list of remote repositories to display extensions from

     

       116
       116
       -
                 </FormText>

     

       117
       117
       -
                 <ArrayFormItem config="repositories" />

     

       118
       118
       -
               </FormItem>

     

       119
       119
       -
               <FormDivider className={FormClasses.dividerDefault} />

     

       120
       120
       -
               <FormItem

     

       121
       121
       -
                 title="Extension search paths"

     

       122
       122
       -
                 className={Margins.marginTop20}

     

       123
       123
       -
               >

     

       124
       124
       -
                 <FormText className={Margins.marginBottom4}>

     

       125
       125
       -
                   A list of local directories to search for built extensions

     

       126
       126
       -
                 </FormText>

     

       127
       127
       -
                 <ArrayFormItem config="devSearchPaths" />

     

       128
       128
       -
               </FormItem>

     

       129
       129
       -
               <FormDivider className={FormClasses.dividerDefault} />

     

       130
       130
       -
               <FormSwitch

     

       131
       131
       -
                 className={Margins.marginTop20}

     

       132
       132
       -
                 value={MoonbaseSettingsStore.getConfigOption("patchAll")}

     

       133
       133
       -
                 onChange={(value: boolean) => {

     

       134
       134
       -
                   MoonbaseSettingsStore.setConfigOption("patchAll", value);

     

       135
       135
       -
                 }}

     

       136
       136
       -
                 note="Wraps every webpack module in a function, separating them in DevTools"

     

       137
       137
       -
               >

     

       138
       138
       -
                 Patch all

     

       139
       139
       -
               </FormSwitch>

     

       140
       140
       -
               <FormItem title="Log level">

     

       141
       141
       -
                 <SingleSelect

     

       142
       142
       -
                   autofocus={false}

     

       143
       143
       -
                   clearable={false}

     

       144
       144
       -
                   value={MoonbaseSettingsStore.getConfigOption("loggerLevel")}

     

       145
       145
       -
                   options={logLevels.map((o) => ({

     

       146
       146
       -
                     value: o.toLowerCase(),

     

       147
       147
       -
                     label: o[0] + o.slice(1).toLowerCase()

     

       148
       148
       -
                   }))}

     

       149
       149
       -
                   onChange={(v) =>

     

       150
       150
       -
                     MoonbaseSettingsStore.setConfigOption("loggerLevel", v)

     

       151
       151
       -
                   }

     

       152
       152
       -
                 />

     

       153
       153
       -
               </FormItem>

     

       154
       154
       -
             </>

     

       155
       155
       -
           );

     

       156
       156
       -
         };

     

       157
       157
       -
       };

-223

packages/core-extensions/src/moonbase/ui/extensions/card.tsx

···

       1
       1
       -
       import WebpackRequire from "@moonlight-mod/types/discord/require";

     

       2
       2
       -
       import {

     

       3
       3
       -
         DangerIconSVG,

     

       4
       4
       -
         DownloadIconSVG,

     

       5
       5
       -
         ExtensionState,

     

       6
       6
       -
         TrashIconSVG

     

       7
       7
       -
       } from "../../types";

     

       8
       8
       -
       import { ExtensionLoadSource } from "@moonlight-mod/types";

     

       9
       9
       -
       import info from "./info";

     

       10
       10
       -
       import settings from "./settings";

     

       11
       11
       -
       

     

       12
       12
       -
       export enum ExtensionPage {

     

       13
       13
       -
         Info,

     

       14
       14
       -
         Description,

     

       15
       15
       -
         Settings

     

       16
       16
       -
       }

     

       17
       17
       -
       

     

       18
       18
       -
       export default (require: typeof WebpackRequire) => {

     

       19
       19
       -
         const React = require("common_react");

     

       20
       20
       -
         const spacepack = require("spacepack_spacepack").spacepack;

     

       21
       21
       -
         const CommonComponents = require("common_components");

     

       22
       22
       -
         const Flux = require("common_flux");

     

       23
       23
       -
       

     

       24
       24
       -
         const { ExtensionInfo } = info(require);

     

       25
       25
       -
         const Settings = settings(require);

     

       26
       26
       -
         const { MoonbaseSettingsStore } =

     

       27
       27
       -
           require("moonbase_stores") as typeof import("../../webpackModules/stores");

     

       28
       28
       -
       

     

       29
       29
       -
         const UserProfileClasses = spacepack.findByCode(

     

       30
       30
       -
           "tabBarContainer",

     

       31
       31
       -
           "topSection"

     

       32
       32
       -
         )[0].exports;

     

       33
       33
       -
       

     

       34
       34
       -
         const DownloadIcon =

     

       35
       35
       -
           spacepack.findByCode(DownloadIconSVG)[0].exports.DownloadIcon;

     

       36
       36
       -
         const TrashIcon = spacepack.findByCode(TrashIconSVG)[0].exports.default;

     

       37
       37
       -
         const DangerIcon =

     

       38
       38
       -
           spacepack.findByCode(DangerIconSVG)[0].exports.CircleExclamationPointIcon;

     

       39
       39
       -
       

     

       40
       40
       -
         const PanelButton =

     

       41
       41
       -
           spacepack.findByCode("Masks.PANEL_BUTTON")[0].exports.default;

     

       42
       42
       -
       

     

       43
       43
       -
         return function ExtensionCard({ id }: { id: string }) {

     

       44
       44
       -
           const [tab, setTab] = React.useState(ExtensionPage.Info);

     

       45
       45
       -
           const [restartNeeded, setRestartNeeded] = React.useState(false);

     

       46
       46
       -
       

     

       47
       47
       -
           const { ext, enabled, busy, update } = Flux.useStateFromStores(

     

       48
       48
       -
             [MoonbaseSettingsStore],

     

       49
       49
       -
             () => {

     

       50
       50
       -
               return {

     

       51
       51
       -
                 ext: MoonbaseSettingsStore.getExtension(id),

     

       52
       52
       -
                 enabled: MoonbaseSettingsStore.getExtensionEnabled(id),

     

       53
       53
       -
                 busy: MoonbaseSettingsStore.busy,

     

       54
       54
       -
                 update: MoonbaseSettingsStore.getExtensionUpdate(id)

     

       55
       55
       -
               };

     

       56
       56
       -
             }

     

       57
       57
       -
           );

     

       58
       58
       -
       

     

       59
       59
       -
           // Why it work like that :sob:

     

       60
       60
       -
           if (ext == null) return <></>;

     

       61
       61
       -
       

     

       62
       62
       -
           const {

     

       63
       63
       -
             Card,

     

       64
       64
       -
             CardClasses,

     

       65
       65
       -
             Flex,

     

       66
       66
       -
             Text,

     

       67
       67
       -
             MarkdownParser,

     

       68
       68
       -
             Switch,

     

       69
       69
       -
             TabBar,

     

       70
       70
       -
             Button

     

       71
       71
       -
           } = CommonComponents;

     

       72
       72
       -
       

     

       73
       73
       -
           const tagline = ext.manifest?.meta?.tagline;

     

       74
       74
       -
           const settings = ext.manifest?.settings;

     

       75
       75
       -
           const description = ext.manifest?.meta?.description;

     

       76
       76
       -
       

     

       77
       77
       -
           return (

     

       78
       78
       -
             <Card editable={true} className={CardClasses.card}>

     

       79
       79
       -
               <div className={CardClasses.cardHeader}>

     

       80
       80
       -
                 <Flex direction={Flex.Direction.VERTICAL}>

     

       81
       81
       -
                   <Flex direction={Flex.Direction.HORIZONTAL}>

     

       82
       82
       -
                     <Text variant="text-md/semibold">

     

       83
       83
       -
                       {ext.manifest?.meta?.name ?? ext.id}

     

       84
       84
       -
                     </Text>

     

       85
       85
       -
                   </Flex>

     

       86
       86
       -
       

     

       87
       87
       -
                   {tagline != null && (

     

       88
       88
       -
                     <Text variant="text-sm/normal">

     

       89
       89
       -
                       {MarkdownParser.parse(tagline)}

     

       90
       90
       -
                     </Text>

     

       91
       91
       -
                   )}

     

       92
       92
       -
                 </Flex>

     

       93
       93
       -
       

     

       94
       94
       -
                 <Flex

     

       95
       95
       -
                   direction={Flex.Direction.HORIZONTAL}

     

       96
       96
       -
                   align={Flex.Align.END}

     

       97
       97
       -
                   justify={Flex.Justify.END}

     

       98
       98
       -
                 >

     

       99
       99
       -
                   {ext.state === ExtensionState.NotDownloaded ? (

     

       100
       100
       -
                     <Button

     

       101
       101
       -
                       color={Button.Colors.BRAND}

     

       102
       102
       -
                       submitting={busy}

     

       103
       103
       -
                       onClick={() => {

     

       104
       104
       -
                         MoonbaseSettingsStore.installExtension(id);

     

       105
       105
       -
                       }}

     

       106
       106
       -
                     >

     

       107
       107
       -
                       Install

     

       108
       108
       -
                     </Button>

     

       109
       109
       -
                   ) : (

     

       110
       110
       -
                     <div

     

       111
       111
       -
                       // too lazy to learn how <Flex /> works lmao

     

       112
       112
       -
                       style={{

     

       113
       113
       -
                         display: "flex",

     

       114
       114
       -
                         alignItems: "center",

     

       115
       115
       -
                         gap: "1rem"

     

       116
       116
       -
                       }}

     

       117
       117
       -
                     >

     

       118
       118
       -
                       {ext.source.type === ExtensionLoadSource.Normal && (

     

       119
       119
       -
                         <PanelButton

     

       120
       120
       -
                           icon={TrashIcon}

     

       121
       121
       -
                           tooltipText="Delete"

     

       122
       122
       -
                           onClick={() => {

     

       123
       123
       -
                             MoonbaseSettingsStore.deleteExtension(id);

     

       124
       124
       -
                           }}

     

       125
       125
       -
                         />

     

       126
       126
       -
                       )}

     

       127
       127
       -
       

     

       128
       128
       -
                       {update !== null && (

     

       129
       129
       -
                         <PanelButton

     

       130
       130
       -
                           icon={DownloadIcon}

     

       131
       131
       -
                           tooltipText="Update"

     

       132
       132
       -
                           onClick={() => {

     

       133
       133
       -
                             MoonbaseSettingsStore.installExtension(id);

     

       134
       134
       -
                           }}

     

       135
       135
       -
                         />

     

       136
       136
       -
                       )}

     

       137
       137
       -
       

     

       138
       138
       -
                       {restartNeeded && (

     

       139
       139
       -
                         <PanelButton

     

       140
       140
       -
                           icon={() => (

     

       141
       141
       -
                             <DangerIcon

     

       142
       142
       -
                               color={CommonComponents.tokens.colors.STATUS_DANGER}

     

       143
       143
       -
                             />

     

       144
       144
       -
                           )}

     

       145
       145
       -
                           onClick={() => window.location.reload()}

     

       146
       146
       -
                           tooltipText="You will need to reload/restart your client for this extension to work properly."

     

       147
       147
       -
                         />

     

       148
       148
       -
                       )}

     

       149
       149
       -
       

     

       150
       150
       -
                       <Switch

     

       151
       151
       -
                         checked={enabled}

     

       152
       152
       -
                         onChange={() => {

     

       153
       153
       -
                           setRestartNeeded(true);

     

       154
       154
       -
                           MoonbaseSettingsStore.setExtensionEnabled(id, !enabled);

     

       155
       155
       -
                         }}

     

       156
       156
       -
                       />

     

       157
       157
       -
                     </div>

     

       158
       158
       -
                   )}

     

       159
       159
       -
                 </Flex>

     

       160
       160
       -
               </div>

     

       161
       161
       -
       

     

       162
       162
       -
               <div className={UserProfileClasses.body}>

     

       163
       163
       -
                 {(description != null || settings != null) && (

     

       164
       164
       -
                   <div

     

       165
       165
       -
                     className={UserProfileClasses.tabBarContainer}

     

       166
       166
       -
                     style={{

     

       167
       167
       -
                       padding: "0 10px"

     

       168
       168
       -
                     }}

     

       169
       169
       -
                   >

     

       170
       170
       -
                     <TabBar

     

       171
       171
       -
                       selectedItem={tab}

     

       172
       172
       -
                       type="top"

     

       173
       173
       -
                       onItemSelect={setTab}

     

       174
       174
       -
                       className={UserProfileClasses.tabBar}

     

       175
       175
       -
                     >

     

       176
       176
       -
                       <TabBar.Item

     

       177
       177
       -
                         className={UserProfileClasses.tabBarItem}

     

       178
       178
       -
                         id={ExtensionPage.Info}

     

       179
       179
       -
                       >

     

       180
       180
       -
                         Info

     

       181
       181
       -
                       </TabBar.Item>

     

       182
       182
       -
       

     

       183
       183
       -
                       {description != null && (

     

       184
       184
       -
                         <TabBar.Item

     

       185
       185
       -
                           className={UserProfileClasses.tabBarItem}

     

       186
       186
       -
                           id={ExtensionPage.Description}

     

       187
       187
       -
                         >

     

       188
       188
       -
                           Description

     

       189
       189
       -
                         </TabBar.Item>

     

       190
       190
       -
                       )}

     

       191
       191
       -
       

     

       192
       192
       -
                       {settings != null && (

     

       193
       193
       -
                         <TabBar.Item

     

       194
       194
       -
                           className={UserProfileClasses.tabBarItem}

     

       195
       195
       -
                           id={ExtensionPage.Settings}

     

       196
       196
       -
                         >

     

       197
       197
       -
                           Settings

     

       198
       198
       -
                         </TabBar.Item>

     

       199
       199
       -
                       )}

     

       200
       200
       -
                     </TabBar>

     

       201
       201
       -
                   </div>

     

       202
       202
       -
                 )}

     

       203
       203
       -
       

     

       204
       204
       -
                 <Flex

     

       205
       205
       -
                   justify={Flex.Justify.START}

     

       206
       206
       -
                   wrap={Flex.Wrap.WRAP}

     

       207
       207
       -
                   style={{

     

       208
       208
       -
                     padding: "16px 16px"

     

       209
       209
       -
                   }}

     

       210
       210
       -
                 >

     

       211
       211
       -
                   {tab === ExtensionPage.Info && <ExtensionInfo ext={ext} />}

     

       212
       212
       -
                   {tab === ExtensionPage.Description && (

     

       213
       213
       -
                     <Text variant="text-md/normal">

     

       214
       214
       -
                       {MarkdownParser.parse(description ?? "*No description*")}

     

       215
       215
       -
                     </Text>

     

       216
       216
       -
                   )}

     

       217
       217
       -
                   {tab === ExtensionPage.Settings && <Settings ext={ext} />}

     

       218
       218
       -
                 </Flex>

     

       219
       219
       -
               </div>

     

       220
       220
       -
             </Card>

     

       221
       221
       -
           );

     

       222
       222
       -
         };

     

       223
       223
       -
       };

-373

packages/core-extensions/src/moonbase/ui/extensions/filterBar.tsx

···

       1
       1
       -
       import { WebpackRequireType } from "@moonlight-mod/types";

     

       2
       2
       -
       import { tagNames } from "./info";

     

       3
       3
       -
       import {

     

       4
       4
       -
         ArrowsUpDownIconSVG,

     

       5
       5
       -
         ChevronSmallDownIconSVG,

     

       6
       6
       -
         ChevronSmallUpIconSVG

     

       7
       7
       -
       } from "../../types";

     

       8
       8
       -
       

     

       9
       9
       -
       export enum Filter {

     

       10
       10
       -
         Core = 1 << 0,

     

       11
       11
       -
         Normal = 1 << 1,

     

       12
       12
       -
         Developer = 1 << 2,

     

       13
       13
       -
         Enabled = 1 << 3,

     

       14
       14
       -
         Disabled = 1 << 4,

     

       15
       15
       -
         Installed = 1 << 5,

     

       16
       16
       -
         Repository = 1 << 6

     

       17
       17
       -
       }

     

       18
       18
       -
       export const defaultFilter = ~(~0 << 7);

     

       19
       19
       -
       

     

       20
       20
       -
       export default async (require: WebpackRequireType) => {

     

       21
       21
       -
         const spacepack = require("spacepack_spacepack").spacepack;

     

       22
       22
       -
         const React = require("common_react");

     

       23
       23
       -
         const Flux = require("common_flux");

     

       24
       24
       -
         const { WindowStore } = require("common_stores");

     

       25
       25
       -
       

     

       26
       26
       -
         const {

     

       27
       27
       -
           Button,

     

       28
       28
       -
           Text,

     

       29
       29
       -
           Heading,

     

       30
       30
       -
           Popout,

     

       31
       31
       -
           Dialog

     

       32
       32
       -
         } = require("common_components");

     

       33
       33
       -
       

     

       34
       34
       -
         const channelModule =

     

       35
       35
       -
           require.m[

     

       36
       36
       -
             spacepack.findByCode(

     

       37
       37
       -
               '"Missing channel in Channel.openChannelContextMenu"'

     

       38
       38
       -
             )[0].id

     

       39
       39
       -
           ].toString();

     

       40
       40
       -
         const moduleId = channelModule.match(/webpackId:"(.+?)"/)![1];

     

       41
       41
       -
         await require.el(moduleId);

     

       42
       42
       -
       

     

       43
       43
       -
         const Margins = spacepack.findByCode("marginCenterHorz:")[0].exports;

     

       44
       44
       -
         const SortMenuClasses = spacepack.findByCode("container:", "clearText:")[0]

     

       45
       45
       -
           .exports;

     

       46
       46
       -
         const FilterDialogClasses = spacepack.findByCode(

     

       47
       47
       -
           "countContainer:",

     

       48
       48
       -
           "tagContainer:"

     

       49
       49
       -
         )[0].exports;

     

       50
       50
       -
         const FilterBarClasses = spacepack.findByCode("tagsButtonWithCount:")[0]

     

       51
       51
       -
           .exports;

     

       52
       52
       -
       

     

       53
       53
       -
         const TagItem = spacepack.findByCode("IncreasedActivityForumTagPill:")[0]

     

       54
       54
       -
           .exports.default;

     

       55
       55
       -
       

     

       56
       56
       -
         const ChevronSmallDownIcon = spacepack.findByCode(ChevronSmallDownIconSVG)[0]

     

       57
       57
       -
           .exports.default;

     

       58
       58
       -
         const ChevronSmallUpIcon = spacepack.findByCode(ChevronSmallUpIconSVG)[0]

     

       59
       59
       -
           .exports.default;

     

       60
       60
       -
         const ArrowsUpDownIcon =

     

       61
       61
       -
           spacepack.findByCode(ArrowsUpDownIconSVG)[0].exports.default;

     

       62
       62
       -
       

     

       63
       63
       -
         function toggleTag(

     

       64
       64
       -
           selectedTags: Set<string>,

     

       65
       65
       -
           setSelectedTags: (tags: Set<string>) => void,

     

       66
       66
       -
           tag: string

     

       67
       67
       -
         ) {

     

       68
       68
       -
           const newState = new Set(selectedTags);

     

       69
       69
       -
           if (newState.has(tag)) newState.delete(tag);

     

       70
       70
       -
           else newState.add(tag);

     

       71
       71
       -
           setSelectedTags(newState);

     

       72
       72
       -
         }

     

       73
       73
       -
       

     

       74
       74
       -
         function FilterButtonPopout({

     

       75
       75
       -
           filter,

     

       76
       76
       -
           setFilter,

     

       77
       77
       -
           closePopout

     

       78
       78
       -
         }: {

     

       79
       79
       -
           filter: Filter;

     

       80
       80
       -
           setFilter: (filter: Filter) => void;

     

       81
       81
       -
           closePopout: () => void;

     

       82
       82
       -
         }) {

     

       83
       83
       -
           const {

     

       84
       84
       -
             Menu,

     

       85
       85
       -
             MenuItem,

     

       86
       86
       -
             MenuGroup,

     

       87
       87
       -
             MenuCheckboxItem

     

       88
       88
       -
           } = require("common_components");

     

       89
       89
       -
       

     

       90
       90
       -
           const toggleFilter = (set: Filter) =>

     

       91
       91
       -
             setFilter(filter & set ? filter & ~set : filter | set);

     

       92
       92
       -
       

     

       93
       93
       -
           return (

     

       94
       94
       -
             <div className={SortMenuClasses.container}>

     

       95
       95
       -
               <Menu navId="sort-filter" hideScrollbar={true} onClose={closePopout}>

     

       96
       96
       -
                 <MenuGroup label="Type">

     

       97
       97
       -
                   <MenuCheckboxItem

     

       98
       98
       -
                     id="t-core"

     

       99
       99
       -
                     label="Core"

     

       100
       100
       -
                     checked={filter & Filter.Core}

     

       101
       101
       -
                     action={() => toggleFilter(Filter.Core)}

     

       102
       102
       -
                   />

     

       103
       103
       -
                   <MenuCheckboxItem

     

       104
       104
       -
                     id="t-normal"

     

       105
       105
       -
                     label="Normal"

     

       106
       106
       -
                     checked={filter & Filter.Normal}

     

       107
       107
       -
                     action={() => toggleFilter(Filter.Normal)}

     

       108
       108
       -
                   />

     

       109
       109
       -
                   <MenuCheckboxItem

     

       110
       110
       -
                     id="t-developer"

     

       111
       111
       -
                     label="Developer"

     

       112
       112
       -
                     checked={filter & Filter.Developer}

     

       113
       113
       -
                     action={() => toggleFilter(Filter.Developer)}

     

       114
       114
       -
                   />

     

       115
       115
       -
                 </MenuGroup>

     

       116
       116
       -
                 <MenuGroup label="State">

     

       117
       117
       -
                   <MenuCheckboxItem

     

       118
       118
       -
                     id="s-enabled"

     

       119
       119
       -
                     label="Enabled"

     

       120
       120
       -
                     checked={filter & Filter.Enabled}

     

       121
       121
       -
                     action={() => toggleFilter(Filter.Enabled)}

     

       122
       122
       -
                   />

     

       123
       123
       -
                   <MenuCheckboxItem

     

       124
       124
       -
                     id="s-disabled"

     

       125
       125
       -
                     label="Disabled"

     

       126
       126
       -
                     checked={filter & Filter.Disabled}

     

       127
       127
       -
                     action={() => toggleFilter(Filter.Disabled)}

     

       128
       128
       -
                   />

     

       129
       129
       -
                 </MenuGroup>

     

       130
       130
       -
                 <MenuGroup label="Location">

     

       131
       131
       -
                   <MenuCheckboxItem

     

       132
       132
       -
                     id="l-installed"

     

       133
       133
       -
                     label="Installed"

     

       134
       134
       -
                     checked={filter & Filter.Installed}

     

       135
       135
       -
                     action={() => toggleFilter(Filter.Installed)}

     

       136
       136
       -
                   />

     

       137
       137
       -
                   <MenuCheckboxItem

     

       138
       138
       -
                     id="l-repository"

     

       139
       139
       -
                     label="Repository"

     

       140
       140
       -
                     checked={filter & Filter.Repository}

     

       141
       141
       -
                     action={() => toggleFilter(Filter.Repository)}

     

       142
       142
       -
                   />

     

       143
       143
       -
                 </MenuGroup>

     

       144
       144
       -
                 <MenuGroup>

     

       145
       145
       -
                   <MenuItem

     

       146
       146
       -
                     id="reset-all"

     

       147
       147
       -
                     className={SortMenuClasses.clearText}

     

       148
       148
       -
                     label={

     

       149
       149
       -
                       <Text variant="text-sm/medium" color="none">

     

       150
       150
       -
                         Reset to default

     

       151
       151
       -
                       </Text>

     

       152
       152
       -
                     }

     

       153
       153
       -
                     action={() => {

     

       154
       154
       -
                       setFilter(defaultFilter);

     

       155
       155
       -
                       closePopout();

     

       156
       156
       -
                     }}

     

       157
       157
       -
                   />

     

       158
       158
       -
                 </MenuGroup>

     

       159
       159
       -
               </Menu>

     

       160
       160
       -
             </div>

     

       161
       161
       -
           );

     

       162
       162
       -
         }

     

       163
       163
       -
       

     

       164
       164
       -
         function TagButtonPopout({

     

       165
       165
       -
           selectedTags,

     

       166
       166
       -
           setSelectedTags,

     

       167
       167
       -
           setPopoutRef,

     

       168
       168
       -
           closePopout

     

       169
       169
       -
         }: any) {

     

       170
       170
       -
           return (

     

       171
       171
       -
             <Dialog ref={setPopoutRef} className={FilterDialogClasses.container}>

     

       172
       172
       -
               <div className={FilterDialogClasses.header}>

     

       173
       173
       -
                 <div className={FilterDialogClasses.headerLeft}>

     

       174
       174
       -
                   <Heading

     

       175
       175
       -
                     color="interactive-normal"

     

       176
       176
       -
                     variant="text-xs/bold"

     

       177
       177
       -
                     className={FilterDialogClasses.headerText}

     

       178
       178
       -
                   >

     

       179
       179
       -
                     Select tags

     

       180
       180
       -
                   </Heading>

     

       181
       181
       -
                   <div className={FilterDialogClasses.countContainer}>

     

       182
       182
       -
                     <Text

     

       183
       183
       -
                       className={FilterDialogClasses.countText}

     

       184
       184
       -
                       color="none"

     

       185
       185
       -
                       variant="text-xs/medium"

     

       186
       186
       -
                     >

     

       187
       187
       -
                       {selectedTags.size}

     

       188
       188
       -
                     </Text>

     

       189
       189
       -
                   </div>

     

       190
       190
       -
                 </div>

     

       191
       191
       -
               </div>

     

       192
       192
       -
               <div className={FilterDialogClasses.tagContainer}>

     

       193
       193
       -
                 {Object.keys(tagNames).map((tag) => (

     

       194
       194
       -
                   <TagItem

     

       195
       195
       -
                     key={tag}

     

       196
       196
       -
                     className={FilterDialogClasses.tag}

     

       197
       197
       -
                     tag={{ name: tagNames[tag as keyof typeof tagNames] }}

     

       198
       198
       -
                     onClick={() => toggleTag(selectedTags, setSelectedTags, tag)}

     

       199
       199
       -
                     selected={selectedTags.has(tag)}

     

       200
       200
       -
                   />

     

       201
       201
       -
                 ))}

     

       202
       202
       -
               </div>

     

       203
       203
       -
               <div className={FilterDialogClasses.separator} />

     

       204
       204
       -
               <Button

     

       205
       205
       -
                 look={Button.Looks.LINK}

     

       206
       206
       -
                 size={Button.Sizes.MIN}

     

       207
       207
       -
                 color={Button.Colors.CUSTOM}

     

       208
       208
       -
                 className={FilterDialogClasses.clear}

     

       209
       209
       -
                 onClick={() => {

     

       210
       210
       -
                   setSelectedTags(new Set());

     

       211
       211
       -
                   closePopout();

     

       212
       212
       -
                 }}

     

       213
       213
       -
               >

     

       214
       214
       -
                 <Text variant="text-sm/medium" color="text-link">

     

       215
       215
       -
                   Clear all

     

       216
       216
       -
                 </Text>

     

       217
       217
       -
               </Button>

     

       218
       218
       -
             </Dialog>

     

       219
       219
       -
           );

     

       220
       220
       -
         }

     

       221
       221
       -
       

     

       222
       222
       -
         return function FilterBar({

     

       223
       223
       -
           filter,

     

       224
       224
       -
           setFilter,

     

       225
       225
       -
           selectedTags,

     

       226
       226
       -
           setSelectedTags

     

       227
       227
       -
         }: {

     

       228
       228
       -
           filter: Filter;

     

       229
       229
       -
           setFilter: (filter: Filter) => void;

     

       230
       230
       -
           selectedTags: Set<string>;

     

       231
       231
       -
           setSelectedTags: (tags: Set<string>) => void;

     

       232
       232
       -
         }) {

     

       233
       233
       -
           const windowSize = Flux.useStateFromStores([WindowStore], () =>

     

       234
       234
       -
             WindowStore.windowSize()

     

       235
       235
       -
           );

     

       236
       236
       -
       

     

       237
       237
       -
           const tagsContainer = React.useRef<HTMLDivElement>(null);

     

       238
       238
       -
           const tagListInner = React.useRef<HTMLDivElement>(null);

     

       239
       239
       -
           const [tagsButtonOffset, setTagsButtonOffset] = React.useState(0);

     

       240
       240
       -
           React.useLayoutEffect(() => {

     

       241
       241
       -
             if (tagsContainer.current === null || tagListInner.current === null)

     

       242
       242
       -
               return;

     

       243
       243
       -
             const { left: containerX, top: containerY } =

     

       244
       244
       -
               tagsContainer.current.getBoundingClientRect();

     

       245
       245
       -
             let offset = 0;

     

       246
       246
       -
             for (const child of tagListInner.current.children) {

     

       247
       247
       -
               const {

     

       248
       248
       -
                 right: childX,

     

       249
       249
       -
                 top: childY,

     

       250
       250
       -
                 height

     

       251
       251
       -
               } = child.getBoundingClientRect();

     

       252
       252
       -
               if (childY - containerY > height) break;

     

       253
       253
       -
               const newOffset = childX - containerX;

     

       254
       254
       -
               if (newOffset > offset) {

     

       255
       255
       -
                 offset = newOffset;

     

       256
       256
       -
               }

     

       257
       257
       -
             }

     

       258
       258
       -
             setTagsButtonOffset(offset);

     

       259
       259
       -
           }, [windowSize]);

     

       260
       260
       -
       

     

       261
       261
       -
           return (

     

       262
       262
       -
             <div

     

       263
       263
       -
               ref={tagsContainer}

     

       264
       264
       -
               style={{

     

       265
       265
       -
                 paddingTop: "12px"

     

       266
       266
       -
               }}

     

       267
       267
       -
               className={`${FilterBarClasses.tagsContainer} ${Margins.marginBottom8}`}

     

       268
       268
       -
             >

     

       269
       269
       -
               <Popout

     

       270
       270
       -
                 renderPopout={({ closePopout }: any) => (

     

       271
       271
       -
                   <FilterButtonPopout

     

       272
       272
       -
                     filter={filter}

     

       273
       273
       -
                     setFilter={setFilter}

     

       274
       274
       -
                     closePopout={closePopout}

     

       275
       275
       -
                   />

     

       276
       276
       -
                 )}

     

       277
       277
       -
                 position="bottom"

     

       278
       278
       -
                 align="left"

     

       279
       279
       -
               >

     

       280
       280
       -
                 {(props: any, { isShown }: { isShown: boolean }) => (

     

       281
       281
       -
                   <Button

     

       282
       282
       -
                     {...props}

     

       283
       283
       -
                     size={Button.Sizes.MIN}

     

       284
       284
       -
                     color={Button.Colors.CUSTOM}

     

       285
       285
       -
                     className={FilterBarClasses.sortDropdown}

     

       286
       286
       -
                     innerClassName={FilterBarClasses.sortDropdownInner}

     

       287
       287
       -
                   >

     

       288
       288
       -
                     <ArrowsUpDownIcon />

     

       289
       289
       -
                     <Text

     

       290
       290
       -
                       className={FilterBarClasses.sortDropdownText}

     

       291
       291
       -
                       variant="text-sm/medium"

     

       292
       292
       -
                       color="interactive-normal"

     

       293
       293
       -
                     >

     

       294
       294
       -
                       Sort & filter

     

       295
       295
       -
                     </Text>

     

       296
       296
       -
                     {isShown ? (

     

       297
       297
       -
                       <ChevronSmallUpIcon size={20} />

     

       298
       298
       -
                     ) : (

     

       299
       299
       -
                       <ChevronSmallDownIcon size={20} />

     

       300
       300
       -
                     )}

     

       301
       301
       -
                   </Button>

     

       302
       302
       -
                 )}

     

       303
       303
       -
               </Popout>

     

       304
       304
       -
               <div className={FilterBarClasses.divider} />

     

       305
       305
       -
               <div className={FilterBarClasses.tagList}>

     

       306
       306
       -
                 <div ref={tagListInner} className={FilterBarClasses.tagListInner}>

     

       307
       307
       -
                   {Object.keys(tagNames).map((tag) => (

     

       308
       308
       -
                     <TagItem

     

       309
       309
       -
                       key={tag}

     

       310
       310
       -
                       className={FilterBarClasses.tag}

     

       311
       311
       -
                       tag={{ name: tagNames[tag as keyof typeof tagNames] }}

     

       312
       312
       -
                       onClick={() => toggleTag(selectedTags, setSelectedTags, tag)}

     

       313
       313
       -
                       selected={selectedTags.has(tag)}

     

       314
       314
       -
                     />

     

       315
       315
       -
                   ))}

     

       316
       316
       -
                 </div>

     

       317
       317
       -
               </div>

     

       318
       318
       -
               <Popout

     

       319
       319
       -
                 renderPopout={({ setPopoutRef, closePopout }: any) => (

     

       320
       320
       -
                   <TagButtonPopout

     

       321
       321
       -
                     selectedTags={selectedTags}

     

       322
       322
       -
                     setSelectedTags={setSelectedTags}

     

       323
       323
       -
                     setPopoutRef={setPopoutRef}

     

       324
       324
       -
                     closePopout={closePopout}

     

       325
       325
       -
                   />

     

       326
       326
       -
                 )}

     

       327
       327
       -
                 position="bottom"

     

       328
       328
       -
                 align="right"

     

       329
       329
       -
               >

     

       330
       330
       -
                 {(props: any, { isShown }: { isShown: boolean }) => (

     

       331
       331
       -
                   <Button

     

       332
       332
       -
                     {...props}

     

       333
       333
       -
                     size={Button.Sizes.MIN}

     

       334
       334
       -
                     color={Button.Colors.CUSTOM}

     

       335
       335
       -
                     style={{

     

       336
       336
       -
                       left: tagsButtonOffset

     

       337
       337
       -
                     }}

     

       338
       338
       -
                     // TODO: Use Discord's class name utility

     

       339
       339
       -
                     className={`${FilterBarClasses.tagsButton} ${

     

       340
       340
       -
                       selectedTags.size > 0

     

       341
       341
       -
                         ? FilterBarClasses.tagsButtonWithCount

     

       342
       342
       -
                         : ""

     

       343
       343
       -
                     }`}

     

       344
       344
       -
                     innerClassName={FilterBarClasses.tagsButtonInner}

     

       345
       345
       -
                   >

     

       346
       346
       -
                     {selectedTags.size > 0 ? (

     

       347
       347
       -
                       <div

     

       348
       348
       -
                         style={{ boxSizing: "content-box" }}

     

       349
       349
       -
                         className={FilterBarClasses.countContainer}

     

       350
       350
       -
                       >

     

       351
       351
       -
                         <Text

     

       352
       352
       -
                           className={FilterBarClasses.countText}

     

       353
       353
       -
                           color="none"

     

       354
       354
       -
                           variant="text-xs/medium"

     

       355
       355
       -
                         >

     

       356
       356
       -
                           {selectedTags.size}

     

       357
       357
       -
                         </Text>

     

       358
       358
       -
                       </div>

     

       359
       359
       -
                     ) : (

     

       360
       360
       -
                       <>All</>

     

       361
       361
       -
                     )}

     

       362
       362
       -
                     {isShown ? (

     

       363
       363
       -
                       <ChevronSmallUpIcon size={20} />

     

       364
       364
       -
                     ) : (

     

       365
       365
       -
                       <ChevronSmallDownIcon size={20} />

     

       366
       366
       -
                     )}

     

       367
       367
       -
                   </Button>

     

       368
       368
       -
                 )}

     

       369
       369
       -
               </Popout>

     

       370
       370
       -
             </div>

     

       371
       371
       -
           );

     

       372
       372
       -
         };

     

       373
       373
       -
       };

-118

packages/core-extensions/src/moonbase/ui/extensions/index.tsx

···

       1
       1
       -
       import {

     

       2
       2
       -
         ExtensionLoadSource,

     

       3
       3
       -
         ExtensionTag,

     

       4
       4
       -
         WebpackRequireType

     

       5
       5
       -
       } from "@moonlight-mod/types";

     

       6
       6
       -
       import { ExtensionState } from "../../types";

     

       7
       7
       -
       import filterBar, { Filter, defaultFilter } from "./filterBar";

     

       8
       8
       -
       import card from "./card";

     

       9
       9
       -
       

     

       10
       10
       -
       export default (require: WebpackRequireType) => {

     

       11
       11
       -
         const React = require("common_react");

     

       12
       12
       -
         const spacepack = require("spacepack_spacepack").spacepack;

     

       13
       13
       -
         const Flux = require("common_flux");

     

       14
       14
       -
       

     

       15
       15
       -
         const { MoonbaseSettingsStore } =

     

       16
       16
       -
           require("moonbase_stores") as typeof import("../../webpackModules/stores");

     

       17
       17
       -
       

     

       18
       18
       -
         const ExtensionCard = card(require);

     

       19
       19
       -
         const FilterBar = React.lazy(() =>

     

       20
       20
       -
           filterBar(require).then((c) => ({ default: c }))

     

       21
       21
       -
         );

     

       22
       22
       -
       

     

       23
       23
       -
         const Margins = spacepack.findByCode("marginCenterHorz:")[0].exports;

     

       24
       24
       -
         const SearchBar = spacepack.findByCode("Messages.SEARCH", "hideSearchIcon")[0]

     

       25
       25
       -
           .exports.default;

     

       26
       26
       -
       

     

       27
       27
       -
         return function ExtensionsPage() {

     

       28
       28
       -
           const { extensions, savedFilter } = Flux.useStateFromStoresObject(

     

       29
       29
       -
             [MoonbaseSettingsStore],

     

       30
       30
       -
             () => {

     

       31
       31
       -
               return {

     

       32
       32
       -
                 extensions: MoonbaseSettingsStore.extensions,

     

       33
       33
       -
                 savedFilter: MoonbaseSettingsStore.getExtensionConfig(

     

       34
       34
       -
                   "moonbase",

     

       35
       35
       -
                   "filter"

     

       36
       36
       -
                 )

     

       37
       37
       -
               };

     

       38
       38
       -
             }

     

       39
       39
       -
           );

     

       40
       40
       -
       

     

       41
       41
       -
           const [query, setQuery] = React.useState("");

     

       42
       42
       -
       

     

       43
       43
       -
           let filter: Filter, setFilter: (filter: Filter) => void;

     

       44
       44
       -
           if (moonlight.getConfigOption<boolean>("moonbase", "saveFilter")) {

     

       45
       45
       -
             filter = savedFilter ?? defaultFilter;

     

       46
       46
       -
             setFilter = (filter) =>

     

       47
       47
       -
               MoonbaseSettingsStore.setExtensionConfig("moonbase", "filter", filter);

     

       48
       48
       -
           } else {

     

       49
       49
       -
             const state = React.useState(defaultFilter);

     

       50
       50
       -
             filter = state[0];

     

       51
       51
       -
             setFilter = state[1];

     

       52
       52
       -
           }

     

       53
       53
       -
           const [selectedTags, setSelectedTags] = React.useState(new Set<string>());

     

       54
       54
       -
           const sorted = Object.values(extensions).sort((a, b) => {

     

       55
       55
       -
             const aName = a.manifest.meta?.name ?? a.id;

     

       56
       56
       -
             const bName = b.manifest.meta?.name ?? b.id;

     

       57
       57
       -
             return aName.localeCompare(bName);

     

       58
       58
       -
           });

     

       59
       59
       -
       

     

       60
       60
       -
           const filtered = sorted.filter(

     

       61
       61
       -
             (ext) =>

     

       62
       62
       -
               (ext.manifest.meta?.name?.toLowerCase().includes(query) ||

     

       63
       63
       -
                 ext.manifest.meta?.tagline?.toLowerCase().includes(query) ||

     

       64
       64
       -
                 ext.manifest.meta?.description?.toLowerCase().includes(query)) &&

     

       65
       65
       -
               [...selectedTags.values()].every(

     

       66
       66
       -
                 (tag) => ext.manifest.meta?.tags?.includes(tag as ExtensionTag)

     

       67
       67
       -
               ) &&

     

       68
       68
       -
               // This seems very bad, sorry

     

       69
       69
       -
               !(

     

       70
       70
       -
                 (!(filter & Filter.Core) &&

     

       71
       71
       -
                   ext.source.type === ExtensionLoadSource.Core) ||

     

       72
       72
       -
                 (!(filter & Filter.Normal) &&

     

       73
       73
       -
                   ext.source.type === ExtensionLoadSource.Normal) ||

     

       74
       74
       -
                 (!(filter & Filter.Developer) &&

     

       75
       75
       -
                   ext.source.type === ExtensionLoadSource.Developer) ||

     

       76
       76
       -
                 (!(filter & Filter.Enabled) &&

     

       77
       77
       -
                   MoonbaseSettingsStore.getExtensionEnabled(ext.id)) ||

     

       78
       78
       -
                 (!(filter & Filter.Disabled) &&

     

       79
       79
       -
                   !MoonbaseSettingsStore.getExtensionEnabled(ext.id)) ||

     

       80
       80
       -
                 (!(filter & Filter.Installed) &&

     

       81
       81
       -
                   ext.state !== ExtensionState.NotDownloaded) ||

     

       82
       82
       -
                 (!(filter & Filter.Repository) &&

     

       83
       83
       -
                   ext.state === ExtensionState.NotDownloaded)

     

       84
       84
       -
               )

     

       85
       85
       -
           );

     

       86
       86
       -
       

     

       87
       87
       -
           return (

     

       88
       88
       -
             <>

     

       89
       89
       -
               <SearchBar

     

       90
       90
       -
                 size={SearchBar.Sizes.MEDIUM}

     

       91
       91
       -
                 query={query}

     

       92
       92
       -
                 onChange={(v: string) => setQuery(v.toLowerCase())}

     

       93
       93
       -
                 onClear={() => setQuery("")}

     

       94
       94
       -
                 autoFocus={true}

     

       95
       95
       -
                 autoComplete="off"

     

       96
       96
       -
                 inputProps={{

     

       97
       97
       -
                   autoCapitalize: "none",

     

       98
       98
       -
                   autoCorrect: "off",

     

       99
       99
       -
                   spellCheck: "false"

     

       100
       100
       -
                 }}

     

       101
       101
       -
               />

     

       102
       102
       -
               <React.Suspense

     

       103
       103
       -
                 fallback={<div className={Margins.marginBottom20}></div>}

     

       104
       104
       -
               >

     

       105
       105
       -
                 <FilterBar

     

       106
       106
       -
                   filter={filter}

     

       107
       107
       -
                   setFilter={setFilter}

     

       108
       108
       -
                   selectedTags={selectedTags}

     

       109
       109
       -
                   setSelectedTags={setSelectedTags}

     

       110
       110
       -
                 />

     

       111
       111
       -
               </React.Suspense>

     

       112
       112
       -
               {filtered.map((ext) => (

     

       113
       113
       -
                 <ExtensionCard id={ext.id} key={ext.id} />

     

       114
       114
       -
               ))}

     

       115
       115
       -
             </>

     

       116
       116
       -
           );

     

       117
       117
       -
         };

     

       118
       118
       -
       };

-209

packages/core-extensions/src/moonbase/ui/extensions/info.tsx

···

       1
       1
       -
       import WebpackRequire from "@moonlight-mod/types/discord/require";

     

       2
       2
       -
       import { ExtensionTag } from "@moonlight-mod/types";

     

       3
       3
       -
       import { MoonbaseExtension } from "../../types";

     

       4
       4
       -
       

     

       5
       5
       -
       type Dependency = {

     

       6
       6
       -
         id: string;

     

       7
       7
       -
         type: DependencyType;

     

       8
       8
       -
       };

     

       9
       9
       -
       

     

       10
       10
       -
       enum DependencyType {

     

       11
       11
       -
         Dependency = "dependency",

     

       12
       12
       -
         Optional = "optional",

     

       13
       13
       -
         Incompatible = "incompatible"

     

       14
       14
       -
       }

     

       15
       15
       -
       

     

       16
       16
       -
       export const tagNames: Record<ExtensionTag, string> = {

     

       17
       17
       -
         [ExtensionTag.Accessibility]: "Accessibility",

     

       18
       18
       -
         [ExtensionTag.Appearance]: "Appearance",

     

       19
       19
       -
         [ExtensionTag.Chat]: "Chat",

     

       20
       20
       -
         [ExtensionTag.Commands]: "Commands",

     

       21
       21
       -
         [ExtensionTag.ContextMenu]: "Context Menu",

     

       22
       22
       -
         [ExtensionTag.DangerZone]: "Danger Zone",

     

       23
       23
       -
         [ExtensionTag.Development]: "Development",

     

       24
       24
       -
         [ExtensionTag.Fixes]: "Fixes",

     

       25
       25
       -
         [ExtensionTag.Fun]: "Fun",

     

       26
       26
       -
         [ExtensionTag.Markdown]: "Markdown",

     

       27
       27
       -
         [ExtensionTag.Voice]: "Voice",

     

       28
       28
       -
         [ExtensionTag.Privacy]: "Privacy",

     

       29
       29
       -
         [ExtensionTag.Profiles]: "Profiles",

     

       30
       30
       -
         [ExtensionTag.QualityOfLife]: "Quality of Life",

     

       31
       31
       -
         [ExtensionTag.Library]: "Library"

     

       32
       32
       -
       };

     

       33
       33
       -
       

     

       34
       34
       -
       export default (require: typeof WebpackRequire) => {

     

       35
       35
       -
         const React = require("common_react");

     

       36
       36
       -
         const spacepack = require("spacepack_spacepack").spacepack;

     

       37
       37
       -
       

     

       38
       38
       -
         const CommonComponents = require("common_components");

     

       39
       39
       -
         const UserInfoClasses = spacepack.findByCode(

     

       40
       40
       -
           "infoScroller",

     

       41
       41
       -
           "userInfoSection",

     

       42
       42
       -
           "userInfoSectionHeader"

     

       43
       43
       -
         )[0].exports;

     

       44
       44
       -
       

     

       45
       45
       -
         const { MoonbaseSettingsStore } =

     

       46
       46
       -
           require("moonbase_stores") as typeof import("../../webpackModules/stores");

     

       47
       47
       -
       

     

       48
       48
       -
         function InfoSection({

     

       49
       49
       -
           title,

     

       50
       50
       -
           children

     

       51
       51
       -
         }: {

     

       52
       52
       -
           title: string;

     

       53
       53
       -
           children: React.ReactNode;

     

       54
       54
       -
         }) {

     

       55
       55
       -
           return (

     

       56
       56
       -
             <div

     

       57
       57
       -
               style={{

     

       58
       58
       -
                 marginRight: "1em"

     

       59
       59
       -
               }}

     

       60
       60
       -
             >

     

       61
       61
       -
               <CommonComponents.Text

     

       62
       62
       -
                 variant="eyebrow"

     

       63
       63
       -
                 className={UserInfoClasses.userInfoSectionHeader}

     

       64
       64
       -
               >

     

       65
       65
       -
                 {title}

     

       66
       66
       -
               </CommonComponents.Text>

     

       67
       67
       -
       

     

       68
       68
       -
               <CommonComponents.Text variant="text-sm/normal">

     

       69
       69
       -
                 {children}

     

       70
       70
       -
               </CommonComponents.Text>

     

       71
       71
       -
             </div>

     

       72
       72
       -
           );

     

       73
       73
       -
         }

     

       74
       74
       -
       

     

       75
       75
       -
         function Badge({

     

       76
       76
       -
           color,

     

       77
       77
       -
           children

     

       78
       78
       -
         }: {

     

       79
       79
       -
           color: string;

     

       80
       80
       -
           children: React.ReactNode;

     

       81
       81
       -
         }) {

     

       82
       82
       -
           return (

     

       83
       83
       -
             <span

     

       84
       84
       -
               style={{

     

       85
       85
       -
                 borderRadius: ".1875rem",

     

       86
       86
       -
                 padding: "0 0.275rem",

     

       87
       87
       -
                 marginRight: "0.4em",

     

       88
       88
       -
                 backgroundColor: color,

     

       89
       89
       -
                 color: "#fff"

     

       90
       90
       -
               }}

     

       91
       91
       -
             >

     

       92
       92
       -
               {children}

     

       93
       93
       -
             </span>

     

       94
       94
       -
           );

     

       95
       95
       -
         }

     

       96
       96
       -
       

     

       97
       97
       -
         function ExtensionInfo({ ext }: { ext: MoonbaseExtension }) {

     

       98
       98
       -
           const authors = ext.manifest?.meta?.authors;

     

       99
       99
       -
           const tags = ext.manifest?.meta?.tags;

     

       100
       100
       -
           const version = ext.manifest?.version;

     

       101
       101
       -
       

     

       102
       102
       -
           const dependencies: Dependency[] = [];

     

       103
       103
       -
           if (ext.manifest.dependencies != null) {

     

       104
       104
       -
             dependencies.push(

     

       105
       105
       -
               ...ext.manifest.dependencies.map((dep) => ({

     

       106
       106
       -
                 id: dep,

     

       107
       107
       -
                 type: DependencyType.Dependency

     

       108
       108
       -
               }))

     

       109
       109
       -
             );

     

       110
       110
       -
           }

     

       111
       111
       -
       

     

       112
       112
       -
           if (ext.manifest.suggested != null) {

     

       113
       113
       -
             dependencies.push(

     

       114
       114
       -
               ...ext.manifest.suggested.map((dep) => ({

     

       115
       115
       -
                 id: dep,

     

       116
       116
       -
                 type: DependencyType.Optional

     

       117
       117
       -
               }))

     

       118
       118
       -
             );

     

       119
       119
       -
           }

     

       120
       120
       -
       

     

       121
       121
       -
           if (ext.manifest.incompatible != null) {

     

       122
       122
       -
             dependencies.push(

     

       123
       123
       -
               ...ext.manifest.incompatible.map((dep) => ({

     

       124
       124
       -
                 id: dep,

     

       125
       125
       -
                 type: DependencyType.Incompatible

     

       126
       126
       -
               }))

     

       127
       127
       -
             );

     

       128
       128
       -
           }

     

       129
       129
       -
       

     

       130
       130
       -
           return (

     

       131
       131
       -
             <>

     

       132
       132
       -
               {authors != null && (

     

       133
       133
       -
                 <InfoSection title="Authors">

     

       134
       134
       -
                   {authors.map((author, i) => {

     

       135
       135
       -
                     const comma = i !== authors.length - 1 ? ", " : "";

     

       136
       136
       -
                     if (typeof author === "string") {

     

       137
       137
       -
                       return (

     

       138
       138
       -
                         <span key={i}>

     

       139
       139
       -
                           {author}

     

       140
       140
       -
                           {comma}

     

       141
       141
       -
                         </span>

     

       142
       142
       -
                       );

     

       143
       143
       -
                     } else {

     

       144
       144
       -
                       // TODO: resolve IDs

     

       145
       145
       -
                       return (

     

       146
       146
       -
                         <span key={i}>

     

       147
       147
       -
                           {author.name}

     

       148
       148
       -
                           {comma}

     

       149
       149
       -
                         </span>

     

       150
       150
       -
                       );

     

       151
       151
       -
                     }

     

       152
       152
       -
                   })}

     

       153
       153
       -
                 </InfoSection>

     

       154
       154
       -
               )}

     

       155
       155
       -
       

     

       156
       156
       -
               {tags != null && (

     

       157
       157
       -
                 <InfoSection title="Tags">

     

       158
       158
       -
                   {tags.map((tag, i) => {

     

       159
       159
       -
                     const name = tagNames[tag];

     

       160
       160
       -
       

     

       161
       161
       -
                     return (

     

       162
       162
       -
                       <Badge

     

       163
       163
       -
                         key={i}

     

       164
       164
       -
                         color={

     

       165
       165
       -
                           tag === ExtensionTag.DangerZone

     

       166
       166
       -
                             ? "var(--red-400)"

     

       167
       167
       -
                             : "var(--brand-500)"

     

       168
       168
       -
                         }

     

       169
       169
       -
                       >

     

       170
       170
       -
                         {name}

     

       171
       171
       -
                       </Badge>

     

       172
       172
       -
                     );

     

       173
       173
       -
                   })}

     

       174
       174
       -
                 </InfoSection>

     

       175
       175
       -
               )}

     

       176
       176
       -
       

     

       177
       177
       -
               {dependencies.length > 0 && (

     

       178
       178
       -
                 <InfoSection title="Dependencies">

     

       179
       179
       -
                   {dependencies.map((dep) => {

     

       180
       180
       -
                     const colors = {

     

       181
       181
       -
                       [DependencyType.Dependency]: "var(--brand-500)",

     

       182
       182
       -
                       [DependencyType.Optional]: "var(--orange-400)",

     

       183
       183
       -
                       [DependencyType.Incompatible]: "var(--red-400)"

     

       184
       184
       -
                     };

     

       185
       185
       -
                     const color = colors[dep.type];

     

       186
       186
       -
                     const name = MoonbaseSettingsStore.getExtensionName(dep.id);

     

       187
       187
       -
                     return (

     

       188
       188
       -
                       <Badge color={color} key={dep.id}>

     

       189
       189
       -
                         {name}

     

       190
       190
       -
                       </Badge>

     

       191
       191
       -
                     );

     

       192
       192
       -
                   })}

     

       193
       193
       -
                 </InfoSection>

     

       194
       194
       -
               )}

     

       195
       195
       -
       

     

       196
       196
       -
               {version != null && (

     

       197
       197
       -
                 <InfoSection title="Version">

     

       198
       198
       -
                   <span>{version}</span>

     

       199
       199
       -
                 </InfoSection>

     

       200
       200
       -
               )}

     

       201
       201
       -
             </>

     

       202
       202
       -
           );

     

       203
       203
       -
         }

     

       204
       204
       -
       

     

       205
       205
       -
         return {

     

       206
       206
       -
           InfoSection,

     

       207
       207
       -
           ExtensionInfo

     

       208
       208
       -
         };

     

       209
       209
       -
       };

-396

packages/core-extensions/src/moonbase/ui/extensions/settings.tsx

···

       1
       1
       -
       import {

     

       2
       2
       -
         ExtensionSettingType,

     

       3
       3
       -
         ExtensionSettingsManifest,

     

       4
       4
       -
         MultiSelectSettingType,

     

       5
       5
       -
         NumberSettingType,

     

       6
       6
       -
         SelectOption,

     

       7
       7
       -
         SelectSettingType

     

       8
       8
       -
       } from "@moonlight-mod/types/config";

     

       9
       9
       -
       import WebpackRequire from "@moonlight-mod/types/discord/require";

     

       10
       10
       -
       import { CircleXIconSVG, ExtensionState, MoonbaseExtension } from "../../types";

     

       11
       11
       -
       

     

       12
       12
       -
       type SettingsProps = {

     

       13
       13
       -
         ext: MoonbaseExtension;

     

       14
       14
       -
         name: string;

     

       15
       15
       -
         setting: ExtensionSettingsManifest;

     

       16
       16
       -
         disabled: boolean;

     

       17
       17
       -
       };

     

       18
       18
       -
       

     

       19
       19
       -
       type SettingsComponent = React.ComponentType<SettingsProps>;

     

       20
       20
       -
       

     

       21
       21
       -
       export default (require: typeof WebpackRequire) => {

     

       22
       22
       -
         const React = require("common_react");

     

       23
       23
       -
         const CommonComponents = require("common_components");

     

       24
       24
       -
         const Flux = require("common_flux");

     

       25
       25
       -
         const spacepack = require("spacepack_spacepack").spacepack;

     

       26
       26
       -
       

     

       27
       27
       -
         const { MoonbaseSettingsStore } =

     

       28
       28
       -
           require("moonbase_stores") as typeof import("../../webpackModules/stores");

     

       29
       29
       -
       

     

       30
       30
       -
         const Margins = spacepack.findByCode("marginCenterHorz:")[0].exports;

     

       31
       31
       -
       

     

       32
       32
       -
         function useConfigEntry<T>(id: string, name: string) {

     

       33
       33
       -
           return Flux.useStateFromStores(

     

       34
       34
       -
             [MoonbaseSettingsStore],

     

       35
       35
       -
             () => {

     

       36
       36
       -
               return {

     

       37
       37
       -
                 value: MoonbaseSettingsStore.getExtensionConfig<T>(id, name),

     

       38
       38
       -
                 displayName: MoonbaseSettingsStore.getExtensionConfigName(id, name),

     

       39
       39
       -
                 description: MoonbaseSettingsStore.getExtensionConfigDescription(

     

       40
       40
       -
                   id,

     

       41
       41
       -
                   name

     

       42
       42
       -
                 )

     

       43
       43
       -
               };

     

       44
       44
       -
             },

     

       45
       45
       -
             [id, name]

     

       46
       46
       -
           );

     

       47
       47
       -
         }

     

       48
       48
       -
       

     

       49
       49
       -
         function Boolean({ ext, name, setting, disabled }: SettingsProps) {

     

       50
       50
       -
           const { FormSwitch } = CommonComponents;

     

       51
       51
       -
           const { value, displayName, description } = useConfigEntry<boolean>(

     

       52
       52
       -
             ext.id,

     

       53
       53
       -
             name

     

       54
       54
       -
           );

     

       55
       55
       -
       

     

       56
       56
       -
           return (

     

       57
       57
       -
             <FormSwitch

     

       58
       58
       -
               value={value ?? false}

     

       59
       59
       -
               hideBorder={true}

     

       60
       60
       -
               disabled={disabled}

     

       61
       61
       -
               onChange={(value: boolean) => {

     

       62
       62
       -
                 MoonbaseSettingsStore.setExtensionConfig(ext.id, name, value);

     

       63
       63
       -
               }}

     

       64
       64
       -
               note={description}

     

       65
       65
       -
               className={`${Margins.marginReset} ${Margins.marginTop20}`}

     

       66
       66
       -
             >

     

       67
       67
       -
               {displayName}

     

       68
       68
       -
             </FormSwitch>

     

       69
       69
       -
           );

     

       70
       70
       -
         }

     

       71
       71
       -
       

     

       72
       72
       -
         function Number({ ext, name, setting, disabled }: SettingsProps) {

     

       73
       73
       -
           const { FormItem, FormText, Slider } = CommonComponents;

     

       74
       74
       -
           const { value, displayName, description } = useConfigEntry<number>(

     

       75
       75
       -
             ext.id,

     

       76
       76
       -
             name

     

       77
       77
       -
           );

     

       78
       78
       -
       

     

       79
       79
       -
           const castedSetting = setting as NumberSettingType;

     

       80
       80
       -
           const min = castedSetting.min ?? 0;

     

       81
       81
       -
           const max = castedSetting.max ?? 100;

     

       82
       82
       -
       

     

       83
       83
       -
           return (

     

       84
       84
       -
             <FormItem className={Margins.marginTop20} title={displayName}>

     

       85
       85
       -
               {description && <FormText>{description}</FormText>}

     

       86
       86
       -
               <Slider

     

       87
       87
       -
                 initialValue={value ?? 0}

     

       88
       88
       -
                 disabled={disabled}

     

       89
       89
       -
                 minValue={castedSetting.min ?? 0}

     

       90
       90
       -
                 maxValue={castedSetting.max ?? 100}

     

       91
       91
       -
                 onValueChange={(value: number) => {

     

       92
       92
       -
                   const rounded = Math.max(min, Math.min(max, Math.round(value)));

     

       93
       93
       -
                   MoonbaseSettingsStore.setExtensionConfig(ext.id, name, rounded);

     

       94
       94
       -
                 }}

     

       95
       95
       -
               />

     

       96
       96
       -
             </FormItem>

     

       97
       97
       -
           );

     

       98
       98
       -
         }

     

       99
       99
       -
       

     

       100
       100
       -
         function String({ ext, name, setting, disabled }: SettingsProps) {

     

       101
       101
       -
           const { FormItem, FormText, TextInput } = CommonComponents;

     

       102
       102
       -
           const { value, displayName, description } = useConfigEntry<string>(

     

       103
       103
       -
             ext.id,

     

       104
       104
       -
             name

     

       105
       105
       -
           );

     

       106
       106
       -
       

     

       107
       107
       -
           return (

     

       108
       108
       -
             <FormItem className={Margins.marginTop20} title={displayName}>

     

       109
       109
       -
               {description && (

     

       110
       110
       -
                 <FormText className={Margins.marginBottom8}>{description}</FormText>

     

       111
       111
       -
               )}

     

       112
       112
       -
               <TextInput

     

       113
       113
       -
                 value={value ?? ""}

     

       114
       114
       -
                 onChange={(value: string) => {

     

       115
       115
       -
                   if (disabled) return;

     

       116
       116
       -
                   MoonbaseSettingsStore.setExtensionConfig(ext.id, name, value);

     

       117
       117
       -
                 }}

     

       118
       118
       -
               />

     

       119
       119
       -
             </FormItem>

     

       120
       120
       -
           );

     

       121
       121
       -
         }

     

       122
       122
       -
       

     

       123
       123
       -
         function Select({ ext, name, setting, disabled }: SettingsProps) {

     

       124
       124
       -
           const { FormItem, FormText, SingleSelect } = CommonComponents;

     

       125
       125
       -
           const { value, displayName, description } = useConfigEntry<string>(

     

       126
       126
       -
             ext.id,

     

       127
       127
       -
             name

     

       128
       128
       -
           );

     

       129
       129
       -
       

     

       130
       130
       -
           const castedSetting = setting as SelectSettingType;

     

       131
       131
       -
           const options = castedSetting.options;

     

       132
       132
       -
       

     

       133
       133
       -
           return (

     

       134
       134
       -
             <FormItem className={Margins.marginTop20} title={displayName}>

     

       135
       135
       -
               {description && (

     

       136
       136
       -
                 <FormText className={Margins.marginBottom8}>{description}</FormText>

     

       137
       137
       -
               )}

     

       138
       138
       -
               <SingleSelect

     

       139
       139
       -
                 autofocus={false}

     

       140
       140
       -
                 clearable={false}

     

       141
       141
       -
                 value={value ?? ""}

     

       142
       142
       -
                 options={options.map((o: SelectOption) =>

     

       143
       143
       -
                   typeof o === "string" ? { value: o, label: o } : o

     

       144
       144
       -
                 )}

     

       145
       145
       -
                 onChange={(value: string) => {

     

       146
       146
       -
                   if (disabled) return;

     

       147
       147
       -
                   MoonbaseSettingsStore.setExtensionConfig(ext.id, name, value);

     

       148
       148
       -
                 }}

     

       149
       149
       -
               />

     

       150
       150
       -
             </FormItem>

     

       151
       151
       -
           );

     

       152
       152
       -
         }

     

       153
       153
       -
       

     

       154
       154
       -
         function MultiSelect({ ext, name, setting, disabled }: SettingsProps) {

     

       155
       155
       -
           const { FormItem, FormText, Select, useVariableSelect, multiSelect } =

     

       156
       156
       -
             CommonComponents;

     

       157
       157
       -
           const { value, displayName, description } = useConfigEntry<

     

       158
       158
       -
             string | string[]

     

       159
       159
       -
           >(ext.id, name);

     

       160
       160
       -
       

     

       161
       161
       -
           const castedSetting = setting as MultiSelectSettingType;

     

       162
       162
       -
           const options = castedSetting.options;

     

       163
       163
       -
       

     

       164
       164
       -
           return (

     

       165
       165
       -
             <FormItem className={Margins.marginTop20} title={displayName}>

     

       166
       166
       -
               {description && (

     

       167
       167
       -
                 <FormText className={Margins.marginBottom8}>{description}</FormText>

     

       168
       168
       -
               )}

     

       169
       169
       -
               <Select

     

       170
       170
       -
                 autofocus={false}

     

       171
       171
       -
                 clearable={false}

     

       172
       172
       -
                 closeOnSelect={false}

     

       173
       173
       -
                 options={options.map((o: SelectOption) =>

     

       174
       174
       -
                   typeof o === "string" ? { value: o, label: o } : o

     

       175
       175
       -
                 )}

     

       176
       176
       -
                 {...useVariableSelect({

     

       177
       177
       -
                   onSelectInteraction: multiSelect,

     

       178
       178
       -
                   value: new Set(Array.isArray(value) ? value : [value]),

     

       179
       179
       -
                   onChange: (value: string) => {

     

       180
       180
       -
                     if (disabled) return;

     

       181
       181
       -
                     MoonbaseSettingsStore.setExtensionConfig(

     

       182
       182
       -
                       ext.id,

     

       183
       183
       -
                       name,

     

       184
       184
       -
                       Array.from(value)

     

       185
       185
       -
                     );

     

       186
       186
       -
                   }

     

       187
       187
       -
                 })}

     

       188
       188
       -
               />

     

       189
       189
       -
             </FormItem>

     

       190
       190
       -
           );

     

       191
       191
       -
         }

     

       192
       192
       -
       

     

       193
       193
       -
         const RemoveButtonClasses = spacepack.findByCode("removeButtonContainer")[0]

     

       194
       194
       -
           .exports;

     

       195
       195
       -
         const CircleXIcon = spacepack.findByCode(CircleXIconSVG)[0].exports.default;

     

       196
       196
       -
         function RemoveEntryButton({

     

       197
       197
       -
           onClick,

     

       198
       198
       -
           disabled

     

       199
       199
       -
         }: {

     

       200
       200
       -
           onClick: () => void;

     

       201
       201
       -
           disabled: boolean;

     

       202
       202
       -
         }) {

     

       203
       203
       -
           const { Tooltip, Clickable } = CommonComponents;

     

       204
       204
       -
           return (

     

       205
       205
       -
             <div className={RemoveButtonClasses.removeButtonContainer}>

     

       206
       206
       -
               <Tooltip text="Remove entry" position="top">

     

       207
       207
       -
                 {(props: any) => (

     

       208
       208
       -
                   <Clickable

     

       209
       209
       -
                     {...props}

     

       210
       210
       -
                     className={RemoveButtonClasses.removeButton}

     

       211
       211
       -
                     onClick={onClick}

     

       212
       212
       -
                   >

     

       213
       213
       -
                     <CircleXIcon width={16} height={16} />

     

       214
       214
       -
                   </Clickable>

     

       215
       215
       -
                 )}

     

       216
       216
       -
               </Tooltip>

     

       217
       217
       -
             </div>

     

       218
       218
       -
           );

     

       219
       219
       -
         }

     

       220
       220
       -
       

     

       221
       221
       -
         function List({ ext, name, setting, disabled }: SettingsProps) {

     

       222
       222
       -
           const { FormItem, FormText, TextInput, Button, Flex } = CommonComponents;

     

       223
       223
       -
           const { value, displayName, description } = useConfigEntry<string[]>(

     

       224
       224
       -
             ext.id,

     

       225
       225
       -
             name

     

       226
       226
       -
           );

     

       227
       227
       -
       

     

       228
       228
       -
           const entries = value ?? [];

     

       229
       229
       -
           const updateConfig = () =>

     

       230
       230
       -
             MoonbaseSettingsStore.setExtensionConfig(ext.id, name, entries);

     

       231
       231
       -
       

     

       232
       232
       -
           return (

     

       233
       233
       -
             <FormItem className={Margins.marginTop20} title={displayName}>

     

       234
       234
       -
               {description && (

     

       235
       235
       -
                 <FormText className={Margins.marginBottom4}>{description}</FormText>

     

       236
       236
       -
               )}

     

       237
       237
       -
               <Flex direction={Flex.Direction.VERTICAL}>

     

       238
       238
       -
                 {entries.map((val, i) => (

     

       239
       239
       -
                   // FIXME: stylesheets

     

       240
       240
       -
                   <div

     

       241
       241
       -
                     key={i}

     

       242
       242
       -
                     style={{

     

       243
       243
       -
                       display: "grid",

     

       244
       244
       -
                       height: "32px",

     

       245
       245
       -
                       gap: "8px",

     

       246
       246
       -
                       gridTemplateColumns: "1fr 32px",

     

       247
       247
       -
                       alignItems: "center"

     

       248
       248
       -
                     }}

     

       249
       249
       -
                   >

     

       250
       250
       -
                     <TextInput

     

       251
       251
       -
                       size={TextInput.Sizes.MINI}

     

       252
       252
       -
                       value={val}

     

       253
       253
       -
                       disabled={disabled}

     

       254
       254
       -
                       onChange={(newVal: string) => {

     

       255
       255
       -
                         entries[i] = newVal;

     

       256
       256
       -
                         updateConfig();

     

       257
       257
       -
                       }}

     

       258
       258
       -
                     />

     

       259
       259
       -
                     <RemoveEntryButton

     

       260
       260
       -
                       disabled={disabled}

     

       261
       261
       -
                       onClick={() => {

     

       262
       262
       -
                         entries.splice(i, 1);

     

       263
       263
       -
                         updateConfig();

     

       264
       264
       -
                       }}

     

       265
       265
       -
                     />

     

       266
       266
       -
                   </div>

     

       267
       267
       -
                 ))}

     

       268
       268
       -
       

     

       269
       269
       -
                 <Button

     

       270
       270
       -
                   look={Button.Looks.FILLED}

     

       271
       271
       -
                   color={Button.Colors.GREEN}

     

       272
       272
       -
                   size={Button.Sizes.SMALL}

     

       273
       273
       -
                   disabled={disabled}

     

       274
       274
       -
                   className={Margins.marginTop8}

     

       275
       275
       -
                   onClick={() => {

     

       276
       276
       -
                     entries.push("");

     

       277
       277
       -
                     updateConfig();

     

       278
       278
       -
                   }}

     

       279
       279
       -
                 >

     

       280
       280
       -
                   Add new entry

     

       281
       281
       -
                 </Button>

     

       282
       282
       -
               </Flex>

     

       283
       283
       -
             </FormItem>

     

       284
       284
       -
           );

     

       285
       285
       -
         }

     

       286
       286
       -
       

     

       287
       287
       -
         function Dictionary({ ext, name, setting, disabled }: SettingsProps) {

     

       288
       288
       -
           const { FormItem, FormText, TextInput, Button, Flex } = CommonComponents;

     

       289
       289
       -
           const { value, displayName, description } = useConfigEntry<

     

       290
       290
       -
             Record<string, string>

     

       291
       291
       -
           >(ext.id, name);

     

       292
       292
       -
       

     

       293
       293
       -
           const entries = Object.entries(value ?? {});

     

       294
       294
       -
           const updateConfig = () =>

     

       295
       295
       -
             MoonbaseSettingsStore.setExtensionConfig(

     

       296
       296
       -
               ext.id,

     

       297
       297
       -
               name,

     

       298
       298
       -
               Object.fromEntries(entries)

     

       299
       299
       -
             );

     

       300
       300
       -
       

     

       301
       301
       -
           return (

     

       302
       302
       -
             <FormItem className={Margins.marginTop20} title={displayName}>

     

       303
       303
       -
               {description && (

     

       304
       304
       -
                 <FormText className={Margins.marginBottom4}>{description}</FormText>

     

       305
       305
       -
               )}

     

       306
       306
       -
               <Flex direction={Flex.Direction.VERTICAL}>

     

       307
       307
       -
                 {entries.map(([key, val], i) => (

     

       308
       308
       -
                   // FIXME: stylesheets

     

       309
       309
       -
                   <div

     

       310
       310
       -
                     key={i}

     

       311
       311
       -
                     style={{

     

       312
       312
       -
                       display: "grid",

     

       313
       313
       -
                       height: "32px",

     

       314
       314
       -
                       gap: "8px",

     

       315
       315
       -
                       gridTemplateColumns: "1fr 1fr 32px",

     

       316
       316
       -
                       alignItems: "center"

     

       317
       317
       -
                     }}

     

       318
       318
       -
                   >

     

       319
       319
       -
                     <TextInput

     

       320
       320
       -
                       size={TextInput.Sizes.MINI}

     

       321
       321
       -
                       value={key}

     

       322
       322
       -
                       disabled={disabled}

     

       323
       323
       -
                       onChange={(newKey: string) => {

     

       324
       324
       -
                         entries[i][0] = newKey;

     

       325
       325
       -
                         updateConfig();

     

       326
       326
       -
                       }}

     

       327
       327
       -
                     />

     

       328
       328
       -
                     <TextInput

     

       329
       329
       -
                       size={TextInput.Sizes.MINI}

     

       330
       330
       -
                       value={val}

     

       331
       331
       -
                       disabled={disabled}

     

       332
       332
       -
                       onChange={(newValue: string) => {

     

       333
       333
       -
                         entries[i][1] = newValue;

     

       334
       334
       -
                         updateConfig();

     

       335
       335
       -
                       }}

     

       336
       336
       -
                     />

     

       337
       337
       -
                     <RemoveEntryButton

     

       338
       338
       -
                       disabled={disabled}

     

       339
       339
       -
                       onClick={() => {

     

       340
       340
       -
                         entries.splice(i, 1);

     

       341
       341
       -
                         updateConfig();

     

       342
       342
       -
                       }}

     

       343
       343
       -
                     />

     

       344
       344
       -
                   </div>

     

       345
       345
       -
                 ))}

     

       346
       346
       -
       

     

       347
       347
       -
                 <Button

     

       348
       348
       -
                   look={Button.Looks.FILLED}

     

       349
       349
       -
                   color={Button.Colors.GREEN}

     

       350
       350
       -
                   size={Button.Sizes.SMALL}

     

       351
       351
       -
                   className={Margins.marginTop8}

     

       352
       352
       -
                   disabled={disabled}

     

       353
       353
       -
                   onClick={() => {

     

       354
       354
       -
                     entries.push([`entry-${entries.length}`, ""]);

     

       355
       355
       -
                     updateConfig();

     

       356
       356
       -
                   }}

     

       357
       357
       -
                 >

     

       358
       358
       -
                   Add new entry

     

       359
       359
       -
                 </Button>

     

       360
       360
       -
               </Flex>

     

       361
       361
       -
             </FormItem>

     

       362
       362
       -
           );

     

       363
       363
       -
         }

     

       364
       364
       -
       

     

       365
       365
       -
         function Setting({ ext, name, setting, disabled }: SettingsProps) {

     

       366
       366
       -
           const elements: Partial<Record<ExtensionSettingType, SettingsComponent>> = {

     

       367
       367
       -
             [ExtensionSettingType.Boolean]: Boolean,

     

       368
       368
       -
             [ExtensionSettingType.Number]: Number,

     

       369
       369
       -
             [ExtensionSettingType.String]: String,

     

       370
       370
       -
             [ExtensionSettingType.Select]: Select,

     

       371
       371
       -
             [ExtensionSettingType.MultiSelect]: MultiSelect,

     

       372
       372
       -
             [ExtensionSettingType.List]: List,

     

       373
       373
       -
             [ExtensionSettingType.Dictionary]: Dictionary

     

       374
       374
       -
           };

     

       375
       375
       -
           const element = elements[setting.type];

     

       376
       376
       -
           if (element == null) return <></>;

     

       377
       377
       -
           return React.createElement(element, { ext, name, setting, disabled });

     

       378
       378
       -
         }

     

       379
       379
       -
       

     

       380
       380
       -
         return function Settings({ ext }: { ext: MoonbaseExtension }) {

     

       381
       381
       -
           const { Flex } = CommonComponents;

     

       382
       382
       -
           return (

     

       383
       383
       -
             <Flex className="moonbase-settings" direction={Flex.Direction.VERTICAL}>

     

       384
       384
       -
               {Object.entries(ext.manifest.settings!).map(([name, setting]) => (

     

       385
       385
       -
                 <Setting

     

       386
       386
       -
                   ext={ext}

     

       387
       387
       -
                   key={name}

     

       388
       388
       -
                   name={name}

     

       389
       389
       -
                   setting={setting}

     

       390
       390
       -
                   disabled={ext.state === ExtensionState.NotDownloaded}

     

       391
       391
       -
                 />

     

       392
       392
       -
               ))}

     

       393
       393
       -
             </Flex>

     

       394
       394
       -
           );

     

       395
       395
       -
         };

     

       396
       396
       -
       };

-54

packages/core-extensions/src/moonbase/ui/index.tsx

···

       1
       1
       -
       import { WebpackRequireType } from "@moonlight-mod/types";

     

       2
       2
       -
       import { pageModules } from "..";

     

       3
       3
       -
       

     

       4
       4
       -
       export default (require: WebpackRequireType) => {

     

       5
       5
       -
         const React = require("common_react");

     

       6
       6
       -
         const spacepack = require("spacepack_spacepack").spacepack;

     

       7
       7
       -
       

     

       8
       8
       -
         const Margins = spacepack.findByCode("marginCenterHorz:")[0].exports;

     

       9
       9
       -
       

     

       10
       10
       -
         const { Divider } = spacepack.findByCode(".default.HEADER_BAR")[0].exports

     

       11
       11
       -
           .default;

     

       12
       12
       -
         const TitleBarClasses = spacepack.findByCode("iconWrapper:", "children:")[0]

     

       13
       13
       -
           .exports;

     

       14
       14
       -
         const TabBarClasses = spacepack.findByCode("nowPlayingColumn:")[0].exports;

     

       15
       15
       -
       

     

       16
       16
       -
         const pages = pageModules(require);

     

       17
       17
       -
       

     

       18
       18
       -
         return function Moonbase() {

     

       19
       19
       -
           const { Text, TabBar } = require("common_components");

     

       20
       20
       -
       

     

       21
       21
       -
           const [selectedTab, setSelectedTab] = React.useState(Object.keys(pages)[0]);

     

       22
       22
       -
       

     

       23
       23
       -
           return (

     

       24
       24
       -
             <>

     

       25
       25
       -
               <div

     

       26
       26
       -
                 className={`${TitleBarClasses.children} ${Margins.marginBottom20}`}

     

       27
       27
       -
               >

     

       28
       28
       -
                 <Text

     

       29
       29
       -
                   className={TitleBarClasses.titleWrapper}

     

       30
       30
       -
                   variant="heading-lg/semibold"

     

       31
       31
       -
                   tag="h2"

     

       32
       32
       -
                 >

     

       33
       33
       -
                   Moonbase

     

       34
       34
       -
                 </Text>

     

       35
       35
       -
                 <Divider />

     

       36
       36
       -
                 <TabBar

     

       37
       37
       -
                   selectedItem={selectedTab}

     

       38
       38
       -
                   onItemSelect={setSelectedTab}

     

       39
       39
       -
                   type="top-pill"

     

       40
       40
       -
                   className={TabBarClasses.tabBar}

     

       41
       41
       -
                 >

     

       42
       42
       -
                   {Object.entries(pages).map(([id, page]) => (

     

       43
       43
       -
                     <TabBar.Item key={id} id={id} className={TabBarClasses.item}>

     

       44
       44
       -
                       {page.name}

     

       45
       45
       -
                     </TabBar.Item>

     

       46
       46
       -
                   ))}

     

       47
       47
       -
                 </TabBar>

     

       48
       48
       -
               </div>

     

       49
       49
       -
       

     

       50
       50
       -
               {React.createElement(pages[selectedTab].element)}

     

       51
       51
       -
             </>

     

       52
       52
       -
           );

     

       53
       53
       -
         };

     

       54
       54
       -
       };

+51

packages/core-extensions/src/moonbase/webpackModules/moonbase.tsx

···

       1
       1
       +
       import settings from "@moonlight-mod/wp/settings_settings";

     

       2
       2
       +
       import React from "@moonlight-mod/wp/common_react";

     

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

     

       4
       4
       +
       import { Moonbase, pages } from "@moonlight-mod/wp/moonbase_ui";

     

       5
       5
       +
       

     

       6
       6
       +
       import { MoonbaseSettingsStore } from "@moonlight-mod/wp/moonbase_stores";

     

       7
       7
       +
       import { Text } from "@moonlight-mod/wp/common_components";

     

       8
       8
       +
       

     

       9
       9
       +
       function addSection(name: string, element: React.FunctionComponent) {

     

       10
       10
       +
         settings.addSection(name, name, element, null, -2, {

     

       11
       11
       +
           stores: [MoonbaseSettingsStore],

     

       12
       12
       +
           element: () => {

     

       13
       13
       +
             // Require it here because lazy loading SUX

     

       14
       14
       +
             const SettingsNotice =

     

       15
       15
       +
               spacepack.findByCode("onSaveButtonColor")[0].exports.default;

     

       16
       16
       +
             return (

     

       17
       17
       +
               <SettingsNotice

     

       18
       18
       +
                 submitting={MoonbaseSettingsStore.submitting}

     

       19
       19
       +
                 onReset={() => {

     

       20
       20
       +
                   MoonbaseSettingsStore.reset();

     

       21
       21
       +
                 }}

     

       22
       22
       +
                 onSave={() => {

     

       23
       23
       +
                   MoonbaseSettingsStore.writeConfig();

     

       24
       24
       +
                 }}

     

       25
       25
       +
               />

     

       26
       26
       +
             );

     

       27
       27
       +
           }

     

       28
       28
       +
         });

     

       29
       29
       +
       }

     

       30
       30
       +
       

     

       31
       31
       +
       if (moonlight.getConfigOption<boolean>("moonbase", "sections")) {

     

       32
       32
       +
         const Margins = spacepack.findByCode("marginCenterHorz:")[0].exports;

     

       33
       33
       +
       

     

       34
       34
       +
         settings.addHeader("Moonbase", -2);

     

       35
       35
       +
         for (const page of Object.values(pages)) {

     

       36
       36
       +
           addSection(page.name, () => (

     

       37
       37
       +
             <>

     

       38
       38
       +
               <Text

     

       39
       39
       +
                 className={Margins.marginBottom20}

     

       40
       40
       +
                 variant="heading-lg/semibold"

     

       41
       41
       +
                 tag="h2"

     

       42
       42
       +
               >

     

       43
       43
       +
                 Extensions

     

       44
       44
       +
               </Text>

     

       45
       45
       +
               <page.element />

     

       46
       46
       +
             </>

     

       47
       47
       +
           ));

     

       48
       48
       +
         }

     

       49
       49
       +
       } else {

     

       50
       50
       +
         addSection("Moonbase", Moonbase);

     

       51
       51
       +
       }

+92 -80

packages/core-extensions/src/moonbase/webpackModules/stores.ts

···

       1
       1
        
       import { Config, ExtensionLoadSource } from "@moonlight-mod/types";

     

       2
       2
       -
       import {

     

       3
       3
       -
         ExtensionState,

     

       4
       4
       -
         MoonbaseExtension,

     

       5
       5
       -
         MoonbaseNatives,

     

       6
       6
       -
         RepositoryManifest

     

       7
       7
       -
       } from "../types";

     

       2
       2
       +
       import { ExtensionState, MoonbaseExtension, MoonbaseNatives } from "../types";

     

       8
       3
        
       import Flux from "@moonlight-mod/wp/common_flux";

     

       9
       4
        
       import Dispatcher from "@moonlight-mod/wp/common_fluxDispatcher";

     

       10
       5
        
       

     
···

       14
       9
        
       class MoonbaseSettingsStore extends Flux.Store<any> {

     

       15
       10
        
         private origConfig: Config;

     

       16
       11
        
         private config: Config;

     

       12
       12
       +
         private extensionIndex: number;

     

       17
       13
        
       

     

       18
       14
        
         modified: boolean;

     

       19
       15
        
         submitting: boolean;

     

       20
       16
        
         installing: boolean;

     

       21
       17
        
       

     

       22
       22
       -
         extensions: { [id: string]: MoonbaseExtension };

     

       23
       23
       -
         updates: { [id: string]: { version: string; download: string } };

     

       18
       18
       +
         extensions: { [id: number]: MoonbaseExtension };

     

       19
       19
       +
         updates: { [id: number]: { version: string; download: string } };

     

       24
       20
        
       

     

       25
       21
        
         constructor() {

     

       26
       22
        
           super(Dispatcher);

     

       27
       23
        
       

     

       28
       24
        
           this.origConfig = moonlightNode.config;

     

       29
       25
        
           this.config = this.clone(this.origConfig);

     

       26
       26
       +
           this.extensionIndex = 0;

     

       30
       27
        
       

     

       31
       28
        
           this.modified = false;

     

       32
       29
        
           this.submitting = false;

     
···

       35
       32
        
           this.extensions = {};

     

       36
       33
        
           this.updates = {};

     

       37
       34
        
           for (const ext of moonlightNode.extensions) {

     

       38
       38
       -
             const existingExtension = this.extensions[ext.id];

     

       39
       39
       -
             if (existingExtension != null) continue;

     

       40
       40
       -
       

     

       41
       41
       -
             this.extensions[ext.id] = {

     

       35
       35
       +
             const uniqueId = this.extensionIndex++;

     

       36
       36
       +
             this.extensions[uniqueId] = {

     

       42
       37
        
               ...ext,

     

       38
       38
       +
               uniqueId,

     

       43
       39
        
               state: moonlight.enabledExtensions.has(ext.id)

     

       44
       40
        
                 ? ExtensionState.Enabled

     

       45
       41
        
                 : ExtensionState.Disabled

     
···

       50
       46
        
             for (const [repo, exts] of Object.entries(ret)) {

     

       51
       47
        
               try {

     

       52
       48
        
                 for (const ext of exts) {

     

       53
       53
       -
                   try {

     

       54
       54
       -
                     const existingExtension = this.extensions[ext.id];

     

       55
       55
       -
                     if (existingExtension !== undefined) {

     

       56
       56
       -
                       if (this.hasUpdate(repo, ext, existingExtension)) {

     

       57
       57
       -
                         this.updates[ext.id] = {

     

       58
       58
       -
                           version: ext.version!,

     

       59
       59
       -
                           download: ext.download

     

       60
       60
       -
                         };

     

       61
       61
       -
                       }

     

       49
       49
       +
                   const uniqueId = this.extensionIndex++;

     

       50
       50
       +
                   const extensionData = {

     

       51
       51
       +
                     id: ext.id,

     

       52
       52
       +
                     uniqueId,

     

       53
       53
       +
                     manifest: ext,

     

       54
       54
       +
                     source: { type: ExtensionLoadSource.Normal, url: repo },

     

       55
       55
       +
                     state: ExtensionState.NotDownloaded

     

       56
       56
       +
                   };

     

       62
       57
        
       

     

       63
       63
       -
                       this.extensions[ext.id].manifest = ext;

     

       64
       64
       -
                       this.extensions[ext.id].source = {

     

       65
       65
       -
                         type: ExtensionLoadSource.Normal,

     

       66
       66
       -
                         url: repo

     

       58
       58
       +
                   if (this.alreadyExists(extensionData)) {

     

       59
       59
       +
                     if (this.hasUpdate(extensionData)) {

     

       60
       60
       +
                       this.updates[uniqueId] = {

     

       61
       61
       +
                         version: ext.version!,

     

       62
       62
       +
                         download: ext.download

     

       67
       63
        
                       };

     

       68
       68
       -
       

     

       69
       69
       -
                       continue;

     

       70
       64
        
                     }

     

       71
       65
        
       

     

       72
       72
       -
                     this.extensions[ext.id] = {

     

       73
       73
       -
                       id: ext.id,

     

       74
       74
       -
                       manifest: ext,

     

       75
       75
       -
                       source: { type: ExtensionLoadSource.Normal, url: repo },

     

       76
       76
       -
                       state: ExtensionState.NotDownloaded

     

       77
       77
       -
                     };

     

       78
       78
       -
                   } catch (e) {

     

       79
       79
       -
                     logger.error(`Error processing extension ${ext.id}`, e);

     

       66
       66
       +
                     continue;

     

       80
       67
        
                   }

     

       68
       68
       +
       

     

       69
       69
       +
                   this.extensions[uniqueId] = extensionData;

     

       81
       70
        
                 }

     

       82
       71
        
               } catch (e) {

     

       83
       72
        
                 logger.error(`Error processing repository ${repo}`, e);

     
···

       88
       77
        
           });

     

       89
       78
        
         }

     

       90
       79
        
       

     

       91
       91
       -
         // this logic sucks so bad lol

     

       92
       92
       -
         private hasUpdate(

     

       93
       93
       -
           repo: string,

     

       94
       94
       -
           repoExt: RepositoryManifest,

     

       95
       95
       -
           existing: MoonbaseExtension

     

       96
       96
       -
         ) {

     

       80
       80
       +
         private alreadyExists(ext: MoonbaseExtension) {

     

       81
       81
       +
           return Object.values(this.extensions).some(

     

       82
       82
       +
             (e) => e.id === ext.id && e.source.url === ext.source.url

     

       83
       83
       +
           );

     

       84
       84
       +
         }

     

       85
       85
       +
       

     

       86
       86
       +
         private hasUpdate(ext: MoonbaseExtension) {

     

       87
       87
       +
           const existing = Object.values(this.extensions).find(

     

       88
       88
       +
             (e) => e.id === ext.id && e.source.url === ext.source.url

     

       89
       89
       +
           );

     

       90
       90
       +
           if (existing == null) return false;

     

       91
       91
       +
       

     

       97
       92
        
           return (

     

       98
       98
       -
             existing.source.type === ExtensionLoadSource.Normal &&

     

       99
       99
       -
             existing.source.url != null &&

     

       100
       100
       -
             existing.source.url === repo &&

     

       101
       101
       -
             repoExt.version != null &&

     

       102
       102
       -
             existing.manifest.version !== repoExt.version

     

       93
       93
       +
             existing.manifest.version !== ext.manifest.version &&

     

       94
       94
       +
             existing.state !== ExtensionState.NotDownloaded

     

       103
       95
        
           );

     

       104
       96
        
         }

     

       105
       97
        
       

     
···

       118
       110
        
           return this.modified;

     

       119
       111
        
         }

     

       120
       112
        
       

     

       121
       121
       -
         getExtension(id: string) {

     

       122
       122
       -
           return this.extensions[id];

     

       113
       113
       +
         getExtension(uniqueId: number) {

     

       114
       114
       +
           return this.extensions[uniqueId];

     

       123
       115
        
         }

     

       124
       116
        
       

     

       125
       125
       -
         getExtensionName(id: string) {

     

       126
       126
       -
           return Object.prototype.hasOwnProperty.call(this.extensions, id)

     

       127
       127
       -
             ? this.extensions[id].manifest.meta?.name ?? id

     

       128
       128
       -
             : id;

     

       117
       117
       +
         getExtensionUniqueId(id: string) {

     

       118
       118
       +
           return Object.values(this.extensions).find((ext) => ext.id === id)

     

       119
       119
       +
             ?.uniqueId;

     

       120
       120
       +
         }

     

       121
       121
       +
       

     

       122
       122
       +
         getExtensionConflicting(uniqueId: number) {

     

       123
       123
       +
           const ext = this.getExtension(uniqueId);

     

       124
       124
       +
           if (ext.state !== ExtensionState.NotDownloaded) return false;

     

       125
       125
       +
           return Object.values(this.extensions).some(

     

       126
       126
       +
             (e) =>

     

       127
       127
       +
               e.id === ext.id &&

     

       128
       128
       +
               e.uniqueId !== uniqueId &&

     

       129
       129
       +
               e.state !== ExtensionState.NotDownloaded

     

       130
       130
       +
           );

     

       131
       131
       +
         }

     

       132
       132
       +
       

     

       133
       133
       +
         getExtensionName(uniqueId: number) {

     

       134
       134
       +
           const ext = this.getExtension(uniqueId);

     

       135
       135
       +
           return ext.manifest.meta?.name ?? ext.id;

     

       129
       136
        
         }

     

       130
       137
        
       

     

       131
       131
       -
         getExtensionUpdate(id: string) {

     

       132
       132
       -
           return Object.prototype.hasOwnProperty.call(this.updates, id)

     

       133
       133
       -
             ? this.updates[id]

     

       134
       134
       -
             : null;

     

       138
       138
       +
         getExtensionUpdate(uniqueId: number) {

     

       139
       139
       +
           return this.updates[uniqueId]?.version;

     

       135
       140
        
         }

     

       136
       141
        
       

     

       137
       137
       -
         getExtensionEnabled(id: string) {

     

       138
       138
       -
           const val = this.config.extensions[id];

     

       142
       142
       +
         getExtensionEnabled(uniqueId: number) {

     

       143
       143
       +
           const ext = this.getExtension(uniqueId);

     

       144
       144
       +
           if (ext.state === ExtensionState.NotDownloaded) return false;

     

       145
       145
       +
           const val = this.config.extensions[ext.id];

     

       139
       146
        
           if (val == null) return false;

     

       140
       147
        
           return typeof val === "boolean" ? val : val.enabled;

     

       141
       148
        
         }

     

       142
       149
        
       

     

       143
       143
       -
         getExtensionConfig<T>(id: string, key: string): T | undefined {

     

       144
       144
       -
           const defaultValue = this.extensions[id].manifest.settings?.[key]?.default;

     

       150
       150
       +
         getExtensionConfig<T>(uniqueId: number, key: string): T | undefined {

     

       151
       151
       +
           const ext = this.getExtension(uniqueId);

     

       152
       152
       +
           const defaultValue = ext.manifest.settings?.[key]?.default;

     

       145
       153
        
           const clonedDefaultValue = this.clone(defaultValue);

     

       146
       146
       -
           const cfg = this.config.extensions[id];

     

       154
       154
       +
           const cfg = this.config.extensions[ext.id];

     

       147
       155
        
       

     

       148
       156
        
           if (cfg == null || typeof cfg === "boolean") return clonedDefaultValue;

     

       149
       157
        
           return cfg.config?.[key] ?? clonedDefaultValue;

     

       150
       158
        
         }

     

       151
       159
        
       

     

       152
       152
       -
         getExtensionConfigName(id: string, key: string) {

     

       153
       153
       -
           return this.extensions[id].manifest.settings?.[key]?.displayName ?? key;

     

       160
       160
       +
         getExtensionConfigName(uniqueId: number, key: string) {

     

       161
       161
       +
           const ext = this.getExtension(uniqueId);

     

       162
       162
       +
           return ext.manifest.settings?.[key]?.displayName ?? key;

     

       154
       163
        
         }

     

       155
       164
        
       

     

       156
       156
       -
         getExtensionConfigDescription(id: string, key: string) {

     

       157
       157
       -
           return this.extensions[id].manifest.settings?.[key]?.description;

     

       165
       165
       +
         getExtensionConfigDescription(uniqueId: number, key: string) {

     

       166
       166
       +
           const ext = this.getExtension(uniqueId);

     

       167
       167
       +
           return ext.manifest.settings?.[key]?.description;

     

       158
       168
        
         }

     

       159
       169
        
       

     

       160
       160
       -
         setExtensionConfig(id: string, key: string, value: any) {

     

       161
       161
       -
           const oldConfig = this.config.extensions[id];

     

       170
       170
       +
         setExtensionConfig(uniqueId: number, key: string, value: any) {

     

       171
       171
       +
           const ext = this.getExtension(uniqueId);

     

       172
       172
       +
           const oldConfig = this.config.extensions[ext.id];

     

       162
       173
        
           const newConfig =

     

       163
       174
        
             typeof oldConfig === "boolean"

     

       164
       175
        
               ? {

     
···

       170
       181
        
                   config: { ...(oldConfig?.config ?? {}), [key]: value }

     

       171
       182
        
                 };

     

       172
       183
        
       

     

       173
       173
       -
           this.config.extensions[id] = newConfig;

     

       184
       184
       +
           this.config.extensions[ext.id] = newConfig;

     

       174
       185
        
           this.modified = this.isModified();

     

       175
       186
        
           this.emitChange();

     

       176
       187
        
         }

     

       177
       188
        
       

     

       178
       178
       -
         setExtensionEnabled(id: string, enabled: boolean) {

     

       179
       179
       -
           let val = this.config.extensions[id];

     

       189
       189
       +
         setExtensionEnabled(uniqueId: number, enabled: boolean) {

     

       190
       190
       +
           const ext = this.getExtension(uniqueId);

     

       191
       191
       +
           let val = this.config.extensions[ext.id];

     

       180
       192
        
       

     

       181
       193
        
           if (val == null) {

     

       182
       182
       -
             this.config.extensions[id] = { enabled };

     

       194
       194
       +
             this.config.extensions[ext.id] = { enabled };

     

       183
       195
        
             this.modified = this.isModified();

     

       184
       196
        
             this.emitChange();

     

       185
       197
        
             return;

     
···

       191
       203
        
             val.enabled = enabled;

     

       192
       204
        
           }

     

       193
       205
        
       

     

       194
       194
       -
           this.config.extensions[id] = val;

     

       206
       206
       +
           this.config.extensions[ext.id] = val;

     

       195
       207
        
           this.modified = this.isModified();

     

       196
       208
        
           this.emitChange();

     

       197
       209
        
         }

     

       198
       210
        
       

     

       199
       199
       -
         async installExtension(id: string) {

     

       200
       200
       -
           const ext = this.getExtension(id);

     

       211
       211
       +
         async installExtension(uniqueId: number) {

     

       212
       212
       +
           const ext = this.getExtension(uniqueId);

     

       201
       213
        
           if (!("download" in ext.manifest)) {

     

       202
       214
        
             throw new Error("Extension has no download URL");

     

       203
       215
        
           }

     

       204
       216
        
       

     

       205
       217
        
           this.installing = true;

     

       206
       218
        
           try {

     

       207
       207
       -
             const url = this.updates[id]?.download ?? ext.manifest.download;

     

       219
       219
       +
             const url = this.updates[uniqueId]?.download ?? ext.manifest.download;

     

       208
       220
        
             await natives.installExtension(ext.manifest, url, ext.source.url!);

     

       209
       221
        
             if (ext.state === ExtensionState.NotDownloaded) {

     

       210
       210
       -
               this.extensions[id].state = ExtensionState.Disabled;

     

       222
       222
       +
               this.extensions[uniqueId].state = ExtensionState.Disabled;

     

       211
       223
        
             }

     

       212
       224
        
       

     

       213
       213
       -
             delete this.updates[id];

     

       225
       225
       +
             delete this.updates[uniqueId];

     

       214
       226
        
           } catch (e) {

     

       215
       227
        
             logger.error("Error installing extension:", e);

     

       216
       228
        
           }

     
···

       219
       231
        
           this.emitChange();

     

       220
       232
        
         }

     

       221
       233
        
       

     

       222
       222
       -
         async deleteExtension(id: string) {

     

       223
       223
       -
           const ext = this.getExtension(id);

     

       234
       234
       +
         async deleteExtension(uniqueId: number) {

     

       235
       235
       +
           const ext = this.getExtension(uniqueId);

     

       224
       236
        
           if (ext == null) return;

     

       225
       237
        
       

     

       226
       238
        
           this.installing = true;

     

       227
       239
        
           try {

     

       228
       240
        
             await natives.deleteExtension(ext.id);

     

       229
       229
       -
             this.extensions[id].state = ExtensionState.NotDownloaded;

     

       241
       241
       +
             this.extensions[uniqueId].state = ExtensionState.NotDownloaded;

     

       230
       242
        
           } catch (e) {

     

       231
       243
        
             logger.error("Error deleting extension:", e);

     

       232
       244
        
           }

+151

packages/core-extensions/src/moonbase/webpackModules/ui/config/index.tsx

···

       1
       1
       +
       import { LogLevel } from "@moonlight-mod/types";

     

       2
       2
       +
       import { CircleXIconSVG } from "../../../types";

     

       3
       3
       +
       

     

       4
       4
       +
       const logLevels = Object.values(LogLevel).filter(

     

       5
       5
       +
         (v) => typeof v === "string"

     

       6
       6
       +
       ) as string[];

     

       7
       7
       +
       

     

       8
       8
       +
       import React from "@moonlight-mod/wp/common_react";

     

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

     

       10
       10
       +
       import {

     

       11
       11
       +
         FormDivider,

     

       12
       12
       +
         FormItem,

     

       13
       13
       +
         FormText,

     

       14
       14
       +
         FormSwitch,

     

       15
       15
       +
         TextInput,

     

       16
       16
       +
         Flex,

     

       17
       17
       +
         Button,

     

       18
       18
       +
         SingleSelect,

     

       19
       19
       +
         Tooltip,

     

       20
       20
       +
         Clickable

     

       21
       21
       +
       } from "@moonlight-mod/wp/common_components";

     

       22
       22
       +
       

     

       23
       23
       +
       import { MoonbaseSettingsStore } from "@moonlight-mod/wp/moonbase_stores";

     

       24
       24
       +
       

     

       25
       25
       +
       const FormClasses = spacepack.findByCode("dividerDefault:")[0].exports;

     

       26
       26
       +
       const Margins = spacepack.findByCode("marginCenterHorz:")[0].exports;

     

       27
       27
       +
       

     

       28
       28
       +
       const RemoveButtonClasses = spacepack.findByCode("removeButtonContainer")[0]

     

       29
       29
       +
         .exports;

     

       30
       30
       +
       const CircleXIcon = spacepack.findByCode(CircleXIconSVG)[0].exports.default;

     

       31
       31
       +
       function RemoveEntryButton({ onClick }: { onClick: () => void }) {

     

       32
       32
       +
         return (

     

       33
       33
       +
           <div className={RemoveButtonClasses.removeButtonContainer}>

     

       34
       34
       +
             <Tooltip text="Remove entry" position="top">

     

       35
       35
       +
               {(props: any) => (

     

       36
       36
       +
                 <Clickable

     

       37
       37
       +
                   {...props}

     

       38
       38
       +
                   className={RemoveButtonClasses.removeButton}

     

       39
       39
       +
                   onClick={onClick}

     

       40
       40
       +
                 >

     

       41
       41
       +
                   <CircleXIcon width={24} height={24} />

     

       42
       42
       +
                 </Clickable>

     

       43
       43
       +
               )}

     

       44
       44
       +
             </Tooltip>

     

       45
       45
       +
           </div>

     

       46
       46
       +
         );

     

       47
       47
       +
       }

     

       48
       48
       +
       

     

       49
       49
       +
       function ArrayFormItem({

     

       50
       50
       +
         config

     

       51
       51
       +
       }: {

     

       52
       52
       +
         config: "repositories" | "devSearchPaths";

     

       53
       53
       +
       }) {

     

       54
       54
       +
         const items = MoonbaseSettingsStore.getConfigOption(config) ?? [];

     

       55
       55
       +
         return (

     

       56
       56
       +
           <Flex

     

       57
       57
       +
             style={{

     

       58
       58
       +
               gap: "20px"

     

       59
       59
       +
             }}

     

       60
       60
       +
             direction={Flex.Direction.VERTICAL}

     

       61
       61
       +
           >

     

       62
       62
       +
             {items.map((val, i) => (

     

       63
       63
       +
               <div

     

       64
       64
       +
                 key={i}

     

       65
       65
       +
                 style={{

     

       66
       66
       +
                   display: "grid",

     

       67
       67
       +
                   height: "32px",

     

       68
       68
       +
                   gap: "8px",

     

       69
       69
       +
                   gridTemplateColumns: "1fr 32px",

     

       70
       70
       +
                   alignItems: "center"

     

       71
       71
       +
                 }}

     

       72
       72
       +
               >

     

       73
       73
       +
                 <TextInput

     

       74
       74
       +
                   size={TextInput.Sizes.DEFAULT}

     

       75
       75
       +
                   value={val}

     

       76
       76
       +
                   onChange={(newVal: string) => {

     

       77
       77
       +
                     items[i] = newVal;

     

       78
       78
       +
                     MoonbaseSettingsStore.setConfigOption(config, items);

     

       79
       79
       +
                   }}

     

       80
       80
       +
                 />

     

       81
       81
       +
                 <RemoveEntryButton

     

       82
       82
       +
                   onClick={() => {

     

       83
       83
       +
                     items.splice(i, 1);

     

       84
       84
       +
                     MoonbaseSettingsStore.setConfigOption(config, items);

     

       85
       85
       +
                   }}

     

       86
       86
       +
                 />

     

       87
       87
       +
               </div>

     

       88
       88
       +
             ))}

     

       89
       89
       +
       

     

       90
       90
       +
             <Button

     

       91
       91
       +
               look={Button.Looks.FILLED}

     

       92
       92
       +
               color={Button.Colors.GREEN}

     

       93
       93
       +
               size={Button.Sizes.SMALL}

     

       94
       94
       +
               style={{

     

       95
       95
       +
                 marginTop: "10px"

     

       96
       96
       +
               }}

     

       97
       97
       +
               onClick={() => {

     

       98
       98
       +
                 items.push("");

     

       99
       99
       +
                 MoonbaseSettingsStore.setConfigOption(config, items);

     

       100
       100
       +
               }}

     

       101
       101
       +
             >

     

       102
       102
       +
               Add new entry

     

       103
       103
       +
             </Button>

     

       104
       104
       +
           </Flex>

     

       105
       105
       +
         );

     

       106
       106
       +
       }

     

       107
       107
       +
       

     

       108
       108
       +
       export default function ConfigPage() {

     

       109
       109
       +
         return (

     

       110
       110
       +
           <>

     

       111
       111
       +
             <FormItem title="Repositories">

     

       112
       112
       +
               <FormText className={Margins.marginBottom4}>

     

       113
       113
       +
                 A list of remote repositories to display extensions from

     

       114
       114
       +
               </FormText>

     

       115
       115
       +
               <ArrayFormItem config="repositories" />

     

       116
       116
       +
             </FormItem>

     

       117
       117
       +
             <FormDivider className={FormClasses.dividerDefault} />

     

       118
       118
       +
             <FormItem title="Extension search paths" className={Margins.marginTop20}>

     

       119
       119
       +
               <FormText className={Margins.marginBottom4}>

     

       120
       120
       +
                 A list of local directories to search for built extensions

     

       121
       121
       +
               </FormText>

     

       122
       122
       +
               <ArrayFormItem config="devSearchPaths" />

     

       123
       123
       +
             </FormItem>

     

       124
       124
       +
             <FormDivider className={FormClasses.dividerDefault} />

     

       125
       125
       +
             <FormSwitch

     

       126
       126
       +
               className={Margins.marginTop20}

     

       127
       127
       +
               value={MoonbaseSettingsStore.getConfigOption("patchAll")}

     

       128
       128
       +
               onChange={(value: boolean) => {

     

       129
       129
       +
                 MoonbaseSettingsStore.setConfigOption("patchAll", value);

     

       130
       130
       +
               }}

     

       131
       131
       +
               note="Wraps every webpack module in a function, separating them in DevTools"

     

       132
       132
       +
             >

     

       133
       133
       +
               Patch all

     

       134
       134
       +
             </FormSwitch>

     

       135
       135
       +
             <FormItem title="Log level">

     

       136
       136
       +
               <SingleSelect

     

       137
       137
       +
                 autofocus={false}

     

       138
       138
       +
                 clearable={false}

     

       139
       139
       +
                 value={MoonbaseSettingsStore.getConfigOption("loggerLevel")}

     

       140
       140
       +
                 options={logLevels.map((o) => ({

     

       141
       141
       +
                   value: o.toLowerCase(),

     

       142
       142
       +
                   label: o[0] + o.slice(1).toLowerCase()

     

       143
       143
       +
                 }))}

     

       144
       144
       +
                 onChange={(v) =>

     

       145
       145
       +
                   MoonbaseSettingsStore.setConfigOption("loggerLevel", v)

     

       146
       146
       +
                 }

     

       147
       147
       +
               />

     

       148
       148
       +
             </FormItem>

     

       149
       149
       +
           </>

     

       150
       150
       +
         );

     

       151
       151
       +
       }

+220

packages/core-extensions/src/moonbase/webpackModules/ui/extensions/card.tsx

···

       1
       1
       +
       import {

     

       2
       2
       +
         DangerIconSVG,

     

       3
       3
       +
         DownloadIconSVG,

     

       4
       4
       +
         ExtensionState,

     

       5
       5
       +
         TrashIconSVG

     

       6
       6
       +
       } from "../../../types";

     

       7
       7
       +
       import { ExtensionLoadSource } from "@moonlight-mod/types";

     

       8
       8
       +
       

     

       9
       9
       +
       import React from "@moonlight-mod/wp/common_react";

     

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

     

       11
       11
       +
       import CommonComponents from "@moonlight-mod/wp/common_components";

     

       12
       12
       +
       import * as Flux from "@moonlight-mod/wp/common_flux";

     

       13
       13
       +
       

     

       14
       14
       +
       import ExtensionInfo from "./info";

     

       15
       15
       +
       import Settings from "./settings";

     

       16
       16
       +
       

     

       17
       17
       +
       export enum ExtensionPage {

     

       18
       18
       +
         Info,

     

       19
       19
       +
         Description,

     

       20
       20
       +
         Settings

     

       21
       21
       +
       }

     

       22
       22
       +
       

     

       23
       23
       +
       import { MoonbaseSettingsStore } from "@moonlight-mod/wp/moonbase_stores";

     

       24
       24
       +
       

     

       25
       25
       +
       const UserProfileClasses = spacepack.findByCode(

     

       26
       26
       +
         "tabBarContainer",

     

       27
       27
       +
         "topSection"

     

       28
       28
       +
       )[0].exports;

     

       29
       29
       +
       

     

       30
       30
       +
       const DownloadIcon =

     

       31
       31
       +
         spacepack.findByCode(DownloadIconSVG)[0].exports.DownloadIcon;

     

       32
       32
       +
       const TrashIcon = spacepack.findByCode(TrashIconSVG)[0].exports.default;

     

       33
       33
       +
       const DangerIcon =

     

       34
       34
       +
         spacepack.findByCode(DangerIconSVG)[0].exports.CircleExclamationPointIcon;

     

       35
       35
       +
       

     

       36
       36
       +
       const PanelButton =

     

       37
       37
       +
         spacepack.findByCode("Masks.PANEL_BUTTON")[0].exports.default;

     

       38
       38
       +
       

     

       39
       39
       +
       export default function ExtensionCard({ uniqueId }: { uniqueId: number }) {

     

       40
       40
       +
         const [tab, setTab] = React.useState(ExtensionPage.Info);

     

       41
       41
       +
         const [restartNeeded, setRestartNeeded] = React.useState(false);

     

       42
       42
       +
       

     

       43
       43
       +
         const { ext, enabled, busy, update, conflicting } = Flux.useStateFromStores(

     

       44
       44
       +
           [MoonbaseSettingsStore],

     

       45
       45
       +
           () => {

     

       46
       46
       +
             return {

     

       47
       47
       +
               ext: MoonbaseSettingsStore.getExtension(uniqueId),

     

       48
       48
       +
               enabled: MoonbaseSettingsStore.getExtensionEnabled(uniqueId),

     

       49
       49
       +
               busy: MoonbaseSettingsStore.busy,

     

       50
       50
       +
               update: MoonbaseSettingsStore.getExtensionUpdate(uniqueId),

     

       51
       51
       +
               conflicting: MoonbaseSettingsStore.getExtensionConflicting(uniqueId)

     

       52
       52
       +
             };

     

       53
       53
       +
           }

     

       54
       54
       +
         );

     

       55
       55
       +
       

     

       56
       56
       +
         // Why it work like that :sob:

     

       57
       57
       +
         if (ext == null) return <></>;

     

       58
       58
       +
       

     

       59
       59
       +
         const {

     

       60
       60
       +
           Card,

     

       61
       61
       +
           CardClasses,

     

       62
       62
       +
           Flex,

     

       63
       63
       +
           Text,

     

       64
       64
       +
           MarkdownParser,

     

       65
       65
       +
           Switch,

     

       66
       66
       +
           TabBar,

     

       67
       67
       +
           Button

     

       68
       68
       +
         } = CommonComponents;

     

       69
       69
       +
       

     

       70
       70
       +
         const tagline = ext.manifest?.meta?.tagline;

     

       71
       71
       +
         const settings = ext.manifest?.settings;

     

       72
       72
       +
         const description = ext.manifest?.meta?.description;

     

       73
       73
       +
       

     

       74
       74
       +
         return (

     

       75
       75
       +
           <Card editable={true} className={CardClasses.card}>

     

       76
       76
       +
             <div className={CardClasses.cardHeader}>

     

       77
       77
       +
               <Flex direction={Flex.Direction.VERTICAL}>

     

       78
       78
       +
                 <Flex direction={Flex.Direction.HORIZONTAL}>

     

       79
       79
       +
                   <Text variant="text-md/semibold">

     

       80
       80
       +
                     {ext.manifest?.meta?.name ?? ext.id}

     

       81
       81
       +
                   </Text>

     

       82
       82
       +
                 </Flex>

     

       83
       83
       +
       

     

       84
       84
       +
                 {tagline != null && (

     

       85
       85
       +
                   <Text variant="text-sm/normal">

     

       86
       86
       +
                     {MarkdownParser.parse(tagline)}

     

       87
       87
       +
                   </Text>

     

       88
       88
       +
                 )}

     

       89
       89
       +
               </Flex>

     

       90
       90
       +
       

     

       91
       91
       +
               <Flex

     

       92
       92
       +
                 direction={Flex.Direction.HORIZONTAL}

     

       93
       93
       +
                 align={Flex.Align.END}

     

       94
       94
       +
                 justify={Flex.Justify.END}

     

       95
       95
       +
               >

     

       96
       96
       +
                 {ext.state === ExtensionState.NotDownloaded ? (

     

       97
       97
       +
                   <Button

     

       98
       98
       +
                     color={Button.Colors.BRAND}

     

       99
       99
       +
                     submitting={busy}

     

       100
       100
       +
                     disabled={conflicting}

     

       101
       101
       +
                     onClick={() => {

     

       102
       102
       +
                       MoonbaseSettingsStore.installExtension(uniqueId);

     

       103
       103
       +
                     }}

     

       104
       104
       +
                   >

     

       105
       105
       +
                     Install

     

       106
       106
       +
                   </Button>

     

       107
       107
       +
                 ) : (

     

       108
       108
       +
                   <div

     

       109
       109
       +
                     // too lazy to learn how <Flex /> works lmao

     

       110
       110
       +
                     style={{

     

       111
       111
       +
                       display: "flex",

     

       112
       112
       +
                       alignItems: "center",

     

       113
       113
       +
                       gap: "1rem"

     

       114
       114
       +
                     }}

     

       115
       115
       +
                   >

     

       116
       116
       +
                     {ext.source.type === ExtensionLoadSource.Normal && (

     

       117
       117
       +
                       <PanelButton

     

       118
       118
       +
                         icon={TrashIcon}

     

       119
       119
       +
                         tooltipText="Delete"

     

       120
       120
       +
                         onClick={() => {

     

       121
       121
       +
                           MoonbaseSettingsStore.deleteExtension(uniqueId);

     

       122
       122
       +
                         }}

     

       123
       123
       +
                       />

     

       124
       124
       +
                     )}

     

       125
       125
       +
       

     

       126
       126
       +
                     {update != null && (

     

       127
       127
       +
                       <PanelButton

     

       128
       128
       +
                         icon={DownloadIcon}

     

       129
       129
       +
                         tooltipText="Update"

     

       130
       130
       +
                         onClick={() => {

     

       131
       131
       +
                           MoonbaseSettingsStore.installExtension(uniqueId);

     

       132
       132
       +
                         }}

     

       133
       133
       +
                       />

     

       134
       134
       +
                     )}

     

       135
       135
       +
       

     

       136
       136
       +
                     {restartNeeded && (

     

       137
       137
       +
                       <PanelButton

     

       138
       138
       +
                         icon={() => (

     

       139
       139
       +
                           <DangerIcon

     

       140
       140
       +
                             color={CommonComponents.tokens.colors.STATUS_DANGER}

     

       141
       141
       +
                           />

     

       142
       142
       +
                         )}

     

       143
       143
       +
                         onClick={() => window.location.reload()}

     

       144
       144
       +
                         tooltipText="You will need to reload/restart your client for this extension to work properly."

     

       145
       145
       +
                       />

     

       146
       146
       +
                     )}

     

       147
       147
       +
       

     

       148
       148
       +
                     <Switch

     

       149
       149
       +
                       checked={enabled}

     

       150
       150
       +
                       onChange={() => {

     

       151
       151
       +
                         setRestartNeeded(true);

     

       152
       152
       +
                         MoonbaseSettingsStore.setExtensionEnabled(uniqueId, !enabled);

     

       153
       153
       +
                       }}

     

       154
       154
       +
                     />

     

       155
       155
       +
                   </div>

     

       156
       156
       +
                 )}

     

       157
       157
       +
               </Flex>

     

       158
       158
       +
             </div>

     

       159
       159
       +
       

     

       160
       160
       +
             <div className={UserProfileClasses.body}>

     

       161
       161
       +
               {(description != null || settings != null) && (

     

       162
       162
       +
                 <div

     

       163
       163
       +
                   className={UserProfileClasses.tabBarContainer}

     

       164
       164
       +
                   style={{

     

       165
       165
       +
                     padding: "0 10px"

     

       166
       166
       +
                   }}

     

       167
       167
       +
                 >

     

       168
       168
       +
                   <TabBar

     

       169
       169
       +
                     selectedItem={tab}

     

       170
       170
       +
                     type="top"

     

       171
       171
       +
                     onItemSelect={setTab}

     

       172
       172
       +
                     className={UserProfileClasses.tabBar}

     

       173
       173
       +
                   >

     

       174
       174
       +
                     <TabBar.Item

     

       175
       175
       +
                       className={UserProfileClasses.tabBarItem}

     

       176
       176
       +
                       id={ExtensionPage.Info}

     

       177
       177
       +
                     >

     

       178
       178
       +
                       Info

     

       179
       179
       +
                     </TabBar.Item>

     

       180
       180
       +
       

     

       181
       181
       +
                     {description != null && (

     

       182
       182
       +
                       <TabBar.Item

     

       183
       183
       +
                         className={UserProfileClasses.tabBarItem}

     

       184
       184
       +
                         id={ExtensionPage.Description}

     

       185
       185
       +
                       >

     

       186
       186
       +
                         Description

     

       187
       187
       +
                       </TabBar.Item>

     

       188
       188
       +
                     )}

     

       189
       189
       +
       

     

       190
       190
       +
                     {settings != null && (

     

       191
       191
       +
                       <TabBar.Item

     

       192
       192
       +
                         className={UserProfileClasses.tabBarItem}

     

       193
       193
       +
                         id={ExtensionPage.Settings}

     

       194
       194
       +
                       >

     

       195
       195
       +
                         Settings

     

       196
       196
       +
                       </TabBar.Item>

     

       197
       197
       +
                     )}

     

       198
       198
       +
                   </TabBar>

     

       199
       199
       +
                 </div>

     

       200
       200
       +
               )}

     

       201
       201
       +
       

     

       202
       202
       +
               <Flex

     

       203
       203
       +
                 justify={Flex.Justify.START}

     

       204
       204
       +
                 wrap={Flex.Wrap.WRAP}

     

       205
       205
       +
                 style={{

     

       206
       206
       +
                   padding: "16px 16px"

     

       207
       207
       +
                 }}

     

       208
       208
       +
               >

     

       209
       209
       +
                 {tab === ExtensionPage.Info && <ExtensionInfo ext={ext} />}

     

       210
       210
       +
                 {tab === ExtensionPage.Description && (

     

       211
       211
       +
                   <Text variant="text-md/normal">

     

       212
       212
       +
                     {MarkdownParser.parse(description ?? "*No description*")}

     

       213
       213
       +
                   </Text>

     

       214
       214
       +
                 )}

     

       215
       215
       +
                 {tab === ExtensionPage.Settings && <Settings ext={ext} />}

     

       216
       216
       +
               </Flex>

     

       217
       217
       +
             </div>

     

       218
       218
       +
           </Card>

     

       219
       219
       +
         );

     

       220
       220
       +
       }

+370

packages/core-extensions/src/moonbase/webpackModules/ui/extensions/filterBar.tsx

···

       1
       1
       +
       import { tagNames } from "./info";

     

       2
       2
       +
       import {

     

       3
       3
       +
         ArrowsUpDownIconSVG,

     

       4
       4
       +
         ChevronSmallDownIconSVG,

     

       5
       5
       +
         ChevronSmallUpIconSVG

     

       6
       6
       +
       } from "../../../types";

     

       7
       7
       +
       

     

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

     

       9
       9
       +
       import React from "@moonlight-mod/wp/common_react";

     

       10
       10
       +
       import * as Flux from "@moonlight-mod/wp/common_flux";

     

       11
       11
       +
       import { WindowStore } from "@moonlight-mod/wp/common_stores";

     

       12
       12
       +
       import {

     

       13
       13
       +
         Button,

     

       14
       14
       +
         Text,

     

       15
       15
       +
         Heading,

     

       16
       16
       +
         Popout,

     

       17
       17
       +
         Dialog,

     

       18
       18
       +
         Menu,

     

       19
       19
       +
         MenuGroup,

     

       20
       20
       +
         MenuCheckboxItem,

     

       21
       21
       +
         MenuItem

     

       22
       22
       +
       } from "@moonlight-mod/wp/common_components";

     

       23
       23
       +
       

     

       24
       24
       +
       export enum Filter {

     

       25
       25
       +
         Core = 1 << 0,

     

       26
       26
       +
         Normal = 1 << 1,

     

       27
       27
       +
         Developer = 1 << 2,

     

       28
       28
       +
         Enabled = 1 << 3,

     

       29
       29
       +
         Disabled = 1 << 4,

     

       30
       30
       +
         Installed = 1 << 5,

     

       31
       31
       +
         Repository = 1 << 6

     

       32
       32
       +
       }

     

       33
       33
       +
       export const defaultFilter = ~(~0 << 7);

     

       34
       34
       +
       

     

       35
       35
       +
       const modPromise = spacepack.lazyLoad(

     

       36
       36
       +
         '"Missing channel in Channel.openChannelContextMenu"',

     

       37
       37
       +
         /e\("(\d+)"\)/g,

     

       38
       38
       +
         /webpackId:"(.+?)"/

     

       39
       39
       +
       );

     

       40
       40
       +
       

     

       41
       41
       +
       const Margins = spacepack.findByCode("marginCenterHorz:")[0].exports;

     

       42
       42
       +
       const SortMenuClasses = spacepack.findByCode("container:", "clearText:")[0]

     

       43
       43
       +
         .exports;

     

       44
       44
       +
       const FilterDialogClasses = spacepack.findByCode(

     

       45
       45
       +
         "countContainer:",

     

       46
       46
       +
         "tagContainer:"

     

       47
       47
       +
       )[0].exports;

     

       48
       48
       +
       const FilterBarClasses = spacepack.findByCode("tagsButtonWithCount:")[0]

     

       49
       49
       +
         .exports;

     

       50
       50
       +
       

     

       51
       51
       +
       const TagItem = spacepack.findByCode(".FORUM_TAG_A11Y_FILTER_BY_TAG")[0].exports

     

       52
       52
       +
         .default;

     

       53
       53
       +
       

     

       54
       54
       +
       const ChevronSmallDownIcon = spacepack.findByCode(ChevronSmallDownIconSVG)[0]

     

       55
       55
       +
         .exports.default;

     

       56
       56
       +
       const ChevronSmallUpIcon = spacepack.findByCode(ChevronSmallUpIconSVG)[0]

     

       57
       57
       +
         .exports.default;

     

       58
       58
       +
       let ArrowsUpDownIcon: React.FunctionComponent;

     

       59
       59
       +
       

     

       60
       60
       +
       function toggleTag(

     

       61
       61
       +
         selectedTags: Set<string>,

     

       62
       62
       +
         setSelectedTags: (tags: Set<string>) => void,

     

       63
       63
       +
         tag: string

     

       64
       64
       +
       ) {

     

       65
       65
       +
         const newState = new Set(selectedTags);

     

       66
       66
       +
         if (newState.has(tag)) newState.delete(tag);

     

       67
       67
       +
         else newState.add(tag);

     

       68
       68
       +
         setSelectedTags(newState);

     

       69
       69
       +
       }

     

       70
       70
       +
       

     

       71
       71
       +
       function FilterButtonPopout({

     

       72
       72
       +
         filter,

     

       73
       73
       +
         setFilter,

     

       74
       74
       +
         closePopout

     

       75
       75
       +
       }: {

     

       76
       76
       +
         filter: Filter;

     

       77
       77
       +
         setFilter: (filter: Filter) => void;

     

       78
       78
       +
         closePopout: () => void;

     

       79
       79
       +
       }) {

     

       80
       80
       +
         const toggleFilter = (set: Filter) =>

     

       81
       81
       +
           setFilter(filter & set ? filter & ~set : filter | set);

     

       82
       82
       +
       

     

       83
       83
       +
         return (

     

       84
       84
       +
           <div className={SortMenuClasses.container}>

     

       85
       85
       +
             <Menu navId="sort-filter" hideScrollbar={true} onClose={closePopout}>

     

       86
       86
       +
               <MenuGroup label="Type">

     

       87
       87
       +
                 <MenuCheckboxItem

     

       88
       88
       +
                   id="t-core"

     

       89
       89
       +
                   label="Core"

     

       90
       90
       +
                   checked={filter & Filter.Core}

     

       91
       91
       +
                   action={() => toggleFilter(Filter.Core)}

     

       92
       92
       +
                 />

     

       93
       93
       +
                 <MenuCheckboxItem

     

       94
       94
       +
                   id="t-normal"

     

       95
       95
       +
                   label="Normal"

     

       96
       96
       +
                   checked={filter & Filter.Normal}

     

       97
       97
       +
                   action={() => toggleFilter(Filter.Normal)}

     

       98
       98
       +
                 />

     

       99
       99
       +
                 <MenuCheckboxItem

     

       100
       100
       +
                   id="t-developer"

     

       101
       101
       +
                   label="Developer"

     

       102
       102
       +
                   checked={filter & Filter.Developer}

     

       103
       103
       +
                   action={() => toggleFilter(Filter.Developer)}

     

       104
       104
       +
                 />

     

       105
       105
       +
               </MenuGroup>

     

       106
       106
       +
               <MenuGroup label="State">

     

       107
       107
       +
                 <MenuCheckboxItem

     

       108
       108
       +
                   id="s-enabled"

     

       109
       109
       +
                   label="Enabled"

     

       110
       110
       +
                   checked={filter & Filter.Enabled}

     

       111
       111
       +
                   action={() => toggleFilter(Filter.Enabled)}

     

       112
       112
       +
                 />

     

       113
       113
       +
                 <MenuCheckboxItem

     

       114
       114
       +
                   id="s-disabled"

     

       115
       115
       +
                   label="Disabled"

     

       116
       116
       +
                   checked={filter & Filter.Disabled}

     

       117
       117
       +
                   action={() => toggleFilter(Filter.Disabled)}

     

       118
       118
       +
                 />

     

       119
       119
       +
               </MenuGroup>

     

       120
       120
       +
               <MenuGroup label="Location">

     

       121
       121
       +
                 <MenuCheckboxItem

     

       122
       122
       +
                   id="l-installed"

     

       123
       123
       +
                   label="Installed"

     

       124
       124
       +
                   checked={filter & Filter.Installed}

     

       125
       125
       +
                   action={() => toggleFilter(Filter.Installed)}

     

       126
       126
       +
                 />

     

       127
       127
       +
                 <MenuCheckboxItem

     

       128
       128
       +
                   id="l-repository"

     

       129
       129
       +
                   label="Repository"

     

       130
       130
       +
                   checked={filter & Filter.Repository}

     

       131
       131
       +
                   action={() => toggleFilter(Filter.Repository)}

     

       132
       132
       +
                 />

     

       133
       133
       +
               </MenuGroup>

     

       134
       134
       +
               <MenuGroup>

     

       135
       135
       +
                 <MenuItem

     

       136
       136
       +
                   id="reset-all"

     

       137
       137
       +
                   className={SortMenuClasses.clearText}

     

       138
       138
       +
                   label={

     

       139
       139
       +
                     <Text variant="text-sm/medium" color="none">

     

       140
       140
       +
                       Reset to default

     

       141
       141
       +
                     </Text>

     

       142
       142
       +
                   }

     

       143
       143
       +
                   action={() => {

     

       144
       144
       +
                     setFilter(defaultFilter);

     

       145
       145
       +
                     closePopout();

     

       146
       146
       +
                   }}

     

       147
       147
       +
                 />

     

       148
       148
       +
               </MenuGroup>

     

       149
       149
       +
             </Menu>

     

       150
       150
       +
           </div>

     

       151
       151
       +
         );

     

       152
       152
       +
       }

     

       153
       153
       +
       

     

       154
       154
       +
       function TagButtonPopout({

     

       155
       155
       +
         selectedTags,

     

       156
       156
       +
         setSelectedTags,

     

       157
       157
       +
         setPopoutRef,

     

       158
       158
       +
         closePopout

     

       159
       159
       +
       }: any) {

     

       160
       160
       +
         return (

     

       161
       161
       +
           <Dialog ref={setPopoutRef} className={FilterDialogClasses.container}>

     

       162
       162
       +
             <div className={FilterDialogClasses.header}>

     

       163
       163
       +
               <div className={FilterDialogClasses.headerLeft}>

     

       164
       164
       +
                 <Heading

     

       165
       165
       +
                   color="interactive-normal"

     

       166
       166
       +
                   variant="text-xs/bold"

     

       167
       167
       +
                   className={FilterDialogClasses.headerText}

     

       168
       168
       +
                 >

     

       169
       169
       +
                   Select tags

     

       170
       170
       +
                 </Heading>

     

       171
       171
       +
                 <div className={FilterDialogClasses.countContainer}>

     

       172
       172
       +
                   <Text

     

       173
       173
       +
                     className={FilterDialogClasses.countText}

     

       174
       174
       +
                     color="none"

     

       175
       175
       +
                     variant="text-xs/medium"

     

       176
       176
       +
                   >

     

       177
       177
       +
                     {selectedTags.size}

     

       178
       178
       +
                   </Text>

     

       179
       179
       +
                 </div>

     

       180
       180
       +
               </div>

     

       181
       181
       +
             </div>

     

       182
       182
       +
             <div className={FilterDialogClasses.tagContainer}>

     

       183
       183
       +
               {Object.keys(tagNames).map((tag) => (

     

       184
       184
       +
                 <TagItem

     

       185
       185
       +
                   key={tag}

     

       186
       186
       +
                   className={FilterDialogClasses.tag}

     

       187
       187
       +
                   tag={{ name: tagNames[tag as keyof typeof tagNames] }}

     

       188
       188
       +
                   onClick={() => toggleTag(selectedTags, setSelectedTags, tag)}

     

       189
       189
       +
                   selected={selectedTags.has(tag)}

     

       190
       190
       +
                 />

     

       191
       191
       +
               ))}

     

       192
       192
       +
             </div>

     

       193
       193
       +
             <div className={FilterDialogClasses.separator} />

     

       194
       194
       +
             <Button

     

       195
       195
       +
               look={Button.Looks.LINK}

     

       196
       196
       +
               size={Button.Sizes.MIN}

     

       197
       197
       +
               color={Button.Colors.CUSTOM}

     

       198
       198
       +
               className={FilterDialogClasses.clear}

     

       199
       199
       +
               onClick={() => {

     

       200
       200
       +
                 setSelectedTags(new Set());

     

       201
       201
       +
                 closePopout();

     

       202
       202
       +
               }}

     

       203
       203
       +
             >

     

       204
       204
       +
               <Text variant="text-sm/medium" color="text-link">

     

       205
       205
       +
                 Clear all

     

       206
       206
       +
               </Text>

     

       207
       207
       +
             </Button>

     

       208
       208
       +
           </Dialog>

     

       209
       209
       +
         );

     

       210
       210
       +
       }

     

       211
       211
       +
       

     

       212
       212
       +
       function FilterBar({

     

       213
       213
       +
         filter,

     

       214
       214
       +
         setFilter,

     

       215
       215
       +
         selectedTags,

     

       216
       216
       +
         setSelectedTags

     

       217
       217
       +
       }: {

     

       218
       218
       +
         filter: Filter;

     

       219
       219
       +
         setFilter: (filter: Filter) => void;

     

       220
       220
       +
         selectedTags: Set<string>;

     

       221
       221
       +
         setSelectedTags: (tags: Set<string>) => void;

     

       222
       222
       +
       }) {

     

       223
       223
       +
         const windowSize = Flux.useStateFromStores([WindowStore], () =>

     

       224
       224
       +
           WindowStore.windowSize()

     

       225
       225
       +
         );

     

       226
       226
       +
       

     

       227
       227
       +
         const tagsContainer = React.useRef<HTMLDivElement>(null);

     

       228
       228
       +
         const tagListInner = React.useRef<HTMLDivElement>(null);

     

       229
       229
       +
         const [tagsButtonOffset, setTagsButtonOffset] = React.useState(0);

     

       230
       230
       +
         React.useLayoutEffect(() => {

     

       231
       231
       +
           if (tagsContainer.current === null || tagListInner.current === null) return;

     

       232
       232
       +
           const { left: containerX, top: containerY } =

     

       233
       233
       +
             tagsContainer.current.getBoundingClientRect();

     

       234
       234
       +
           let offset = 0;

     

       235
       235
       +
           for (const child of tagListInner.current.children) {

     

       236
       236
       +
             const {

     

       237
       237
       +
               right: childX,

     

       238
       238
       +
               top: childY,

     

       239
       239
       +
               height

     

       240
       240
       +
             } = child.getBoundingClientRect();

     

       241
       241
       +
             if (childY - containerY > height) break;

     

       242
       242
       +
             const newOffset = childX - containerX;

     

       243
       243
       +
             if (newOffset > offset) {

     

       244
       244
       +
               offset = newOffset;

     

       245
       245
       +
             }

     

       246
       246
       +
           }

     

       247
       247
       +
           setTagsButtonOffset(offset);

     

       248
       248
       +
         }, [windowSize]);

     

       249
       249
       +
       

     

       250
       250
       +
         return (

     

       251
       251
       +
           <div

     

       252
       252
       +
             ref={tagsContainer}

     

       253
       253
       +
             style={{

     

       254
       254
       +
               paddingTop: "12px"

     

       255
       255
       +
             }}

     

       256
       256
       +
             className={`${FilterBarClasses.tagsContainer} ${Margins.marginBottom8}`}

     

       257
       257
       +
           >

     

       258
       258
       +
             <Popout

     

       259
       259
       +
               renderPopout={({ closePopout }: any) => (

     

       260
       260
       +
                 <FilterButtonPopout

     

       261
       261
       +
                   filter={filter}

     

       262
       262
       +
                   setFilter={setFilter}

     

       263
       263
       +
                   closePopout={closePopout}

     

       264
       264
       +
                 />

     

       265
       265
       +
               )}

     

       266
       266
       +
               position="bottom"

     

       267
       267
       +
               align="left"

     

       268
       268
       +
             >

     

       269
       269
       +
               {(props: any, { isShown }: { isShown: boolean }) => (

     

       270
       270
       +
                 <Button

     

       271
       271
       +
                   {...props}

     

       272
       272
       +
                   size={Button.Sizes.MIN}

     

       273
       273
       +
                   color={Button.Colors.CUSTOM}

     

       274
       274
       +
                   className={FilterBarClasses.sortDropdown}

     

       275
       275
       +
                   innerClassName={FilterBarClasses.sortDropdownInner}

     

       276
       276
       +
                 >

     

       277
       277
       +
                   <ArrowsUpDownIcon />

     

       278
       278
       +
                   <Text

     

       279
       279
       +
                     className={FilterBarClasses.sortDropdownText}

     

       280
       280
       +
                     variant="text-sm/medium"

     

       281
       281
       +
                     color="interactive-normal"

     

       282
       282
       +
                   >

     

       283
       283
       +
                     Sort & filter

     

       284
       284
       +
                   </Text>

     

       285
       285
       +
                   {isShown ? (

     

       286
       286
       +
                     <ChevronSmallUpIcon size={20} />

     

       287
       287
       +
                   ) : (

     

       288
       288
       +
                     <ChevronSmallDownIcon size={20} />

     

       289
       289
       +
                   )}

     

       290
       290
       +
                 </Button>

     

       291
       291
       +
               )}

     

       292
       292
       +
             </Popout>

     

       293
       293
       +
             <div className={FilterBarClasses.divider} />

     

       294
       294
       +
             <div className={FilterBarClasses.tagList}>

     

       295
       295
       +
               <div ref={tagListInner} className={FilterBarClasses.tagListInner}>

     

       296
       296
       +
                 {Object.keys(tagNames).map((tag) => (

     

       297
       297
       +
                   <TagItem

     

       298
       298
       +
                     key={tag}

     

       299
       299
       +
                     className={FilterBarClasses.tag}

     

       300
       300
       +
                     tag={{ name: tagNames[tag as keyof typeof tagNames] }}

     

       301
       301
       +
                     onClick={() => toggleTag(selectedTags, setSelectedTags, tag)}

     

       302
       302
       +
                     selected={selectedTags.has(tag)}

     

       303
       303
       +
                   />

     

       304
       304
       +
                 ))}

     

       305
       305
       +
               </div>

     

       306
       306
       +
             </div>

     

       307
       307
       +
             <Popout

     

       308
       308
       +
               renderPopout={({ setPopoutRef, closePopout }: any) => (

     

       309
       309
       +
                 <TagButtonPopout

     

       310
       310
       +
                   selectedTags={selectedTags}

     

       311
       311
       +
                   setSelectedTags={setSelectedTags}

     

       312
       312
       +
                   setPopoutRef={setPopoutRef}

     

       313
       313
       +
                   closePopout={closePopout}

     

       314
       314
       +
                 />

     

       315
       315
       +
               )}

     

       316
       316
       +
               position="bottom"

     

       317
       317
       +
               align="right"

     

       318
       318
       +
             >

     

       319
       319
       +
               {(props: any, { isShown }: { isShown: boolean }) => (

     

       320
       320
       +
                 <Button

     

       321
       321
       +
                   {...props}

     

       322
       322
       +
                   size={Button.Sizes.MIN}

     

       323
       323
       +
                   color={Button.Colors.CUSTOM}

     

       324
       324
       +
                   style={{

     

       325
       325
       +
                     left: tagsButtonOffset

     

       326
       326
       +
                   }}

     

       327
       327
       +
                   // TODO: Use Discord's class name utility

     

       328
       328
       +
                   className={`${FilterBarClasses.tagsButton} ${

     

       329
       329
       +
                     selectedTags.size > 0 ? FilterBarClasses.tagsButtonWithCount : ""

     

       330
       330
       +
                   }`}

     

       331
       331
       +
                   innerClassName={FilterBarClasses.tagsButtonInner}

     

       332
       332
       +
                 >

     

       333
       333
       +
                   {selectedTags.size > 0 ? (

     

       334
       334
       +
                     <div

     

       335
       335
       +
                       style={{ boxSizing: "content-box" }}

     

       336
       336
       +
                       className={FilterBarClasses.countContainer}

     

       337
       337
       +
                     >

     

       338
       338
       +
                       <Text

     

       339
       339
       +
                         className={FilterBarClasses.countText}

     

       340
       340
       +
                         color="none"

     

       341
       341
       +
                         variant="text-xs/medium"

     

       342
       342
       +
                       >

     

       343
       343
       +
                         {selectedTags.size}

     

       344
       344
       +
                       </Text>

     

       345
       345
       +
                     </div>

     

       346
       346
       +
                   ) : (

     

       347
       347
       +
                     <>All</>

     

       348
       348
       +
                   )}

     

       349
       349
       +
                   {isShown ? (

     

       350
       350
       +
                     <ChevronSmallUpIcon size={20} />

     

       351
       351
       +
                   ) : (

     

       352
       352
       +
                     <ChevronSmallDownIcon size={20} />

     

       353
       353
       +
                   )}

     

       354
       354
       +
                 </Button>

     

       355
       355
       +
               )}

     

       356
       356
       +
             </Popout>

     

       357
       357
       +
           </div>

     

       358
       358
       +
         );

     

       359
       359
       +
       }

     

       360
       360
       +
       

     

       361
       361
       +
       // TODO: spacepack lazy loading utils

     

       362
       362
       +
       export default React.lazy(() =>

     

       363
       363
       +
         modPromise.then(async () => {

     

       364
       364
       +
           await modPromise;

     

       365
       365
       +
           ArrowsUpDownIcon ??=

     

       366
       366
       +
             spacepack.findByCode(ArrowsUpDownIconSVG)[0].exports.default;

     

       367
       367
       +
       

     

       368
       368
       +
           return { default: FilterBar };

     

       369
       369
       +
         })

     

       370
       370
       +
       );

+105

packages/core-extensions/src/moonbase/webpackModules/ui/extensions/index.tsx

···

       1
       1
       +
       import { ExtensionLoadSource, ExtensionTag } from "@moonlight-mod/types";

     

       2
       2
       +
       import { ExtensionState } from "../../../types";

     

       3
       3
       +
       import FilterBar, { Filter, defaultFilter } from "./filterBar";

     

       4
       4
       +
       import ExtensionCard from "./card";

     

       5
       5
       +
       

     

       6
       6
       +
       import React from "@moonlight-mod/wp/common_react";

     

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

     

       8
       8
       +
       import * as Flux from "@moonlight-mod/wp/common_flux";

     

       9
       9
       +
       

     

       10
       10
       +
       import { MoonbaseSettingsStore } from "@moonlight-mod/wp/moonbase_stores";

     

       11
       11
       +
       

     

       12
       12
       +
       const Margins = spacepack.findByCode("marginCenterHorz:")[0].exports;

     

       13
       13
       +
       const SearchBar = spacepack.findByCode("Messages.SEARCH", "hideSearchIcon")[0]

     

       14
       14
       +
         .exports.default;

     

       15
       15
       +
       

     

       16
       16
       +
       export default function ExtensionsPage() {

     

       17
       17
       +
         const moonbaseId = MoonbaseSettingsStore.getExtensionUniqueId("moonbase")!;

     

       18
       18
       +
         const { extensions, savedFilter } = Flux.useStateFromStoresObject(

     

       19
       19
       +
           [MoonbaseSettingsStore],

     

       20
       20
       +
           () => {

     

       21
       21
       +
             return {

     

       22
       22
       +
               extensions: MoonbaseSettingsStore.extensions,

     

       23
       23
       +
               savedFilter: MoonbaseSettingsStore.getExtensionConfig(

     

       24
       24
       +
                 moonbaseId,

     

       25
       25
       +
                 "filter"

     

       26
       26
       +
               )

     

       27
       27
       +
             };

     

       28
       28
       +
           }

     

       29
       29
       +
         );

     

       30
       30
       +
       

     

       31
       31
       +
         const [query, setQuery] = React.useState("");

     

       32
       32
       +
       

     

       33
       33
       +
         let filter: Filter, setFilter: (filter: Filter) => void;

     

       34
       34
       +
         if (moonlight.getConfigOption<boolean>("moonbase", "saveFilter")) {

     

       35
       35
       +
           filter = savedFilter ?? defaultFilter;

     

       36
       36
       +
           setFilter = (filter) =>

     

       37
       37
       +
             MoonbaseSettingsStore.setExtensionConfig(moonbaseId, "filter", filter);

     

       38
       38
       +
         } else {

     

       39
       39
       +
           const state = React.useState(defaultFilter);

     

       40
       40
       +
           filter = state[0];

     

       41
       41
       +
           setFilter = state[1];

     

       42
       42
       +
         }

     

       43
       43
       +
         const [selectedTags, setSelectedTags] = React.useState(new Set<string>());

     

       44
       44
       +
         const sorted = Object.values(extensions).sort((a, b) => {

     

       45
       45
       +
           const aName = a.manifest.meta?.name ?? a.id;

     

       46
       46
       +
           const bName = b.manifest.meta?.name ?? b.id;

     

       47
       47
       +
           return aName.localeCompare(bName);

     

       48
       48
       +
         });

     

       49
       49
       +
       

     

       50
       50
       +
         const filtered = sorted.filter(

     

       51
       51
       +
           (ext) =>

     

       52
       52
       +
             (ext.manifest.meta?.name?.toLowerCase().includes(query) ||

     

       53
       53
       +
               ext.manifest.meta?.tagline?.toLowerCase().includes(query) ||

     

       54
       54
       +
               ext.manifest.meta?.description?.toLowerCase().includes(query)) &&

     

       55
       55
       +
             [...selectedTags.values()].every(

     

       56
       56
       +
               (tag) => ext.manifest.meta?.tags?.includes(tag as ExtensionTag)

     

       57
       57
       +
             ) &&

     

       58
       58
       +
             // This seems very bad, sorry

     

       59
       59
       +
             !(

     

       60
       60
       +
               (!(filter & Filter.Core) &&

     

       61
       61
       +
                 ext.source.type === ExtensionLoadSource.Core) ||

     

       62
       62
       +
               (!(filter & Filter.Normal) &&

     

       63
       63
       +
                 ext.source.type === ExtensionLoadSource.Normal) ||

     

       64
       64
       +
               (!(filter & Filter.Developer) &&

     

       65
       65
       +
                 ext.source.type === ExtensionLoadSource.Developer) ||

     

       66
       66
       +
               (!(filter & Filter.Enabled) &&

     

       67
       67
       +
                 MoonbaseSettingsStore.getExtensionEnabled(ext.uniqueId)) ||

     

       68
       68
       +
               (!(filter & Filter.Disabled) &&

     

       69
       69
       +
                 !MoonbaseSettingsStore.getExtensionEnabled(ext.uniqueId)) ||

     

       70
       70
       +
               (!(filter & Filter.Installed) &&

     

       71
       71
       +
                 ext.state !== ExtensionState.NotDownloaded) ||

     

       72
       72
       +
               (!(filter & Filter.Repository) &&

     

       73
       73
       +
                 ext.state === ExtensionState.NotDownloaded)

     

       74
       74
       +
             )

     

       75
       75
       +
         );

     

       76
       76
       +
       

     

       77
       77
       +
         return (

     

       78
       78
       +
           <>

     

       79
       79
       +
             <SearchBar

     

       80
       80
       +
               size={SearchBar.Sizes.MEDIUM}

     

       81
       81
       +
               query={query}

     

       82
       82
       +
               onChange={(v: string) => setQuery(v.toLowerCase())}

     

       83
       83
       +
               onClear={() => setQuery("")}

     

       84
       84
       +
               autoFocus={true}

     

       85
       85
       +
               autoComplete="off"

     

       86
       86
       +
               inputProps={{

     

       87
       87
       +
                 autoCapitalize: "none",

     

       88
       88
       +
                 autoCorrect: "off",

     

       89
       89
       +
                 spellCheck: "false"

     

       90
       90
       +
               }}

     

       91
       91
       +
             />

     

       92
       92
       +
             <React.Suspense fallback={<div className={Margins.marginBottom20}></div>}>

     

       93
       93
       +
               <FilterBar

     

       94
       94
       +
                 filter={filter}

     

       95
       95
       +
                 setFilter={setFilter}

     

       96
       96
       +
                 selectedTags={selectedTags}

     

       97
       97
       +
                 setSelectedTags={setSelectedTags}

     

       98
       98
       +
               />

     

       99
       99
       +
             </React.Suspense>

     

       100
       100
       +
             {filtered.map((ext) => (

     

       101
       101
       +
               <ExtensionCard uniqueId={ext.uniqueId} key={ext.id} />

     

       102
       102
       +
             ))}

     

       103
       103
       +
           </>

     

       104
       104
       +
         );

     

       105
       105
       +
       }

+204

packages/core-extensions/src/moonbase/webpackModules/ui/extensions/info.tsx

···

       1
       1
       +
       import { ExtensionTag } from "@moonlight-mod/types";

     

       2
       2
       +
       import { MoonbaseExtension } from "../../../types";

     

       3
       3
       +
       

     

       4
       4
       +
       import React from "@moonlight-mod/wp/common_react";

     

       5
       5
       +
       import CommonComponents from "@moonlight-mod/wp/common_components";

     

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

     

       7
       7
       +
       

     

       8
       8
       +
       type Dependency = {

     

       9
       9
       +
         id: string;

     

       10
       10
       +
         type: DependencyType;

     

       11
       11
       +
       };

     

       12
       12
       +
       

     

       13
       13
       +
       enum DependencyType {

     

       14
       14
       +
         Dependency = "dependency",

     

       15
       15
       +
         Optional = "optional",

     

       16
       16
       +
         Incompatible = "incompatible"

     

       17
       17
       +
       }

     

       18
       18
       +
       

     

       19
       19
       +
       export const tagNames: Record<ExtensionTag, string> = {

     

       20
       20
       +
         [ExtensionTag.Accessibility]: "Accessibility",

     

       21
       21
       +
         [ExtensionTag.Appearance]: "Appearance",

     

       22
       22
       +
         [ExtensionTag.Chat]: "Chat",

     

       23
       23
       +
         [ExtensionTag.Commands]: "Commands",

     

       24
       24
       +
         [ExtensionTag.ContextMenu]: "Context Menu",

     

       25
       25
       +
         [ExtensionTag.DangerZone]: "Danger Zone",

     

       26
       26
       +
         [ExtensionTag.Development]: "Development",

     

       27
       27
       +
         [ExtensionTag.Fixes]: "Fixes",

     

       28
       28
       +
         [ExtensionTag.Fun]: "Fun",

     

       29
       29
       +
         [ExtensionTag.Markdown]: "Markdown",

     

       30
       30
       +
         [ExtensionTag.Voice]: "Voice",

     

       31
       31
       +
         [ExtensionTag.Privacy]: "Privacy",

     

       32
       32
       +
         [ExtensionTag.Profiles]: "Profiles",

     

       33
       33
       +
         [ExtensionTag.QualityOfLife]: "Quality of Life",

     

       34
       34
       +
         [ExtensionTag.Library]: "Library"

     

       35
       35
       +
       };

     

       36
       36
       +
       

     

       37
       37
       +
       const UserInfoClasses = spacepack.findByCode(

     

       38
       38
       +
         "infoScroller",

     

       39
       39
       +
         "userInfoSection",

     

       40
       40
       +
         "userInfoSectionHeader"

     

       41
       41
       +
       )[0].exports;

     

       42
       42
       +
       

     

       43
       43
       +
       import { MoonbaseSettingsStore } from "@moonlight-mod/wp/moonbase_stores";

     

       44
       44
       +
       

     

       45
       45
       +
       function InfoSection({

     

       46
       46
       +
         title,

     

       47
       47
       +
         children

     

       48
       48
       +
       }: {

     

       49
       49
       +
         title: string;

     

       50
       50
       +
         children: React.ReactNode;

     

       51
       51
       +
       }) {

     

       52
       52
       +
         return (

     

       53
       53
       +
           <div

     

       54
       54
       +
             style={{

     

       55
       55
       +
               marginRight: "1em"

     

       56
       56
       +
             }}

     

       57
       57
       +
           >

     

       58
       58
       +
             <CommonComponents.Text

     

       59
       59
       +
               variant="eyebrow"

     

       60
       60
       +
               className={UserInfoClasses.userInfoSectionHeader}

     

       61
       61
       +
             >

     

       62
       62
       +
               {title}

     

       63
       63
       +
             </CommonComponents.Text>

     

       64
       64
       +
       

     

       65
       65
       +
             <CommonComponents.Text variant="text-sm/normal">

     

       66
       66
       +
               {children}

     

       67
       67
       +
             </CommonComponents.Text>

     

       68
       68
       +
           </div>

     

       69
       69
       +
         );

     

       70
       70
       +
       }

     

       71
       71
       +
       

     

       72
       72
       +
       function Badge({

     

       73
       73
       +
         color,

     

       74
       74
       +
         children

     

       75
       75
       +
       }: {

     

       76
       76
       +
         color: string;

     

       77
       77
       +
         children: React.ReactNode;

     

       78
       78
       +
       }) {

     

       79
       79
       +
         return (

     

       80
       80
       +
           <span

     

       81
       81
       +
             style={{

     

       82
       82
       +
               borderRadius: ".1875rem",

     

       83
       83
       +
               padding: "0 0.275rem",

     

       84
       84
       +
               marginRight: "0.4em",

     

       85
       85
       +
               backgroundColor: color,

     

       86
       86
       +
               color: "#fff"

     

       87
       87
       +
             }}

     

       88
       88
       +
           >

     

       89
       89
       +
             {children}

     

       90
       90
       +
           </span>

     

       91
       91
       +
         );

     

       92
       92
       +
       }

     

       93
       93
       +
       

     

       94
       94
       +
       export default function ExtensionInfo({ ext }: { ext: MoonbaseExtension }) {

     

       95
       95
       +
         const authors = ext.manifest?.meta?.authors;

     

       96
       96
       +
         const tags = ext.manifest?.meta?.tags;

     

       97
       97
       +
         const version = ext.manifest?.version;

     

       98
       98
       +
       

     

       99
       99
       +
         const dependencies: Dependency[] = [];

     

       100
       100
       +
         if (ext.manifest.dependencies != null) {

     

       101
       101
       +
           dependencies.push(

     

       102
       102
       +
             ...ext.manifest.dependencies.map((dep) => ({

     

       103
       103
       +
               id: dep,

     

       104
       104
       +
               type: DependencyType.Dependency

     

       105
       105
       +
             }))

     

       106
       106
       +
           );

     

       107
       107
       +
         }

     

       108
       108
       +
       

     

       109
       109
       +
         if (ext.manifest.suggested != null) {

     

       110
       110
       +
           dependencies.push(

     

       111
       111
       +
             ...ext.manifest.suggested.map((dep) => ({

     

       112
       112
       +
               id: dep,

     

       113
       113
       +
               type: DependencyType.Optional

     

       114
       114
       +
             }))

     

       115
       115
       +
           );

     

       116
       116
       +
         }

     

       117
       117
       +
       

     

       118
       118
       +
         if (ext.manifest.incompatible != null) {

     

       119
       119
       +
           dependencies.push(

     

       120
       120
       +
             ...ext.manifest.incompatible.map((dep) => ({

     

       121
       121
       +
               id: dep,

     

       122
       122
       +
               type: DependencyType.Incompatible

     

       123
       123
       +
             }))

     

       124
       124
       +
           );

     

       125
       125
       +
         }

     

       126
       126
       +
       

     

       127
       127
       +
         return (

     

       128
       128
       +
           <>

     

       129
       129
       +
             {authors != null && (

     

       130
       130
       +
               <InfoSection title="Authors">

     

       131
       131
       +
                 {authors.map((author, i) => {

     

       132
       132
       +
                   const comma = i !== authors.length - 1 ? ", " : "";

     

       133
       133
       +
                   if (typeof author === "string") {

     

       134
       134
       +
                     return (

     

       135
       135
       +
                       <span key={i}>

     

       136
       136
       +
                         {author}

     

       137
       137
       +
                         {comma}

     

       138
       138
       +
                       </span>

     

       139
       139
       +
                     );

     

       140
       140
       +
                   } else {

     

       141
       141
       +
                     // TODO: resolve IDs

     

       142
       142
       +
                     return (

     

       143
       143
       +
                       <span key={i}>

     

       144
       144
       +
                         {author.name}

     

       145
       145
       +
                         {comma}

     

       146
       146
       +
                       </span>

     

       147
       147
       +
                     );

     

       148
       148
       +
                   }

     

       149
       149
       +
                 })}

     

       150
       150
       +
               </InfoSection>

     

       151
       151
       +
             )}

     

       152
       152
       +
       

     

       153
       153
       +
             {tags != null && (

     

       154
       154
       +
               <InfoSection title="Tags">

     

       155
       155
       +
                 {tags.map((tag, i) => {

     

       156
       156
       +
                   const name = tagNames[tag];

     

       157
       157
       +
       

     

       158
       158
       +
                   return (

     

       159
       159
       +
                     <Badge

     

       160
       160
       +
                       key={i}

     

       161
       161
       +
                       color={

     

       162
       162
       +
                         tag === ExtensionTag.DangerZone

     

       163
       163
       +
                           ? "var(--red-400)"

     

       164
       164
       +
                           : "var(--brand-500)"

     

       165
       165
       +
                       }

     

       166
       166
       +
                     >

     

       167
       167
       +
                       {name}

     

       168
       168
       +
                     </Badge>

     

       169
       169
       +
                   );

     

       170
       170
       +
                 })}

     

       171
       171
       +
               </InfoSection>

     

       172
       172
       +
             )}

     

       173
       173
       +
       

     

       174
       174
       +
             {dependencies.length > 0 && (

     

       175
       175
       +
               <InfoSection title="Dependencies">

     

       176
       176
       +
                 {dependencies.map((dep) => {

     

       177
       177
       +
                   const colors = {

     

       178
       178
       +
                     [DependencyType.Dependency]: "var(--brand-500)",

     

       179
       179
       +
                     [DependencyType.Optional]: "var(--orange-400)",

     

       180
       180
       +
                     [DependencyType.Incompatible]: "var(--red-400)"

     

       181
       181
       +
                   };

     

       182
       182
       +
                   const color = colors[dep.type];

     

       183
       183
       +
                   const id = MoonbaseSettingsStore.getExtensionUniqueId(dep.id);

     

       184
       184
       +
                   const name =

     

       185
       185
       +
                     (id !== null

     

       186
       186
       +
                       ? MoonbaseSettingsStore.getExtensionName(id!)

     

       187
       187
       +
                       : null) ?? dep.id;

     

       188
       188
       +
                   return (

     

       189
       189
       +
                     <Badge color={color} key={dep.id}>

     

       190
       190
       +
                       {name}

     

       191
       191
       +
                     </Badge>

     

       192
       192
       +
                   );

     

       193
       193
       +
                 })}

     

       194
       194
       +
               </InfoSection>

     

       195
       195
       +
             )}

     

       196
       196
       +
       

     

       197
       197
       +
             {version != null && (

     

       198
       198
       +
               <InfoSection title="Version">

     

       199
       199
       +
                 <span>{version}</span>

     

       200
       200
       +
               </InfoSection>

     

       201
       201
       +
             )}

     

       202
       202
       +
           </>

     

       203
       203
       +
         );

     

       204
       204
       +
       }

+427

packages/core-extensions/src/moonbase/webpackModules/ui/extensions/settings.tsx

···

       1
       1
       +
       import {

     

       2
       2
       +
         ExtensionSettingType,

     

       3
       3
       +
         ExtensionSettingsManifest,

     

       4
       4
       +
         MultiSelectSettingType,

     

       5
       5
       +
         NumberSettingType,

     

       6
       6
       +
         SelectOption,

     

       7
       7
       +
         SelectSettingType

     

       8
       8
       +
       } from "@moonlight-mod/types/config";

     

       9
       9
       +
       

     

       10
       10
       +
       import {

     

       11
       11
       +
         CircleXIconSVG,

     

       12
       12
       +
         ExtensionState,

     

       13
       13
       +
         MoonbaseExtension

     

       14
       14
       +
       } from "../../../types";

     

       15
       15
       +
       

     

       16
       16
       +
       import React from "@moonlight-mod/wp/common_react";

     

       17
       17
       +
       import CommonComponents from "@moonlight-mod/wp/common_components";

     

       18
       18
       +
       import * as Flux from "@moonlight-mod/wp/common_flux";

     

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

     

       20
       20
       +
       

     

       21
       21
       +
       type SettingsProps = {

     

       22
       22
       +
         ext: MoonbaseExtension;

     

       23
       23
       +
         name: string;

     

       24
       24
       +
         setting: ExtensionSettingsManifest;

     

       25
       25
       +
         disabled: boolean;

     

       26
       26
       +
       };

     

       27
       27
       +
       

     

       28
       28
       +
       type SettingsComponent = React.ComponentType<SettingsProps>;

     

       29
       29
       +
       

     

       30
       30
       +
       import { MoonbaseSettingsStore } from "@moonlight-mod/wp/moonbase_stores";

     

       31
       31
       +
       

     

       32
       32
       +
       const Margins = spacepack.findByCode("marginCenterHorz:")[0].exports;

     

       33
       33
       +
       

     

       34
       34
       +
       function useConfigEntry<T>(uniqueId: number, name: string) {

     

       35
       35
       +
         return Flux.useStateFromStores(

     

       36
       36
       +
           [MoonbaseSettingsStore],

     

       37
       37
       +
           () => {

     

       38
       38
       +
             return {

     

       39
       39
       +
               value: MoonbaseSettingsStore.getExtensionConfig<T>(uniqueId, name),

     

       40
       40
       +
               displayName: MoonbaseSettingsStore.getExtensionConfigName(

     

       41
       41
       +
                 uniqueId,

     

       42
       42
       +
                 name

     

       43
       43
       +
               ),

     

       44
       44
       +
               description: MoonbaseSettingsStore.getExtensionConfigDescription(

     

       45
       45
       +
                 uniqueId,

     

       46
       46
       +
                 name

     

       47
       47
       +
               )

     

       48
       48
       +
             };

     

       49
       49
       +
           },

     

       50
       50
       +
           [uniqueId, name]

     

       51
       51
       +
         );

     

       52
       52
       +
       }

     

       53
       53
       +
       

     

       54
       54
       +
       function Boolean({ ext, name, setting, disabled }: SettingsProps) {

     

       55
       55
       +
         const { FormSwitch } = CommonComponents;

     

       56
       56
       +
         const { value, displayName, description } = useConfigEntry<boolean>(

     

       57
       57
       +
           ext.uniqueId,

     

       58
       58
       +
           name

     

       59
       59
       +
         );

     

       60
       60
       +
       

     

       61
       61
       +
         return (

     

       62
       62
       +
           <FormSwitch

     

       63
       63
       +
             value={value ?? false}

     

       64
       64
       +
             hideBorder={true}

     

       65
       65
       +
             disabled={disabled}

     

       66
       66
       +
             onChange={(value: boolean) => {

     

       67
       67
       +
               MoonbaseSettingsStore.setExtensionConfig(ext.uniqueId, name, value);

     

       68
       68
       +
             }}

     

       69
       69
       +
             note={description}

     

       70
       70
       +
             className={`${Margins.marginReset} ${Margins.marginTop20}`}

     

       71
       71
       +
           >

     

       72
       72
       +
             {displayName}

     

       73
       73
       +
           </FormSwitch>

     

       74
       74
       +
         );

     

       75
       75
       +
       }

     

       76
       76
       +
       

     

       77
       77
       +
       function Number({ ext, name, setting, disabled }: SettingsProps) {

     

       78
       78
       +
         const { FormItem, FormText, Slider } = CommonComponents;

     

       79
       79
       +
         const { value, displayName, description } = useConfigEntry<number>(

     

       80
       80
       +
           ext.uniqueId,

     

       81
       81
       +
           name

     

       82
       82
       +
         );

     

       83
       83
       +
       

     

       84
       84
       +
         const castedSetting = setting as NumberSettingType;

     

       85
       85
       +
         const min = castedSetting.min ?? 0;

     

       86
       86
       +
         const max = castedSetting.max ?? 100;

     

       87
       87
       +
       

     

       88
       88
       +
         return (

     

       89
       89
       +
           <FormItem className={Margins.marginTop20} title={displayName}>

     

       90
       90
       +
             {description && <FormText>{description}</FormText>}

     

       91
       91
       +
             <Slider

     

       92
       92
       +
               initialValue={value ?? 0}

     

       93
       93
       +
               disabled={disabled}

     

       94
       94
       +
               minValue={castedSetting.min ?? 0}

     

       95
       95
       +
               maxValue={castedSetting.max ?? 100}

     

       96
       96
       +
               onValueChange={(value: number) => {

     

       97
       97
       +
                 const rounded = Math.max(min, Math.min(max, Math.round(value)));

     

       98
       98
       +
                 MoonbaseSettingsStore.setExtensionConfig(ext.uniqueId, name, rounded);

     

       99
       99
       +
               }}

     

       100
       100
       +
             />

     

       101
       101
       +
           </FormItem>

     

       102
       102
       +
         );

     

       103
       103
       +
       }

     

       104
       104
       +
       

     

       105
       105
       +
       function String({ ext, name, setting, disabled }: SettingsProps) {

     

       106
       106
       +
         const { FormItem, FormText, TextInput } = CommonComponents;

     

       107
       107
       +
         const { value, displayName, description } = useConfigEntry<string>(

     

       108
       108
       +
           ext.uniqueId,

     

       109
       109
       +
           name

     

       110
       110
       +
         );

     

       111
       111
       +
       

     

       112
       112
       +
         return (

     

       113
       113
       +
           <FormItem className={Margins.marginTop20} title={displayName}>

     

       114
       114
       +
             {description && (

     

       115
       115
       +
               <FormText className={Margins.marginBottom8}>{description}</FormText>

     

       116
       116
       +
             )}

     

       117
       117
       +
             <TextInput

     

       118
       118
       +
               value={value ?? ""}

     

       119
       119
       +
               onChange={(value: string) => {

     

       120
       120
       +
                 if (disabled) return;

     

       121
       121
       +
                 MoonbaseSettingsStore.setExtensionConfig(ext.uniqueId, name, value);

     

       122
       122
       +
               }}

     

       123
       123
       +
             />

     

       124
       124
       +
           </FormItem>

     

       125
       125
       +
         );

     

       126
       126
       +
       }

     

       127
       127
       +
       

     

       128
       128
       +
       function MultilineString({ ext, name, setting, disabled }: SettingsProps) {

     

       129
       129
       +
         const { FormItem, FormText, TextArea } = CommonComponents;

     

       130
       130
       +
         const { value, displayName, description } = useConfigEntry<string>(

     

       131
       131
       +
           ext.uniqueId,

     

       132
       132
       +
           name

     

       133
       133
       +
         );

     

       134
       134
       +
       

     

       135
       135
       +
         return (

     

       136
       136
       +
           <FormItem className={Margins.marginTop20} title={displayName}>

     

       137
       137
       +
             {description && (

     

       138
       138
       +
               <FormText className={Margins.marginBottom8}>{description}</FormText>

     

       139
       139
       +
             )}

     

       140
       140
       +
             <TextArea

     

       141
       141
       +
               rows={5}

     

       142
       142
       +
               value={value ?? ""}

     

       143
       143
       +
               className={"moonbase-resizeable"}

     

       144
       144
       +
               onChange={(value: string) => {

     

       145
       145
       +
                 if (disabled) return;

     

       146
       146
       +
                 MoonbaseSettingsStore.setExtensionConfig(ext.uniqueId, name, value);

     

       147
       147
       +
               }}

     

       148
       148
       +
             />

     

       149
       149
       +
           </FormItem>

     

       150
       150
       +
         );

     

       151
       151
       +
       }

     

       152
       152
       +
       

     

       153
       153
       +
       function Select({ ext, name, setting, disabled }: SettingsProps) {

     

       154
       154
       +
         const { FormItem, FormText, SingleSelect } = CommonComponents;

     

       155
       155
       +
         const { value, displayName, description } = useConfigEntry<string>(

     

       156
       156
       +
           ext.uniqueId,

     

       157
       157
       +
           name

     

       158
       158
       +
         );

     

       159
       159
       +
       

     

       160
       160
       +
         const castedSetting = setting as SelectSettingType;

     

       161
       161
       +
         const options = castedSetting.options;

     

       162
       162
       +
       

     

       163
       163
       +
         return (

     

       164
       164
       +
           <FormItem className={Margins.marginTop20} title={displayName}>

     

       165
       165
       +
             {description && (

     

       166
       166
       +
               <FormText className={Margins.marginBottom8}>{description}</FormText>

     

       167
       167
       +
             )}

     

       168
       168
       +
             <SingleSelect

     

       169
       169
       +
               autofocus={false}

     

       170
       170
       +
               clearable={false}

     

       171
       171
       +
               value={value ?? ""}

     

       172
       172
       +
               options={options.map((o: SelectOption) =>

     

       173
       173
       +
                 typeof o === "string" ? { value: o, label: o } : o

     

       174
       174
       +
               )}

     

       175
       175
       +
               onChange={(value: string) => {

     

       176
       176
       +
                 if (disabled) return;

     

       177
       177
       +
                 MoonbaseSettingsStore.setExtensionConfig(ext.uniqueId, name, value);

     

       178
       178
       +
               }}

     

       179
       179
       +
             />

     

       180
       180
       +
           </FormItem>

     

       181
       181
       +
         );

     

       182
       182
       +
       }

     

       183
       183
       +
       

     

       184
       184
       +
       function MultiSelect({ ext, name, setting, disabled }: SettingsProps) {

     

       185
       185
       +
         const { FormItem, FormText, Select, useVariableSelect, multiSelect } =

     

       186
       186
       +
           CommonComponents;

     

       187
       187
       +
         const { value, displayName, description } = useConfigEntry<string | string[]>(

     

       188
       188
       +
           ext.uniqueId,

     

       189
       189
       +
           name

     

       190
       190
       +
         );

     

       191
       191
       +
       

     

       192
       192
       +
         const castedSetting = setting as MultiSelectSettingType;

     

       193
       193
       +
         const options = castedSetting.options;

     

       194
       194
       +
       

     

       195
       195
       +
         return (

     

       196
       196
       +
           <FormItem className={Margins.marginTop20} title={displayName}>

     

       197
       197
       +
             {description && (

     

       198
       198
       +
               <FormText className={Margins.marginBottom8}>{description}</FormText>

     

       199
       199
       +
             )}

     

       200
       200
       +
             <Select

     

       201
       201
       +
               autofocus={false}

     

       202
       202
       +
               clearable={false}

     

       203
       203
       +
               closeOnSelect={false}

     

       204
       204
       +
               options={options.map((o: SelectOption) =>

     

       205
       205
       +
                 typeof o === "string" ? { value: o, label: o } : o

     

       206
       206
       +
               )}

     

       207
       207
       +
               {...useVariableSelect({

     

       208
       208
       +
                 onSelectInteraction: multiSelect,

     

       209
       209
       +
                 value: new Set(Array.isArray(value) ? value : [value]),

     

       210
       210
       +
                 onChange: (value: string) => {

     

       211
       211
       +
                   if (disabled) return;

     

       212
       212
       +
                   MoonbaseSettingsStore.setExtensionConfig(

     

       213
       213
       +
                     ext.uniqueId,

     

       214
       214
       +
                     name,

     

       215
       215
       +
                     Array.from(value)

     

       216
       216
       +
                   );

     

       217
       217
       +
                 }

     

       218
       218
       +
               })}

     

       219
       219
       +
             />

     

       220
       220
       +
           </FormItem>

     

       221
       221
       +
         );

     

       222
       222
       +
       }

     

       223
       223
       +
       

     

       224
       224
       +
       const RemoveButtonClasses = spacepack.findByCode("removeButtonContainer")[0]

     

       225
       225
       +
         .exports;

     

       226
       226
       +
       const CircleXIcon = spacepack.findByCode(CircleXIconSVG)[0].exports.default;

     

       227
       227
       +
       function RemoveEntryButton({

     

       228
       228
       +
         onClick,

     

       229
       229
       +
         disabled

     

       230
       230
       +
       }: {

     

       231
       231
       +
         onClick: () => void;

     

       232
       232
       +
         disabled: boolean;

     

       233
       233
       +
       }) {

     

       234
       234
       +
         const { Tooltip, Clickable } = CommonComponents;

     

       235
       235
       +
         return (

     

       236
       236
       +
           <div className={RemoveButtonClasses.removeButtonContainer}>

     

       237
       237
       +
             <Tooltip text="Remove entry" position="top">

     

       238
       238
       +
               {(props: any) => (

     

       239
       239
       +
                 <Clickable

     

       240
       240
       +
                   {...props}

     

       241
       241
       +
                   className={RemoveButtonClasses.removeButton}

     

       242
       242
       +
                   onClick={onClick}

     

       243
       243
       +
                 >

     

       244
       244
       +
                   <CircleXIcon width={16} height={16} />

     

       245
       245
       +
                 </Clickable>

     

       246
       246
       +
               )}

     

       247
       247
       +
             </Tooltip>

     

       248
       248
       +
           </div>

     

       249
       249
       +
         );

     

       250
       250
       +
       }

     

       251
       251
       +
       

     

       252
       252
       +
       function List({ ext, name, setting, disabled }: SettingsProps) {

     

       253
       253
       +
         const { FormItem, FormText, TextInput, Button, Flex } = CommonComponents;

     

       254
       254
       +
         const { value, displayName, description } = useConfigEntry<string[]>(

     

       255
       255
       +
           ext.uniqueId,

     

       256
       256
       +
           name

     

       257
       257
       +
         );

     

       258
       258
       +
       

     

       259
       259
       +
         const entries = value ?? [];

     

       260
       260
       +
         const updateConfig = () =>

     

       261
       261
       +
           MoonbaseSettingsStore.setExtensionConfig(ext.uniqueId, name, entries);

     

       262
       262
       +
       

     

       263
       263
       +
         return (

     

       264
       264
       +
           <FormItem className={Margins.marginTop20} title={displayName}>

     

       265
       265
       +
             {description && (

     

       266
       266
       +
               <FormText className={Margins.marginBottom4}>{description}</FormText>

     

       267
       267
       +
             )}

     

       268
       268
       +
             <Flex direction={Flex.Direction.VERTICAL}>

     

       269
       269
       +
               {entries.map((val, i) => (

     

       270
       270
       +
                 // FIXME: stylesheets

     

       271
       271
       +
                 <div

     

       272
       272
       +
                   key={i}

     

       273
       273
       +
                   style={{

     

       274
       274
       +
                     display: "grid",

     

       275
       275
       +
                     height: "32px",

     

       276
       276
       +
                     gap: "8px",

     

       277
       277
       +
                     gridTemplateColumns: "1fr 32px",

     

       278
       278
       +
                     alignItems: "center"

     

       279
       279
       +
                   }}

     

       280
       280
       +
                 >

     

       281
       281
       +
                   <TextInput

     

       282
       282
       +
                     size={TextInput.Sizes.MINI}

     

       283
       283
       +
                     value={val}

     

       284
       284
       +
                     disabled={disabled}

     

       285
       285
       +
                     onChange={(newVal: string) => {

     

       286
       286
       +
                       entries[i] = newVal;

     

       287
       287
       +
                       updateConfig();

     

       288
       288
       +
                     }}

     

       289
       289
       +
                   />

     

       290
       290
       +
                   <RemoveEntryButton

     

       291
       291
       +
                     disabled={disabled}

     

       292
       292
       +
                     onClick={() => {

     

       293
       293
       +
                       entries.splice(i, 1);

     

       294
       294
       +
                       updateConfig();

     

       295
       295
       +
                     }}

     

       296
       296
       +
                   />

     

       297
       297
       +
                 </div>

     

       298
       298
       +
               ))}

     

       299
       299
       +
       

     

       300
       300
       +
               <Button

     

       301
       301
       +
                 look={Button.Looks.FILLED}

     

       302
       302
       +
                 color={Button.Colors.GREEN}

     

       303
       303
       +
                 size={Button.Sizes.SMALL}

     

       304
       304
       +
                 disabled={disabled}

     

       305
       305
       +
                 className={Margins.marginTop8}

     

       306
       306
       +
                 onClick={() => {

     

       307
       307
       +
                   entries.push("");

     

       308
       308
       +
                   updateConfig();

     

       309
       309
       +
                 }}

     

       310
       310
       +
               >

     

       311
       311
       +
                 Add new entry

     

       312
       312
       +
               </Button>

     

       313
       313
       +
             </Flex>

     

       314
       314
       +
           </FormItem>

     

       315
       315
       +
         );

     

       316
       316
       +
       }

     

       317
       317
       +
       

     

       318
       318
       +
       function Dictionary({ ext, name, setting, disabled }: SettingsProps) {

     

       319
       319
       +
         const { FormItem, FormText, TextInput, Button, Flex } = CommonComponents;

     

       320
       320
       +
         const { value, displayName, description } = useConfigEntry<

     

       321
       321
       +
           Record<string, string>

     

       322
       322
       +
         >(ext.uniqueId, name);

     

       323
       323
       +
       

     

       324
       324
       +
         const entries = Object.entries(value ?? {});

     

       325
       325
       +
         const updateConfig = () =>

     

       326
       326
       +
           MoonbaseSettingsStore.setExtensionConfig(

     

       327
       327
       +
             ext.uniqueId,

     

       328
       328
       +
             name,

     

       329
       329
       +
             Object.fromEntries(entries)

     

       330
       330
       +
           );

     

       331
       331
       +
       

     

       332
       332
       +
         return (

     

       333
       333
       +
           <FormItem className={Margins.marginTop20} title={displayName}>

     

       334
       334
       +
             {description && (

     

       335
       335
       +
               <FormText className={Margins.marginBottom4}>{description}</FormText>

     

       336
       336
       +
             )}

     

       337
       337
       +
             <Flex direction={Flex.Direction.VERTICAL}>

     

       338
       338
       +
               {entries.map(([key, val], i) => (

     

       339
       339
       +
                 // FIXME: stylesheets

     

       340
       340
       +
                 <div

     

       341
       341
       +
                   key={i}

     

       342
       342
       +
                   style={{

     

       343
       343
       +
                     display: "grid",

     

       344
       344
       +
                     height: "32px",

     

       345
       345
       +
                     gap: "8px",

     

       346
       346
       +
                     gridTemplateColumns: "1fr 1fr 32px",

     

       347
       347
       +
                     alignItems: "center"

     

       348
       348
       +
                   }}

     

       349
       349
       +
                 >

     

       350
       350
       +
                   <TextInput

     

       351
       351
       +
                     size={TextInput.Sizes.MINI}

     

       352
       352
       +
                     value={key}

     

       353
       353
       +
                     disabled={disabled}

     

       354
       354
       +
                     onChange={(newKey: string) => {

     

       355
       355
       +
                       entries[i][0] = newKey;

     

       356
       356
       +
                       updateConfig();

     

       357
       357
       +
                     }}

     

       358
       358
       +
                   />

     

       359
       359
       +
                   <TextInput

     

       360
       360
       +
                     size={TextInput.Sizes.MINI}

     

       361
       361
       +
                     value={val}

     

       362
       362
       +
                     disabled={disabled}

     

       363
       363
       +
                     onChange={(newValue: string) => {

     

       364
       364
       +
                       entries[i][1] = newValue;

     

       365
       365
       +
                       updateConfig();

     

       366
       366
       +
                     }}

     

       367
       367
       +
                   />

     

       368
       368
       +
                   <RemoveEntryButton

     

       369
       369
       +
                     disabled={disabled}

     

       370
       370
       +
                     onClick={() => {

     

       371
       371
       +
                       entries.splice(i, 1);

     

       372
       372
       +
                       updateConfig();

     

       373
       373
       +
                     }}

     

       374
       374
       +
                   />

     

       375
       375
       +
                 </div>

     

       376
       376
       +
               ))}

     

       377
       377
       +
       

     

       378
       378
       +
               <Button

     

       379
       379
       +
                 look={Button.Looks.FILLED}

     

       380
       380
       +
                 color={Button.Colors.GREEN}

     

       381
       381
       +
                 size={Button.Sizes.SMALL}

     

       382
       382
       +
                 className={Margins.marginTop8}

     

       383
       383
       +
                 disabled={disabled}

     

       384
       384
       +
                 onClick={() => {

     

       385
       385
       +
                   entries.push([`entry-${entries.length}`, ""]);

     

       386
       386
       +
                   updateConfig();

     

       387
       387
       +
                 }}

     

       388
       388
       +
               >

     

       389
       389
       +
                 Add new entry

     

       390
       390
       +
               </Button>

     

       391
       391
       +
             </Flex>

     

       392
       392
       +
           </FormItem>

     

       393
       393
       +
         );

     

       394
       394
       +
       }

     

       395
       395
       +
       

     

       396
       396
       +
       function Setting({ ext, name, setting, disabled }: SettingsProps) {

     

       397
       397
       +
         const elements: Partial<Record<ExtensionSettingType, SettingsComponent>> = {

     

       398
       398
       +
           [ExtensionSettingType.Boolean]: Boolean,

     

       399
       399
       +
           [ExtensionSettingType.Number]: Number,

     

       400
       400
       +
           [ExtensionSettingType.String]: String,

     

       401
       401
       +
           [ExtensionSettingType.MultilineString]: MultilineString,

     

       402
       402
       +
           [ExtensionSettingType.Select]: Select,

     

       403
       403
       +
           [ExtensionSettingType.MultiSelect]: MultiSelect,

     

       404
       404
       +
           [ExtensionSettingType.List]: List,

     

       405
       405
       +
           [ExtensionSettingType.Dictionary]: Dictionary

     

       406
       406
       +
         };

     

       407
       407
       +
         const element = elements[setting.type];

     

       408
       408
       +
         if (element == null) return <></>;

     

       409
       409
       +
         return React.createElement(element, { ext, name, setting, disabled });

     

       410
       410
       +
       }

     

       411
       411
       +
       

     

       412
       412
       +
       export default function Settings({ ext }: { ext: MoonbaseExtension }) {

     

       413
       413
       +
         const { Flex } = CommonComponents;

     

       414
       414
       +
         return (

     

       415
       415
       +
           <Flex className="moonbase-settings" direction={Flex.Direction.VERTICAL}>

     

       416
       416
       +
             {Object.entries(ext.manifest.settings!).map(([name, setting]) => (

     

       417
       417
       +
               <Setting

     

       418
       418
       +
                 ext={ext}

     

       419
       419
       +
                 key={name}

     

       420
       420
       +
                 name={name}

     

       421
       421
       +
                 setting={setting}

     

       422
       422
       +
                 disabled={ext.state === ExtensionState.NotDownloaded}

     

       423
       423
       +
               />

     

       424
       424
       +
             ))}

     

       425
       425
       +
           </Flex>

     

       426
       426
       +
         );

     

       427
       427
       +
       }

+64

packages/core-extensions/src/moonbase/webpackModules/ui/index.tsx

···

       1
       1
       +
       import React from "@moonlight-mod/wp/common_react";

     

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

     

       3
       3
       +
       import { Text, TabBar } from "@moonlight-mod/wp/common_components";

     

       4
       4
       +
       

     

       5
       5
       +
       import ExtensionsPage from "./extensions";

     

       6
       6
       +
       import ConfigPage from "./config";

     

       7
       7
       +
       

     

       8
       8
       +
       const Margins = spacepack.findByCode("marginCenterHorz:")[0].exports;

     

       9
       9
       +
       

     

       10
       10
       +
       const { Divider } = spacepack.findByCode(".default.HEADER_BAR")[0].exports

     

       11
       11
       +
         .default;

     

       12
       12
       +
       const TitleBarClasses = spacepack.findByCode("iconWrapper:", "children:")[0]

     

       13
       13
       +
         .exports;

     

       14
       14
       +
       const TabBarClasses = spacepack.findByCode("nowPlayingColumn:")[0].exports;

     

       15
       15
       +
       

     

       16
       16
       +
       export const pages: Record<

     

       17
       17
       +
         string,

     

       18
       18
       +
         {

     

       19
       19
       +
           name: string;

     

       20
       20
       +
           element: React.FunctionComponent;

     

       21
       21
       +
         }

     

       22
       22
       +
       > = {

     

       23
       23
       +
         extensions: {

     

       24
       24
       +
           name: "Extensions",

     

       25
       25
       +
           element: ExtensionsPage

     

       26
       26
       +
         },

     

       27
       27
       +
         config: {

     

       28
       28
       +
           name: "Config",

     

       29
       29
       +
           element: ConfigPage

     

       30
       30
       +
         }

     

       31
       31
       +
       };

     

       32
       32
       +
       

     

       33
       33
       +
       export function Moonbase() {

     

       34
       34
       +
         const [selectedTab, setSelectedTab] = React.useState(Object.keys(pages)[0]);

     

       35
       35
       +
       

     

       36
       36
       +
         return (

     

       37
       37
       +
           <>

     

       38
       38
       +
             <div className={`${TitleBarClasses.children} ${Margins.marginBottom20}`}>

     

       39
       39
       +
               <Text

     

       40
       40
       +
                 className={TitleBarClasses.titleWrapper}

     

       41
       41
       +
                 variant="heading-lg/semibold"

     

       42
       42
       +
                 tag="h2"

     

       43
       43
       +
               >

     

       44
       44
       +
                 Moonbase

     

       45
       45
       +
               </Text>

     

       46
       46
       +
               <Divider />

     

       47
       47
       +
               <TabBar

     

       48
       48
       +
                 selectedItem={selectedTab}

     

       49
       49
       +
                 onItemSelect={setSelectedTab}

     

       50
       50
       +
                 type="top-pill"

     

       51
       51
       +
                 className={TabBarClasses.tabBar}

     

       52
       52
       +
               >

     

       53
       53
       +
                 {Object.entries(pages).map(([id, page]) => (

     

       54
       54
       +
                   <TabBar.Item key={id} id={id} className={TabBarClasses.item}>

     

       55
       55
       +
                     {page.name}

     

       56
       56
       +
                   </TabBar.Item>

     

       57
       57
       +
                 ))}

     

       58
       58
       +
               </TabBar>

     

       59
       59
       +
             </div>

     

       60
       60
       +
       

     

       61
       61
       +
             {React.createElement(pages[selectedTab].element)}

     

       62
       62
       +
           </>

     

       63
       63
       +
         );

     

       64
       64
       +
       }

packages/core-extensions/src/moonbase/wp.d.ts

···

       1
       1
       +
       declare module "@moonlight-mod/wp/moonbase_ui" {

     

       2
       2
       +
         export * from "core-extensions/src/moonbase/webpackModules/ui";

     

       3
       3
       +
       }

     

       4
       4
       +
       

     

       5
       5
       +
       declare module "@moonlight-mod/wp/moonbase_stores" {

     

       6
       6
       +
         export * from "core-extensions/src/moonbase/webpackModules/stores";

     

       7
       7
       +
       }

+3 -6

packages/core-extensions/src/quietLoggers/index.ts

···

       33
       33
        
           "is not a valid locale",

     

       34
       34
        
           /(.)\.error\(""\.concat\((.)," is not a valid locale\."\)\)/g

     

       35
       35
        
         ],

     

       36
       36
       -
         ['.displayName="RunningGameStore"', /.\.info\("games",{.+?}\),/],

     

       36
       36
       +
         ['="RunningGameStore"', /.\.info\("games",{.+?}\),/],

     

       37
       37
        
         [

     

       38
       38
        
           '"[BUILD INFO] Release Channel: "',

     

       39
       39
       -
           /new\(0,.{1,2}\.default\)\(\)\.log\("\[BUILD INFO\] Release Channel: ".+?"\)\),/

     

       39
       39
       +
           /new .{1,2}\.default\(\)\.log\("\[BUILD INFO\] Release Channel: ".+?"\)\),/

     

       40
       40
        
         ],

     

       41
       41
        
         [

     

       42
       42
        
           '.AnalyticEvents.APP_NATIVE_CRASH,"Storage"',

     
···

       46
       46
        
           '.AnalyticEvents.APP_NATIVE_CRASH,"Storage"',

     

       47
       47
        
           'console.log("AppCrashedFatalReport: getLastCrash not supported.");'

     

       48
       48
        
         ],

     

       49
       49
       -
         [

     

       50
       50
       -
           '"[NATIVE INFO] ',

     

       51
       51
       -
           /new\(0,.{1,2}\.default\)\(\)\.log\("\[NATIVE INFO] .+?\)\),/

     

       52
       52
       -
         ],

     

       49
       49
       +
         ['"[NATIVE INFO] ', /new .{1,2}\.default\(\)\.log\("\[NATIVE INFO] .+?\)\),/],

     

       53
       50
        
         ['"Spellchecker"', /.\.info\("Switching to ".+?"\(unavailable\)"\);?/g],

     

       54
       51
        
         [

     

       55
       52
        
           'throw new Error("Messages are still loading.");',

+3 -3

packages/core-extensions/src/settings/index.ts

···

       5
       5
        
         {

     

       6
       6
        
           find: ".UserSettingsSections.HOTSPOT_OPTIONS",

     

       7
       7
        
           replace: {

     

       8
       8
       -
             match: /\.CUSTOM,element:(.+?)}\];return (.{1,2})/,

     

       9
       9
       -
             replacement: (_, lastElement, sections) =>

     

       10
       10
       -
               `.CUSTOM,element:${lastElement}}];return require("settings_settings").Settings._mutateSections(${sections})`

     

       8
       8
       +
             match: /return(\[.+?\.CUSTOM,element:.+?}\])}/,

     

       9
       9
       +
             replacement: (_, arr) =>

     

       10
       10
       +
               `return require("settings_settings").Settings._mutateSections(${arr})}`

     

       11
       11
        
           }

     

       12
       12
        
         },

     

       13
       13
        
         {

+19 -8

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

···

       162
       162
        
           );

     

       163
       163
        
         },

     

       164
       164
        
       

     

       165
       165
       -
         lazyLoad: (find: string | RegExp | (string | RegExp)[], match: RegExp) => {

     

       166
       166
       -
           const module = Array.isArray(find)

     

       165
       165
       +
         lazyLoad: (

     

       166
       166
       +
           find: string | RegExp | (string | RegExp)[],

     

       167
       167
       +
           chunk: RegExp,

     

       168
       168
       +
           module: RegExp

     

       169
       169
       +
         ) => {

     

       170
       170
       +
           if (!chunk.flags.includes("g"))

     

       171
       171
       +
             return Promise.reject("Chunk ID regex must be global");

     

       172
       172
       +
       

     

       173
       173
       +
           const mod = Array.isArray(find)

     

       167
       174
        
             ? spacepack.findByCode(...find)

     

       168
       175
        
             : spacepack.findByCode(find);

     

       169
       169
       -
           if (module.length < 1) return Promise.reject("Find failed");

     

       176
       176
       +
           if (mod.length < 1) return Promise.reject("Module find failed");

     

       170
       177
        
       

     

       171
       171
       -
           const findId = module[0].id;

     

       178
       178
       +
           const findId = mod[0].id;

     

       172
       179
        
           const findCode = webpackRequire.m[findId].toString().replace(/\n/g, "");

     

       173
       180
        
       

     

       174
       174
       -
           const matchResult = findCode.match(match);

     

       175
       175
       -
           if (!matchResult) return Promise.reject("Match failed");

     

       181
       181
       +
           const chunkIds = [...findCode.matchAll(chunk)].map(([, id]) => id);

     

       182
       182
       +
           if (chunkIds.length === 0) return Promise.reject("Chunk ID match failed");

     

       183
       183
       +
       

     

       184
       184
       +
           const moduleId = findCode.match(module)?.[1];

     

       185
       185
       +
           if (!moduleId) return Promise.reject("Module ID match failed");

     

       176
       186
        
       

     

       177
       177
       -
           const matchId = matchResult[1];

     

       178
       178
       -
           return webpackRequire.el(matchId).then(() => webpackRequire(matchId));

     

       187
       187
       +
           return Promise.all(chunkIds.map((c) => webpackRequire.e(c))).then(() =>

     

       188
       188
       +
             webpackRequire(moduleId)

     

       189
       189
       +
           );

     

       179
       190
        
         },

     

       180
       191
        
       

     

       181
       192
        
         filterReal: (modules: WebpackModule[]) => {

+8 -6

packages/core/src/extension.ts

···

       13
       13
        
         const path = requireImport("path");

     

       14
       14
        
         const ret = [];

     

       15
       15
        
       

     

       16
       16
       -
         for (const file of fs.readdirSync(dir)) {

     

       17
       17
       -
           if (file === "manifest.json") {

     

       18
       18
       -
             ret.push(path.join(dir, file));

     

       19
       19
       -
           }

     

       16
       16
       +
         if (fs.existsSync(dir)) {

     

       17
       17
       +
           for (const file of fs.readdirSync(dir)) {

     

       18
       18
       +
             if (file === "manifest.json") {

     

       19
       19
       +
               ret.push(path.join(dir, file));

     

       20
       20
       +
             }

     

       20
       21
        
       

     

       21
       21
       -
           if (fs.statSync(path.join(dir, file)).isDirectory()) {

     

       22
       22
       -
             ret.push(...findManifests(path.join(dir, file)));

     

       22
       22
       +
             if (fs.statSync(path.join(dir, file)).isDirectory()) {

     

       23
       23
       +
               ret.push(...findManifests(path.join(dir, file)));

     

       24
       24
       +
             }

     

       23
       25
        
           }

     

       24
       26
        
         }

     

       25
       27

+11 -7

packages/core/src/patch.ts

···

       20
       20
        
       

     

       21
       21
        
       export function registerPatch(patch: IdentifiedPatch) {

     

       22
       22
        
         patches.push(patch);

     

       23
       23
       +
         moonlight.unpatched.add(patch);

     

       23
       24
        
       }

     

       24
       25
        
       

     

       25
       26
        
       export function registerWebpackModule(wp: IdentifiedWebpackModule) {

     

       26
       27
        
         webpackModules.add(wp);

     

       28
       28
       +
         if (wp.dependencies?.length) {

     

       29
       29
       +
           moonlight.pendingModules.add(wp);

     

       30
       30
       +
         }

     

       27
       31
        
       }

     

       28
       32
        
       

     

       29
       33
        
       /*

     
···

       206
       210
        
       

     

       207
       211
        
         for (const [_modId, mod] of Object.entries(entry)) {

     

       208
       212
        
           const modStr = mod.toString();

     

       209
       209
       -
           const wpModules = Array.from(webpackModules.values());

     

       210
       210
       -
           for (const wpModule of wpModules) {

     

       213
       213
       +
           for (const wpModule of webpackModules) {

     

       211
       214
        
             const id = wpModule.ext + "_" + wpModule.id;

     

       212
       215
        
             if (wpModule.dependencies) {

     

       213
       216
        
               const deps = new Set(wpModule.dependencies);

     
···

       215
       218
        
               // FIXME: This dependency resolution might fail if the things we want

     

       216
       219
        
               // got injected earlier. If weird dependencies fail, this is likely why.

     

       217
       220
        
               if (deps.size) {

     

       218
       218
       -
                 for (const dep of deps.values()) {

     

       221
       221
       +
                 for (const dep of deps) {

     

       219
       222
        
                   if (typeof dep === "string") {

     

       220
       223
        
                     if (modStr.includes(dep)) deps.delete(dep);

     

       221
       224
        
                   } else if (dep instanceof RegExp) {

     
···

       230
       233
        
                 }

     

       231
       234
        
       

     

       232
       235
        
                 if (deps.size !== 0) {

     

       233
       233
       -
                   // Update the deps that have passed

     

       234
       234
       -
                   webpackModules.delete(wpModule);

     

       235
       236
        
                   wpModule.dependencies = Array.from(deps);

     

       236
       236
       -
                   webpackModules.add(wpModule);

     

       237
       237
        
                   continue;

     

       238
       238
        
                 }

     

       239
       239
        
       

     
···

       242
       242
        
             }

     

       243
       243
        
       

     

       244
       244
        
             webpackModules.delete(wpModule);

     

       245
       245
       +
             moonlight.pendingModules.delete(wpModule);

     

       245
       246
        
             injectedWpModules.push(wpModule);

     

       246
       247
        
       

     

       247
       248
        
             inject = true;

     

       248
       249
        
       

     

       249
       249
       -
             if (wpModule.run) modules[id] = wpModule.run;

     

       250
       250
       +
             if (wpModule.run) {

     

       251
       251
       +
               modules[id] = wpModule.run;

     

       252
       252
       +
               wpModule.run.__moonlight = true;

     

       253
       253
       +
             }

     

       250
       254
        
             if (wpModule.entrypoint) entrypoints.push(id);

     

       251
       255
        
           }

     

       252
       256
        
           if (!webpackModules.size) break;

+1 -2

packages/types/package.json

···

       1
       1
        
       {

     

       2
       2
        
         "name": "@moonlight-mod/types",

     

       3
       3
       -
         "version": "1.1.6",

     

       3
       3
       +
         "version": "1.1.7",

     

       4
       4
        
         "main": "./src/index.ts",

     

       5
       5
        
         "types": "./src/index.ts",

     

       6
       6
        
         "exports": {

     
···

       10
       10
        
         },

     

       11
       11
        
         "dependencies": {

     

       12
       12
        
           "@types/flux": "^3.1.12",

     

       13
       13
       -
           "@types/node": "^20.6.2",

     

       14
       13
        
           "@types/react": "^18.2.22",

     

       15
       14
        
           "csstype": "^3.1.2",

     

       16
       15
        
           "standalone-electron-types": "^1.0.0"

packages/types/src/config.ts

···

       19
       19
        
         Boolean = "boolean",

     

       20
       20
        
         Number = "number",

     

       21
       21
        
         String = "string",

     

       22
       22
       +
         MultilineString = "multilinestring",

     

       22
       23
        
         Select = "select",

     

       23
       24
        
         MultiSelect = "multiselect",

     

       24
       25
        
         List = "list",

     
···

       47
       48
        
       

     

       48
       49
        
       export type StringSettingType = {

     

       49
       50
        
         type: ExtensionSettingType.String;

     

       51
       51
       +
         default?: string;

     

       52
       52
       +
       };

     

       53
       53
       +
       

     

       54
       54
       +
       export type MultilineTextInputSettingType = {

     

       55
       55
       +
         type: ExtensionSettingType.MultilineString;

     

       50
       56
        
         default?: string;

     

       51
       57
        
       };

     

       52
       58
        
       

     
···

       84
       90
        
         | BooleanSettingType

     

       85
       91
        
         | NumberSettingType

     

       86
       92
        
         | StringSettingType

     

       93
       93
       +
         | MultilineTextInputSettingType

     

       87
       94
        
         | SelectSettingType

     

       88
       95
        
         | MultiSelectSettingType

     

       89
       96
        
         | ListSettingType

+3 -1

packages/types/src/coreExtensions.ts

···

       29
       29
        
         ) => Function | null;

     

       30
       30
        
         lazyLoad: (

     

       31
       31
        
           find: string | RegExp | (string | RegExp)[],

     

       32
       32
       -
           match: RegExp

     

       32
       32
       +
           chunk: RegExp,

     

       33
       33
       +
           module: RegExp

     

       33
       34
        
         ) => Promise<any>;

     

       34
       35
        
         filterReal: (modules: WebpackModule[]) => WebpackModule[];

     

       35
       36
        
       };

     
···

       76
       77
        
       export type CommonFluxDispatcher = Dispatcher<any>;

     

       77
       78
        
       

     

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

     

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

+45

packages/types/src/coreExtensions/components.ts

···

       43
       43
        
         Sizes: typeof TextInputSizes;

     

       44
       44
        
       }

     

       45
       45
        
       

     

       46
       46
       +
       export enum TextAreaAutoComplete {

     

       47
       47
       +
         ON = "on",

     

       48
       48
       +
         OFF = "off"

     

       49
       49
       +
       }

     

       50
       50
       +
       

     

       51
       51
       +
       export enum TextAreaWrap {

     

       52
       52
       +
         HARD = "hard",

     

       53
       53
       +
         SOFT = "soft",

     

       54
       54
       +
         OFF = "off"

     

       55
       55
       +
       }

     

       56
       56
       +
       

     

       57
       57
       +
       interface TextArea

     

       58
       58
       +
         extends ComponentClass<

     

       59
       59
       +
           PropsWithoutRef<{

     

       60
       60
       +
             value?: string;

     

       61
       61
       +
             defaultValue?: string;

     

       62
       62
       +
             autoComplete?: TextAreaAutoComplete;

     

       63
       63
       +
             autoFocus?: boolean;

     

       64
       64
       +
             cols?: number;

     

       65
       65
       +
             disabled?: boolean;

     

       66
       66
       +
             form?: string;

     

       67
       67
       +
             maxLength?: number;

     

       68
       68
       +
             minLength?: number;

     

       69
       69
       +
             name?: string;

     

       70
       70
       +
             onChange?: (value: string, name: string) => void;

     

       71
       71
       +
             onChangeCapture?: (value: string, name: string) => void;

     

       72
       72
       +
             onInput?: (value: string, name: string) => void;

     

       73
       73
       +
             onInputCapture?: (value: string, name: string) => void;

     

       74
       74
       +
             onInvalid?: (value: string, name: string) => void;

     

       75
       75
       +
             onInvalidCapture?: (value: string, name: string) => void;

     

       76
       76
       +
             onSelect?: (value: string, name: string) => void;

     

       77
       77
       +
             onSelectCapture?: (value: string, name: string) => void;

     

       78
       78
       +
             placeholder?: string;

     

       79
       79
       +
             readOnly?: boolean;

     

       80
       80
       +
             required?: boolean;

     

       81
       81
       +
             rows?: number;

     

       82
       82
       +
             wrap?: TextAreaWrap;

     

       83
       83
       +
             className?: string;

     

       84
       84
       +
           }>

     

       85
       85
       +
         > {

     

       86
       86
       +
         AutoCompletes: typeof TextAreaAutoComplete;

     

       87
       87
       +
         Wraps: typeof TextAreaWrap;

     

       88
       88
       +
       }

     

       89
       89
       +
       

     

       46
       90
        
       export enum FormTextTypes {

     

       47
       91
        
         DEFAULT = "default",

     

       48
       92
        
         DESCRIPTION = "description",

     
···

       238
       282
        
           }>

     

       239
       283
        
         >;

     

       240
       284
        
         TextInput: TextInput;

     

       285
       285
       +
         TextArea: TextArea;

     

       241
       286
        
         FormDivider: ComponentClass<any>;

     

       242
       287
        
         FormSection: ComponentClass<

     

       243
       288
        
           PropsWithChildren<{

+154

packages/types/src/coreExtensions/contextMenu.ts

···

       1
       1
       +
       // TODO: Deduplicate common props

     

       2
       2
       +
       

     

       3
       3
       +
       export type Menu = React.FunctionComponent<{

     

       4
       4
       +
         navId: string;

     

       5
       5
       +
         variant?: string;

     

       6
       6
       +
         hideScrollbar?: boolean;

     

       7
       7
       +
         className?: string;

     

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

     

       9
       9
       +
         onClose?: () => void;

     

       10
       10
       +
         onSelect?: () => void;

     

       11
       11
       +
       }>;

     

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

     

       13
       13
       +
       

     

       14
       14
       +
       export type MenuElement =

     

       15
       15
       +
         | MenuSeparator

     

       16
       16
       +
         | MenuGroup

     

       17
       17
       +
         | MenuItem

     

       18
       18
       +
         | MenuCheckboxItem

     

       19
       19
       +
         | MenuRadioItem

     

       20
       20
       +
         | MenuControlItem;

     

       21
       21
       +
       

     

       22
       22
       +
       /* eslint-disable prettier/prettier */

     

       23
       23
       +
       export type MenuSeparator = React.FunctionComponent;

     

       24
       24
       +
       export type MenuGroup = React.FunctionComponent<{

     

       25
       25
       +
         label?: string;

     

       26
       26
       +
         className?: string;

     

       27
       27
       +
         color?: string;

     

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

     

       29
       29
       +
       }>;

     

       30
       30
       +
       export type MenuItem = React.FunctionComponent<{

     

       31
       31
       +
         id: any;

     

       32
       32
       +
         dontCloseOnActionIfHoldingShiftKey?: boolean;

     

       33
       33
       +
       } & ({

     

       34
       34
       +
         label: string;

     

       35
       35
       +
         subtext?: string;

     

       36
       36
       +
         color?: string;

     

       37
       37
       +
         hint?: string;

     

       38
       38
       +
         disabled?: boolean;

     

       39
       39
       +
         icon?: any;

     

       40
       40
       +
         showIconFirst?: boolean;

     

       41
       41
       +
         imageUrl?: string;

     

       42
       42
       +
       

     

       43
       43
       +
         className?: string;

     

       44
       44
       +
         focusedClassName?: string;

     

       45
       45
       +
         subMenuIconClassName?: string;

     

       46
       46
       +
       

     

       47
       47
       +
         action?: () => void;

     

       48
       48
       +
         onFocus?: () => void;

     

       49
       49
       +
       

     

       50
       50
       +
         iconProps?: any;

     

       51
       51
       +
         sparkle?: any;

     

       52
       52
       +
       

     

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

     

       54
       54
       +
         onChildrenScroll?: any;

     

       55
       55
       +
         childRowHeight?: any;

     

       56
       56
       +
         listClassName?: string;

     

       57
       57
       +
         subMenuClassName?: string;

     

       58
       58
       +
       } | {

     

       59
       59
       +
         color?: string;

     

       60
       60
       +
         disabled?: boolean;

     

       61
       61
       +
         keepItemStyles?: boolean;

     

       62
       62
       +
       

     

       63
       63
       +
         action?: () => void;

     

       64
       64
       +
       

     

       65
       65
       +
         render: any;

     

       66
       66
       +
         navigable?: boolean;

     

       67
       67
       +
       })>;

     

       68
       68
       +
       export type MenuCheckboxItem = React.FunctionComponent<{

     

       69
       69
       +
         id: any;

     

       70
       70
       +
         label: string;

     

       71
       71
       +
         subtext?: string;

     

       72
       72
       +
         color?: string;

     

       73
       73
       +
         className?: string;

     

       74
       74
       +
         focusedClassName?: string;

     

       75
       75
       +
         disabled?: boolean;

     

       76
       76
       +
         checked: boolean;

     

       77
       77
       +
         action?: () => void;

     

       78
       78
       +
       }>;

     

       79
       79
       +
       export type MenuRadioItem = React.FunctionComponent<{

     

       80
       80
       +
         id: any;

     

       81
       81
       +
         label: string;

     

       82
       82
       +
         subtext?: string;

     

       83
       83
       +
         color?: string;

     

       84
       84
       +
         disabled?: boolean;

     

       85
       85
       +
         action?: () => void;

     

       86
       86
       +
       }>;

     

       87
       87
       +
       export type MenuControlItem = React.FunctionComponent<{

     

       88
       88
       +
         id: any;

     

       89
       89
       +
         label: string;

     

       90
       90
       +
         color?: string;

     

       91
       91
       +
         disabled?: boolean;

     

       92
       92
       +
         showDefaultFocus?: boolean;

     

       93
       93
       +
       } & ({

     

       94
       94
       +
         control: any;

     

       95
       95
       +
       } | {

     

       96
       96
       +
         control?: undefined;

     

       97
       97
       +
         interactive?: boolean;

     

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

     

       99
       99
       +
       })>;

     

       100
       100
       +
       /* eslint-disable prettier/prettier */

     

       101
       101
       +
       

     

       102
       102
       +
       export type ContextMenu = {

     

       103
       103
       +
         addItem: (

     

       104
       104
       +
           navId: string,

     

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

     

       106
       106
       +
           anchorId: string,

     

       107
       107
       +
           before?: boolean

     

       108
       108
       +
         ) => void;

     

       109
       109
       +
       

     

       110
       110
       +
         MenuCheckboxItem: MenuCheckboxItem;

     

       111
       111
       +
         MenuControlItem: MenuControlItem;

     

       112
       112
       +
         MenuGroup: MenuGroup;

     

       113
       113
       +
         MenuItem: MenuItem;

     

       114
       114
       +
         MenuRadioItem: MenuRadioItem;

     

       115
       115
       +
         MenuSeparator: MenuSeparator;

     

       116
       116
       +
       };

     

       117
       117
       +
       

     

       118
       118
       +
       export type InternalItem = {

     

       119
       119
       +
         type: string;

     

       120
       120
       +
         key?: string;

     

       121
       121
       +
       };

     

       122
       122
       +
       

     

       123
       123
       +
       export type InternalSeparator = {

     

       124
       124
       +
         type: "separator";

     

       125
       125
       +
         navigable: false;

     

       126
       126
       +
       };

     

       127
       127
       +
       export type InternalGroupStart = {

     

       128
       128
       +
         type: "groupstart";

     

       129
       129
       +
         length: number;

     

       130
       130
       +
         navigable: false;

     

       131
       131
       +
         props: React.ComponentProps<MenuGroup>;

     

       132
       132
       +
       };

     

       133
       133
       +
       export type InternalGroupEnd = {

     

       134
       134
       +
         type: "groupend";

     

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

     

       136
       136
       +
       export type InternalCustomItem = {

     

       137
       137
       +
         type: "customitem";

     

       138
       138
       +
         key: any;

     

       139
       139
       +
         navigable?: boolean;

     

       140
       140
       +
         render: any;

     

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

     

       142
       142
       +
       };

     

       143
       143
       +
       export type InternalItem_ = {

     

       144
       144
       +
         type: "item";

     

       145
       145
       +
         key: any;

     

       146
       146
       +
         navigable: true;

     

       147
       147
       +
         label: string;

     

       148
       148
       +
       };

     

       149
       149
       +
       

     

       150
       150
       +
       export type EvilItemParser = (

     

       151
       151
       +
         el:

     

       152
       152
       +
           | React.ReactComponentElement<MenuElement>

     

       153
       153
       +
           | React.ReactComponentElement<MenuElement>[]

     

       154
       154
       +
       ) => InternalItem[];

packages/types/src/discord/require.ts

···

       6
       6
        
         CommonComponents,

     

       7
       7
        
         CommonFluxDispatcher

     

       8
       8
        
       } from "../coreExtensions";

     

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

     

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

     

       10
       11
        
       

     

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

     
···

       27
       28
        
       };

     

       28
       29
        
       

     

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

     

       31
       31
       +
       

     

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

     

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

     

       30
       34
        
       

     

       31
       35
        
       export default WebpackRequire;

+1 -1

packages/types/src/discord/webpack.ts

···

       3
       3
        
       export type WebpackRequireType = typeof WebpackRequire & {

     

       4
       4
        
         c: Record<string, WebpackModule>;

     

       5
       5
        
         m: Record<string, WebpackModuleFunc>;

     

       6
       6
       -
         el: (module: number | string) => Promise<void>;

     

       6
       6
       +
         e: (module: number | string) => Promise<void>;

     

       7
       7
        
       };

     

       8
       8
        
       

     

       9
       9
        
       export type WebpackModule = {

packages/types/src/globals.ts

···

       3
       3
        
       import {

     

       4
       4
        
         DetectedExtension,

     

       5
       5
        
         IdentifiedPatch,

     

       6
       6
       +
         IdentifiedWebpackModule,

     

       6
       7
        
         ProcessedExtensions

     

       7
       8
        
       } from "./extension";

     

       8
       9
        
       import EventEmitter from "events";

     
···

       36
       37
        
       

     

       37
       38
        
       export type MoonlightWeb = {

     

       38
       39
        
         unpatched: Set<IdentifiedPatch>;

     

       40
       40
       +
         pendingModules: Set<IdentifiedWebpackModule>;

     

       39
       41
        
         enabledExtensions: Set<string>;

     

       40
       42
        
       

     

       41
       43
        
         getConfig: (ext: string) => ConfigExtension["config"];

+18 -5

packages/types/src/import.d.ts

···

       6
       6
        
       

     

       7
       7
        
       declare module "@moonlight-mod/wp/common_components" {

     

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

     

       9
       9
       -
         const components: CoreExtensions.CommonComponents;

     

       10
       10
       -
         export default components;

     

       11
       11
       -
         export = components;

     

       9
       9
       +
         const CommonComponent: CoreExtensions.CommonComponents;

     

       10
       10
       +
         export = CommonComponent;

     

       12
       11
        
       }

     

       13
       12
        
       

     

       14
       13
        
       declare module "@moonlight-mod/wp/common_flux" {

     

       15
       14
        
         import { CoreExtensions } from "@moonlight-mod/types";

     

       16
       15
        
         const Flux: CoreExtensions.CommonFlux;

     

       17
       17
       -
         export default Flux;

     

       16
       16
       +
         // FIXME: This is wrong, the default export differs from the named exports.

     

       17
       17
       +
         export = Flux;

     

       18
       18
        
       }

     

       19
       19
        
       

     

       20
       20
        
       declare module "@moonlight-mod/wp/common_fluxDispatcher" {

     
···

       23
       23
        
         export default Dispatcher;

     

       24
       24
        
       }

     

       25
       25
        
       

     

       26
       26
       +
       declare module "@moonlight-mod/wp/common_stores";

     

       27
       27
       +
       

     

       26
       28
        
       declare module "@moonlight-mod/wp/common_react" {

     

       27
       29
        
         import React from "react";

     

       28
       30
        
         export = React;

     
···

       32
       34
        
         import { CoreExtensions } from "@moonlight-mod/types";

     

       33
       35
        
         export const Settings: CoreExtensions.Settings;

     

       34
       36
        
         export default Settings;

     

       35
       35
       -
         export = Settings;

     

       36
       37
        
       }

     

       37
       38
        
       

     

       38
       39
        
       declare module "@moonlight-mod/wp/markdown_markdown" {

     
···

       40
       41
        
         const Markdown: CoreExtensions.Markdown.Markdown;

     

       41
       42
        
         export = Markdown;

     

       42
       43
        
       }

     

       44
       44
       +
       

     

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

     

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

     

       47
       47
       +
         const EvilParser: CoreExtensions.ContextMenu.EvilItemParser;

     

       48
       48
       +
         export = EvilParser;

     

       49
       49
       +
       }

     

       50
       50
       +
       

     

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

     

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

     

       53
       53
       +
         const ContextMenu: CoreExtensions.ContextMenu.ContextMenu;

     

       54
       54
       +
         export = ContextMenu;

     

       55
       55
       +
       }

-1

packages/types/src/index.ts

···

       1
       1
       -
       /// <reference types="node" />

     

       2
       1
        
       /// <reference types="standalone-electron-types" />

     

       3
       2
        
       /// <reference types="react" />

     

       4
       3
        
       /// <reference types="flux" />

-1

packages/types/tsconfig.json

···

       5
       5
        
           "esModuleInterop": true,

     

       6
       6
        
           "forceConsistentCasingInFileNames": true,

     

       7
       7
        
           "strict": true,

     

       8
       8
       -
           "skipLibCheck": true,

     

       9
       8
        
           "moduleResolution": "bundler",

     

       10
       9
        
           "jsx": "react",

     

       11
       10
        
           "declaration": true

packages/web-preload/src/index.ts

···

       8
       8
        
       

     

       9
       9
        
         window.moonlight = {

     

       10
       10
        
           unpatched: new Set(),

     

       11
       11
       +
           pendingModules: new Set(),

     

       11
       12
        
           enabledExtensions: new Set(),

     

       12
       13
        
       

     

       13
       14
        
           getConfig: moonlightNode.getConfig.bind(moonlightNode),

-7

pnpm-lock.yaml

···

       80
       80
        
             '@types/flux':

     

       81
       81
        
               specifier: ^3.1.12

     

       82
       82
        
               version: 3.1.12

     

       83
       83
       -
             '@types/node':

     

       84
       84
       -
               specifier: ^20.6.2

     

       85
       85
       -
               version: 20.6.2

     

       86
       83
        
             '@types/react':

     

       87
       84
        
               specifier: ^18.2.22

     

       88
       85
        
               version: 18.2.22

     
···

       421
       418
        
       

     

       422
       419
        
         /@types/node@18.17.17:

     

       423
       420
        
           resolution: {integrity: sha512-cOxcXsQ2sxiwkykdJqvyFS+MLQPLvIdwh5l6gNg8qF6s+C7XSkEWOZjK+XhUZd+mYvHV/180g2cnCcIl4l06Pw==}

     

       424
       424
       -
           dev: false

     

       425
       425
       -
       

     

       426
       426
       -
         /@types/node@20.6.2:

     

       427
       427
       -
           resolution: {integrity: sha512-Y+/1vGBHV/cYk6OI1Na/LHzwnlNCAfU3ZNGrc1LdRe/LAIbdDPTTv/HU3M7yXN448aTVDq3eKRm2cg7iKLb8gw==}

     

       428
       421
        
           dev: false

     

       429
       422
        
       

     

       430
       423
        
         /@types/prop-types@15.7.6:

-1

tsconfig.json

···

       5
       5
        
           "esModuleInterop": true,

     

       6
       6
        
           "forceConsistentCasingInFileNames": true,

     

       7
       7
        
           "strict": true,

     

       8
       8
       -
           "skipLibCheck": true,

     

       9
       8
        
           "moduleResolution": "bundler",

     

       10
       9
        
           "baseUrl": "./packages/",

     

       11
       10
        
           "jsx": "react",