···

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

     

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

     

       
2
       
2
       
+
       
import { constants, ExtensionLoadSource } from "@moonlight-mod/types";

     

       
3
       
3
       
 
       
import { ExtensionCompat } from "@moonlight-mod/core/extension/loader";

     

       
4
       
4
       
 
       


     

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

     
···

       
12
       
12
       
 
       


     

       
13
       
13
       
 
       
import ExtensionInfo from "./info";

     

       
14
       
14
       
 
       
import Settings from "./settings";

     

       
15
       
15
       
-
       
import installWithDependencyPopup from "./popup";

     

       
15
       
15
       
+
       
import { doBuiltinExtensionPopup, doMissingExtensionPopup } from "./popup";

     

       
16
       
16
       
 
       


     

       
17
       
17
       
 
       
export enum ExtensionPage {

     

       
18
       
18
       
 
       
  Info,

     
···

       
98
       
98
       
 
       
                  submitting={busy}

     

       
99
       
99
       
 
       
                  disabled={ext.compat !== ExtensionCompat.Compatible || conflicting}

     

       
100
       
100
       
 
       
                  onClick={async () => {

     

       
101
       
101
       
-
       
                    await installWithDependencyPopup(uniqueId);

     

       
101
       
101
       
+
       
                    await MoonbaseSettingsStore.installExtension(uniqueId);

     

       
102
       
102
       
+
       
                    const deps = await MoonbaseSettingsStore.getDependencies(uniqueId);

     

       
103
       
103
       
+
       
                    if (deps != null) {

     

       
104
       
104
       
+
       
                      await doMissingExtensionPopup(deps);

     

       
105
       
105
       
+
       
                    }

     

       
102
       
106
       
 
       
                  }}

     

       
103
       
107
       
 
       
                >

     

       
104
       
108
       
 
       
                  Install

     
···

       
157
       
161
       
 
       
                      : undefined

     

       
158
       
162
       
 
       
                }

     

       
159
       
163
       
 
       
                onChange={() => {

     

       
160
       
160
       
-
       
                  setRestartNeeded(true);

     

       
161
       
161
       
-
       
                  MoonbaseSettingsStore.setExtensionEnabled(uniqueId, !enabled);

     

       
164
       
164
       
+
       
                  const toggle = () => {

     

       
165
       
165
       
+
       
                    setRestartNeeded(true);

     

       
166
       
166
       
+
       
                    MoonbaseSettingsStore.setExtensionEnabled(uniqueId, !enabled);

     

       
167
       
167
       
+
       
                  };

     

       
168
       
168
       
+
       


     

       
169
       
169
       
+
       
                  if (enabled && constants.builtinExtensions.includes(ext.id)) {

     

       
170
       
170
       
+
       
                    doBuiltinExtensionPopup(uniqueId, toggle);

     

       
171
       
171
       
+
       
                  } else {

     

       
172
       
172
       
+
       
                    toggle();

     

       
173
       
173
       
+
       
                  }

     

       
162
       
174
       
 
       
                }}

     

       
163
       
175
       
 
       
              />

     

       
164
       
176
       
 
       
            </div>

     

···

       
10
       
10
       
 
       
const { openModalLazy, useModalsStore, closeModal } = Components;

     

       
11
       
11
       
 
       
const Popup = spacepack.findByCode(".minorContainer", "secondaryAction")[0].exports.default;

     

       
12
       
12
       
 
       


     

       
13
       
13
       
+
       
function close() {

     

       
14
       
14
       
+
       
  const ModalStore = useModalsStore.getState();

     

       
15
       
15
       
+
       
  closeModal(ModalStore.default[0].key);

     

       
16
       
16
       
+
       
}

     

       
17
       
17
       
+
       


     

       
13
       
18
       
 
       
const presentableLoadSources: Record<ExtensionLoadSource, string> = {

     

       
14
       
19
       
 
       
  [ExtensionLoadSource.Developer]: "Local extension", // should never show up

     

       
15
       
20
       
 
       
  [ExtensionLoadSource.Core]: "Core extension",

     
···

       
50
       
55
       
 
       
  );

     

       
51
       
56
       
 
       
}

     

       
52
       
57
       
 
       


     

       
53
       
53
       
-
       
function close() {

     

       
54
       
54
       
-
       
  const ModalStore = useModalsStore.getState();

     

       
55
       
55
       
-
       
  closeModal(ModalStore.default[0].key);

     

       
56
       
56
       
-
       
}

     

       
57
       
57
       
-
       


     

       
58
       
58
       
-
       
