commit 6b210d8459a064f28681b0b86cffecb058f8b199 · notnite.com/moonlight

+8 -1

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

···

       5
       5
        
           "tagline": "The official settings UI for moonlight",

     

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

     

       7
       7
        
         },

     

       8
       8
       -
         "dependencies": ["spacepack", "settings", "common"]

     

       8
       8
       +
         "dependencies": ["spacepack", "settings", "common"],

     

       9
       9
       +
         "settings": {

     

       10
       10
       +
           "saveFilter": {

     

       11
       11
       +
             "displayName": "Persist filter",

     

       12
       12
       +
             "description": "Save extension filter in config",

     

       13
       13
       +
             "type": "boolean"

     

       14
       14
       +
           }

     

       15
       15
       +
         }

     

       9
       16
        
       }

+28 -33

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

···

       6
       6
        
         ChevronSmallUpIconSVG

     

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

     

       8
       8
        
       

     

       9
       9
       -
       export const defaultFilter = {

     

       10
       10
       -
         core: true,

     

       11
       11
       -
         normal: true,

     

       12
       12
       -
         developer: true,

     

       13
       13
       -
         enabled: true,

     

       14
       14
       -
         disabled: true,

     

       15
       15
       -
         installed: true,

     

       16
       16
       -
         repository: true

     

       17
       17
       -
       };

     

       18
       18
       -
       export type Filter = typeof defaultFilter;

     

       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;

     
···

       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
       +
       

     

       90
       93
        
           return (

     

       91
       94
        
             <div className={SortMenuClasses.container}>

     

       92
       95
        
               <Menu navId="sort-filter" hideScrollbar={true} onClose={closePopout}>

     
···

       94
       97
        
                   <MenuCheckboxItem

     

       95
       98
        
                     id="t-core"

     

       96
       99
        
                     label="Core"

     

       97
       97
       -
                     checked={filter.core}

     

       98
       98
       -
                     action={() => setFilter({ ...filter, core: !filter.core })}

     

       100
       100
       +
                     checked={filter & Filter.Core}

     

       101
       101
       +
                     action={() => toggleFilter(Filter.Core)}

     

       99
       102
        
                   />

     

       100
       103
        
                   <MenuCheckboxItem

     

       101
       104
        
                     id="t-normal"

     

       102
       105
        
                     label="Normal"

     

       103
       103
       -
                     checked={filter.normal}

     

       104
       104
       -
                     action={() => setFilter({ ...filter, normal: !filter.normal })}

     

       106
       106
       +
                     checked={filter & Filter.Normal}

     

       107
       107
       +
                     action={() => toggleFilter(Filter.Normal)}

     

       105
       108
        
                   />

     

       106
       109
        
                   <MenuCheckboxItem

     

       107
       110
        
                     id="t-developer"

     

       108
       111
        
                     label="Developer"

     

       109
       109
       -
                     checked={filter.developer}

     

       110
       110
       -
                     action={() =>

     

       111
       111
       -
                       setFilter({ ...filter, developer: !filter.developer })

     

       112
       112
       -
                     }

     

       112
       112
       +
                     checked={filter & Filter.Developer}

     

       113
       113
       +
                     action={() => toggleFilter(Filter.Developer)}

     

       113
       114
        
                   />

     

       114
       115
        
                 </MenuGroup>

     

       115
       116
        
                 <MenuGroup label="State">

     

       116
       117
        
                   <MenuCheckboxItem

     

       117
       118
        
                     id="s-enabled"

     

       118
       119
        
                     label="Enabled"

     

       119
       119
       -
                     checked={filter.enabled}

     

       120
       120
       -
                     action={() => setFilter({ ...filter, enabled: !filter.enabled })}

     

       120
       120
       +
                     checked={filter & Filter.Enabled}

     

       121
       121
       +
                     action={() => toggleFilter(Filter.Enabled)}

     

       121
       122
        
                   />

     

       122
       123
        
                   <MenuCheckboxItem

     

       123
       124
        
                     id="s-disabled"

     

       124
       125
        
                     label="Disabled"

     

       125
       125
       -
                     checked={filter.disabled}

     

       126
       126
       -
                     action={() =>

     

       127
       127
       -
                       setFilter({ ...filter, disabled: !filter.disabled })

     

       128
       128
       -
                     }

     

       126
       126
       +
                     checked={filter & Filter.Disabled}

     

       127
       127
       +
                     action={() => toggleFilter(Filter.Disabled)}

     

       129
       128
        
                   />

     

       130
       129
        
                 </MenuGroup>

     

       131
       130
        
                 <MenuGroup label="Location">

     

       132
       131
        
                   <MenuCheckboxItem

     

       133
       132
        
                     id="l-installed"

     

       134
       133
        
                     label="Installed"

     

       135
       135
       -
                     checked={filter.installed}

     

       136
       136
       -
                     action={() =>

     

       137
       137
       -
                       setFilter({ ...filter, installed: !filter.installed })

     

       138
       138
       -
                     }

     

       134
       134
       +
                     checked={filter & Filter.Installed}

     

       135
       135
       +
                     action={() => toggleFilter(Filter.Installed)}

     

       139
       136
        
                   />

     

       140
       137
        
                   <MenuCheckboxItem

     

       141
       138
        
                     id="l-repository"

     

       142
       139
        
                     label="Repository"

     

       143
       143
       -
                     checked={filter.repository}

     

       144
       144
       -
                     action={() =>

     

       145
       145
       -
                       setFilter({ ...filter, repository: !filter.repository })

     

       146
       146
       -
                     }

     

       140
       140
       +
                     checked={filter & Filter.Repository}

     

       141
       141
       +
                     action={() => toggleFilter(Filter.Repository)}

     

       147
       142
        
                   />

     

       148
       143
        
                 </MenuGroup>

     

       149
       144
        
                 <MenuGroup>

     
···

       156
       151
        
                       </Text>

     

       157
       152
        
                     }

     

       158
       153
        
                     action={() => {

     

       159
       159
       -
                       setFilter({ ...defaultFilter });

     

       154
       154
       +
                       setFilter(defaultFilter);

     

       160
       155
        
                       closePopout();

     

       161
       156
        
                     }}

     

       162
       157
        
                   />