function OurPopup({

     

       
58
       
58
       
+
       
function MissingExtensionPopup({

     

       
59
       
59
       
 
       
  deps,

     

       
60
       
60
       
 
       
  transitionState

     

       
61
       
61
       
 
       
}: {

     
···

       
148
       
148
       
 
       
  );

     

       
149
       
149
       
 
       
}

     

       
150
       
150
       
 
       


     

       
151
       
151
       
-
       
export async function doPopup(deps: Record<string, MoonbaseExtension[]>) {

     

       
151
       
151
       
+
       
export async function doMissingExtensionPopup(deps: Record<string, MoonbaseExtension[]>) {

     

       
152
       
152
       
 
       
  await openModalLazy(async () => {

     

       
153
       
153
       
 
       
    return ({ transitionState }: { transitionState: number | null }) => {

     

       
154
       
154
       
-
       
      return <OurPopup transitionState={transitionState} deps={deps} />;

     

       
154
       
154
       
+
       
      return <MissingExtensionPopup transitionState={transitionState} deps={deps} />;

     

       
155
       
155
       
 
       
    };

     

       
156
       
156
       
 
       
  });

     

       
157
       
157
       
 
       
}

     

       
158
       
158
       
 
       


     

       
159
       
159
       
-
       
export default async function installWithDependencyPopup(uniqueId: number) {

     

       
160
       
160
       
-
       
  await MoonbaseSettingsStore.installExtension(uniqueId);

     

       
161
       
161
       
-
       
  const deps = await MoonbaseSettingsStore.getDependencies(uniqueId);

     

       
162
       
162
       
-
       
  if (deps != null) {

     

       
163
       
163
       
-
       
    await doPopup(deps);

     

       
164
       
164
       
-
       
  }

     

       
159
       
159
       
+
       
function BuiltinExtensionPopup({

     

       
160
       
160
       
+
       
  transitionState,

     

       
161
       
161
       
+
       
  uniqueId,

     

       
162
       
162
       
+
       
  cb

     

       
163
       
163
       
+
       
}: {

     

       
164
       
164
       
+
       
  transitionState: number | null;

     

       
165
       
165
       
+
       
  uniqueId: number;

     

       
166
       
166
       
+
       
  cb: () => void;

     

       
167
       
167
       
+
       
}) {

     

       
168
       
168
       
+
       
  const { Text } = Components;

     

       
169
       
169
       
+
       


     

       
170
       
170
       
+
       
  return (

     

       
171
       
171
       
+
       
    <Popup

     

       
172
       
172
       
+
       
      body={

     

       
173
       
173
       
+
       
        <Flex>

     

       
174
       
174
       
+
       
          <Text variant="text-md/normal">

     

       
175
       
175
       
+
       
            This extension is enabled by default. Disabling it might have consequences. Are you sure you want to disable

     

       
176
       
176
       
+
       
            it?

     

       
177
       
177
       
+
       
          </Text>

     

       
178
       
178
       
+
       
        </Flex>

     

       
179
       
179
       
+
       
      }

     

       
180
       
180
       
+
       
      cancelText="No"

     

       
181
       
181
       
+
       
      confirmText="Yes"

     

       
182
       
182
       
+
       
      onCancel={close}

     

       
183
       
183
       
+
       
      onConfirm={() => {

     

       
184
       
184
       
+
       
        close();

     

       
185
       
185
       
+
       
        cb();

     

       
186
       
186
       
+
       
      }}

     

       
187
       
187
       
+
       
      title="Built in extension"

     

       
188
       
188
       
+
       
      transitionState={transitionState}

     

       
189
       
189
       
+
       
    />

     

       
190
       
190
       
+
       
  );

     

       
191
       
191
       
+
       
}

     

       
192
       
192
       
+
       


     

       
193
       
193
       
+
       
export async function doBuiltinExtensionPopup(uniqueId: number, cb: () => void) {

     

       
194
       
194
       
+
       
  await openModalLazy(async () => {

     

       
195
       
195
       
+
       
    return ({ transitionState }: { transitionState: number | null }) => {

     

       
196
       
196
       
+
       
      return <BuiltinExtensionPopup transitionState={transitionState} uniqueId={uniqueId} cb={cb} />;

     

       
197
       
197
       
+
       
    };

     

       
198
       
198
       
+
       
  });

     

       
165
       
199
       
 
       
}

     

···

       
6
       
6
       
 
       
const logger = new Logger("core/config");

     

       
7
       
7
       
 
       


     

       
8
       
8
       
 
       
const defaultConfig: Config = {

     

       
9
       
9
       
+
       
  // If you're updating this, update `builtinExtensions` in constants as well

     

       
9
       
10
       
 
       
  extensions: {

     

       
10
       
11
       
 
       
    moonbase: true,

     

       
11
       
12
       
 
       
    disableSentry: true,

     

···

       
14
       
14
       
 
       
export const apiLevel = 2;

     

       
15
       
15
       
 
       


     

       
16
       
16
       
 
       
export const mainRepo = "https://moonlight-mod.github.io/extensions-dist/repo.json";

     

       
17
       
17
       
+
       
// If you're updating this, update `defaultConfig` in core as well

     

       
18
       
18
       
+
       
export const builtinExtensions = ["moonbase", "disableSentry", "noTrack", "noHideToken"];