+44 -26

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

···

       4
       4
        
         WebpackRequireType

     

       5
       5
        
       } from "@moonlight-mod/types";

     

       6
       6
        
       import { ExtensionState } from "../../types";

     

       7
       7
       -
       import filterBar, { defaultFilter } from "./filterBar";

     

       7
       7
       +
       import filterBar, { Filter, defaultFilter } from "./filterBar";

     

       8
       8
        
       import card from "./card";

     

       9
       9
        
       

     

       10
       10
        
       export default (require: WebpackRequireType) => {

     
···

       26
       26
        
         const { Text } = require("common_components");

     

       27
       27
        
       

     

       28
       28
        
         return function ExtensionsPage() {

     

       29
       29
       -
           const { extensions } = Flux.useStateFromStoresObject(

     

       29
       29
       +
           const { extensions, savedFilter } = Flux.useStateFromStoresObject(

     

       30
       30
        
             [MoonbaseSettingsStore],

     

       31
       31
        
             () => {

     

       32
       32
       -
               return { extensions: MoonbaseSettingsStore.extensions };

     

       32
       32
       +
               return {

     

       33
       33
       +
                 extensions: MoonbaseSettingsStore.extensions,

     

       34
       34
       +
                 savedFilter: MoonbaseSettingsStore.getExtensionConfig(

     

       35
       35
       +
                   "moonbase",

     

       36
       36
       +
                   "filter"

     

       37
       37
       +
                 )

     

       38
       38
       +
               };

     

       33
       39
        
             }

     

       34
       40
        
           );

     

       35
       41
        
       

     

       36
       42
        
           const [query, setQuery] = React.useState("");

     

       37
       43
        
       

     

       38
       38
       -
           const savedFilter = MoonbaseSettingsStore.getConfigOption(

     

       39
       39
       -
             "saveExtensionFilter"

     

       40
       40
       -
           )

     

       41
       41
       -
             ? MoonbaseSettingsStore.getConfigOption("extensionsFilter")

     

       42
       42
       -
             : null;

     

       43
       43
       -
           const [filter, setFilter] = React.useState(

     

       44
       44
       -
             savedFilter ? { ...savedFilter } : { ...defaultFilter }

     

       45
       45
       -
           );

     

       44
       44
       +
           // const [filter, setFilter] = React.useState(

     

       45
       45
       +
           //   moonlight.getConfigOption<boolean>("moonbase", "saveFilters")

     

       46
       46
       +
           //     ? moonlight.getConfigOption<number>("moonbase", "filters") ??

     

       47
       47
       +
           //         defaultFilter

     

       48
       48
       +
           //     : defaultFilter

     

       49
       49
       +
           // );

     

       50
       50
       +
           let filter: Filter, setFilter: (filter: Filter) => void;

     

       51
       51
       +
           if (moonlight.getConfigOption<boolean>("moonbase", "saveFilter")) {

     

       52
       52
       +
             filter = savedFilter ?? defaultFilter;

     

       53
       53
       +
             setFilter = (filter) =>

     

       54
       54
       +
               MoonbaseSettingsStore.setExtensionConfig("moonbase", "filter", filter);

     

       55
       55
       +
           } else {

     

       56
       56
       +
             const state = React.useState(defaultFilter);

     

       57
       57
       +
             filter = state[0];

     

       58
       58
       +
             setFilter = state[1];

     

       59
       59
       +
           }

     

       46
       60
        
           const [selectedTags, setSelectedTags] = React.useState(new Set<string>());

     

       47
       61
        
           const sorted = Object.values(extensions).sort((a, b) => {

     

       48
       62
        
             const aName = a.manifest.meta?.name ?? a.id;

     
···

       60
       74
        
               ) &&

     

       61
       75
        
               // This seems very bad, sorry

     

       62
       76
        
               !(

     

       63
       63
       -
                 (!filter.core && ext.source.type === ExtensionLoadSource.Core) ||

     

       64
       64
       -
                 (!filter.normal && ext.source.type === ExtensionLoadSource.Normal) ||

     

       65
       65
       -
                 (!filter.developer &&

     

       77
       77
       +
                 (!(filter & Filter.Core) &&

     

       78
       78
       +
                   ext.source.type === ExtensionLoadSource.Core) ||

     

       79
       79
       +
                 (!(filter & Filter.Normal) &&

     

       80
       80
       +
                   ext.source.type === ExtensionLoadSource.Normal) ||

     

       81
       81
       +
                 (!(filter & Filter.Developer) &&

     

       66
       82
        
                   ext.source.type === ExtensionLoadSource.Developer) ||

     

       67
       67
       -
                 (!filter.enabled &&

     

       83
       83
       +
                 (!(filter & Filter.Enabled) &&

     

       68
       84
        
                   MoonbaseSettingsStore.getExtensionEnabled(ext.id)) ||

     

       69
       69
       -
                 (!filter.disabled &&

     

       85
       85
       +
                 (!(filter & Filter.Disabled) &&

     

       70
       86
        
                   !MoonbaseSettingsStore.getExtensionEnabled(ext.id)) ||

     

       71
       71
       -
                 (!filter.installed && ext.state !== ExtensionState.NotDownloaded) ||

     

       72
       72
       -
                 (!filter.repository && ext.state === ExtensionState.NotDownloaded)

     

       87
       87
       +
                 (!(filter & Filter.Installed) &&

     

       88
       88
       +
                   ext.state !== ExtensionState.NotDownloaded) ||

     

       89
       89
       +
                 (!(filter & Filter.Repository) &&

     

       90
       90
       +
                   ext.state === ExtensionState.NotDownloaded)

     

       73
       91
        
               )

     

       74
       92
        
           );

     

       75
       93
        
       

     
···

       101
       119
        
                 <FilterBar

     

       102
       120
        
                   filter={filter}

     

       103
       121
        
                   setFilter={(filter) => {

     

       104
       104
       -
                     if (

     

       105
       105
       -
                       MoonbaseSettingsStore.getConfigOption("saveExtensionFilter")

     

       106
       106
       -
                     ) {

     

       107
       107
       -
                       MoonbaseSettingsStore.setConfigOption(

     

       108
       108
       -
                         "extensionsFilter",

     

       109
       109
       -
                         filter

     

       110
       110
       -
                       );

     

       111
       111
       -
                     }

     

       122
       122
       +
                     // if (

     

       123
       123
       +
                     //   MoonbaseSettingsStore.getConfigOption("saveExtensionFilter")

     

       124
       124
       +
                     // ) {

     

       125
       125
       +
                     //   MoonbaseSettingsStore.setConfigOption(

     

       126
       126
       +
                     //     "extensionsFilter",

     

       127
       127
       +
                     //     filter

     

       128
       128
       +
                     //   );

     

       129
       129
       +
                     // }

     

       112
       130
        
                     setFilter(filter);

     

       113
       131
        
                   }}

     

       114
       132
        
                   selectedTags={selectedTags}

-10

packages/core/src/config.ts

···

       9
       9
        
           noTrack: true,

     

       10
       10
        
           noHideToken: true

     

       11
       11
        
         },

     

       12
       12
       -
         saveExtensionFilter: false,

     

       13
       13
       -
         extensionsFilter: {

     

       14
       14
       -
           core: true,

     

       15
       15
       -
           developer: true,

     

       16
       16
       -
           disabled: true,

     

       17
       17
       -
           enabled: true,

     

       18
       18
       -
           installed: true,

     

       19
       19
       -
           normal: true,

     

       20
       20
       -
           repository: true

     

       21
       21
       -
         },

     

       22
       12
        
         repositories: ["https://moonlight-mod.github.io/extensions-dist/repo.json"]

     

       23
       13
        
       };

     

       24
       14

-10

packages/types/src/config.ts

···

       4
       4
        
         devSearchPaths?: string[];

     

       5
       5
        
         loggerLevel?: string;

     

       6
       6
        
         patchAll?: boolean;

     

       7
       7
       -
         saveExtensionFilter: boolean;

     

       8
       8
       -
         extensionsFilter: {

     

       9
       9
       -
           core: boolean;

     

       10
       10
       -
           normal: boolean;

     

       11
       11
       -
           developer: boolean;

     

       12
       12
       -
           enabled: boolean;

     

       13
       13
       -
           disabled: boolean;

     

       14
       14
       -
           installed: boolean;

     

       15
       15
       -
           repository: boolean;

     

       16
       16
       -
         };

     

       17
       7
        
       };

     

       18
       8
        
       

     

       19
       9
        
       export type ConfigExtensions =