hendrik/lens
1
0
Fork 0
mirror of https://github.com/lensapp/lens.git synced 2025-05-20 05:10:56 +00:00
Code Issues Projects Releases Wiki Activity

Convert all renderer runnables to late-inject style

Browse Source 
- To help fix issues around injection time

Signed-off-by: Sebastian Malton <sebastian@malton.name>
This commit is contained in:
Sebastian Malton 2022-12-05 14:11:24 -05:00
parent 83bb5c37d9
commit c68a1bfd04
16 changed files with 159 additions and 191 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
src/features/cluster/state-sync/renderer/setup-sync.injectable.ts
View File

@ -10,22 +10,19 @@ import requestInitialClusterStatesInjectable from "./request-initial.injectable"
const setupClusterStateSyncInjectable = getInjectable({
id: "setup-cluster-state-sync",
instantiate: (di) => {
const requestInitialClusterStates = di.inject(requestInitialClusterStatesInjectable);
const getClusterById = di.inject(getClusterByIdInjectable);
instantiate: (di) => ({
id: "setup-cluster-state-sync",
run: async () => {
const requestInitialClusterStates = di.inject(requestInitialClusterStatesInjectable);
const getClusterById = di.inject(getClusterByIdInjectable);
const initalStates = await requestInitialClusterStates();
return {
id: "setup-cluster-state-sync",
run: async () => {
const initalStates = await requestInitialClusterStates();
for (const { clusterId, state } of initalStates) {
getClusterById(clusterId)?.setState(state);
}
},
runAfter: di.inject(initClusterStoreInjectable),
};
},
for (const { clusterId, state } of initalStates) {
getClusterById(clusterId)?.setState(state);
}
},
runAfter: di.inject(initClusterStoreInjectable),
}),
injectionToken: beforeFrameStartsInjectionToken,
});

18
src/features/cluster/store/renderer/init.injectable.ts
View File

@ -9,17 +9,15 @@ import initUserStoreInjectable from "../../../../renderer/stores/init-user-store
const initClusterStoreInjectable = getInjectable({
id: "init-cluster-store",
instantiate: (di) => {
const clusterStore = di.inject(clusterStoreInjectable);
instantiate: (di) => ({
id: "init-cluster-store",
run: () => {
const clusterStore = di.inject(clusterStoreInjectable);
return {
id: "init-cluster-store",
run: () => {
clusterStore.load();
},
runAfter: di.inject(initUserStoreInjectable),
};
},
clusterStore.load();
},
runAfter: di.inject(initUserStoreInjectable),
}),
injectionToken: beforeFrameStartsInjectionToken,
});

18
src/features/hotbar/store/renderer/init.injectable.ts
View File

@ -9,17 +9,15 @@ import initClusterStoreInjectable from "../../../cluster/store/renderer/init.inj
const initHotbarStoreInjectable = getInjectable({
id: "init-hotbar-store",
instantiate: (di) => {
const hotbarStore = di.inject(hotbarStoreInjectable);
instantiate: (di) => ({
id: "init-hotbar-store",
run: () => {
const hotbarStore = di.inject(hotbarStoreInjectable);
return {
id: "init-hotbar-store",
run: () => {
hotbarStore.load();
},
runAfter: di.inject(initClusterStoreInjectable),
};
},
hotbarStore.load();
},
runAfter: di.inject(initClusterStoreInjectable),
}),
injectionToken: beforeFrameStartsInjectionToken,
});

20
src/features/theme/system-type/renderer/initialize.injectable.ts
View File

@ -10,18 +10,16 @@ import requestInitialSystemThemeTypeInjectable from "./request-initial.injectabl
const initializeSystemThemeTypeInjectable = getInjectable({
id: "initialize-system-theme-type",
instantiate: (di) => {
const systemThemeConfiguration = di.inject(systemThemeConfigurationInjectable);
const requestInitialSystemThemeType = di.inject(requestInitialSystemThemeTypeInjectable);
instantiate: (di) => ({
id: "initialize-system-theme-type",
run: async () => {
const systemThemeConfiguration = di.inject(systemThemeConfigurationInjectable);
const requestInitialSystemThemeType = di.inject(requestInitialSystemThemeTypeInjectable);
return {
id: "initialize-system-theme-type",
run: async () => {
systemThemeConfiguration.set(await requestInitialSystemThemeType());
},
runAfter: di.inject(initUserStoreInjectable),
};
},
systemThemeConfiguration.set(await requestInitialSystemThemeType());
},
runAfter: di.inject(initUserStoreInjectable),
}),
injectionToken: beforeFrameStartsInjectionToken,
});

21
src/renderer/app-paths/setup-app-paths.injectable.ts
View File

@ -11,19 +11,16 @@ import { requestFromChannelInjectionToken } from "../../common/utils/channel/req
const setupAppPathsInjectable = getInjectable({
id: "setup-app-paths",
instantiate: (di) => {
const requestFromChannel = di.inject(requestFromChannelInjectionToken);
const appPathsState = di.inject(appPathsStateInjectable);
instantiate: (di) => ({
id: "setup-app-paths",
run: async () => {
const requestFromChannel = di.inject(requestFromChannelInjectionToken);
const appPathsState = di.inject(appPathsStateInjectable);
const appPaths = await requestFromChannel(appPathsChannel);
return {
id: "setup-app-paths",
run: async () => {
const appPaths = await requestFromChannel(appPathsChannel);
appPathsState.set(appPaths);
},
};
},
appPathsState.set(appPaths);
},
}),
injectionToken: beforeFrameStartsInjectionToken,
});

18
src/renderer/before-frame-starts/runnables/load-monaco-themes.injectable.ts
View File

@ -9,17 +9,15 @@ import { evenBeforeFrameStartsInjectionToken } from "../tokens";
const loadMonacoThemesInjectable = getInjectable({
id: "load-monaco-themes",
instantiate: (di) => {
const customThemes = di.injectMany(customMonacoThemeInjectionToken);
const addNewMonacoTheme = di.inject(addNewMonacoThemeInjectable);
instantiate: (di) => ({
id: "load-monaco-themes",
run: () => {
const customThemes = di.injectMany(customMonacoThemeInjectionToken);
const addNewMonacoTheme = di.inject(addNewMonacoThemeInjectable);
return {
id: "load-monaco-themes",
run: () => {
customThemes.forEach(addNewMonacoTheme);
},
};
},
customThemes.forEach(addNewMonacoTheme);
},
}),
injectionToken: evenBeforeFrameStartsInjectionToken,
});

30
src/renderer/before-frame-starts/runnables/setup-current-cluster-broadcast.injectable.ts
View File

@ -11,23 +11,21 @@ import { evenBeforeMainFrameStartsInjectionToken } from "../tokens";
const setupCurrentClusterBroadcastInjectable = getInjectable({
id: "setup-current-cluster-broadcast",
instantiate: (di) => {
const matchedClusterId = di.inject(matchedClusterIdInjectable);
const sendMessageToChannel = di.inject(sendMessageToChannelInjectionToken);
instantiate: (di) => ({
id: "setup-current-cluster-broadcast",
run: () => {
const matchedClusterId = di.inject(matchedClusterIdInjectable);
const sendMessageToChannel = di.inject(sendMessageToChannelInjectionToken);
return {
id: "setup-current-cluster-broadcast",
run: () => {
reaction(
() => matchedClusterId.get(),
clusterId => sendMessageToChannel(currentClusterMessageChannel, clusterId),
{
fireImmediately: true,
},
);
},
};
},
reaction(
() => matchedClusterId.get(),
clusterId => sendMessageToChannel(currentClusterMessageChannel, clusterId),
{
fireImmediately: true,
},
);
},
}),
injectionToken: evenBeforeMainFrameStartsInjectionToken,
});

19
src/renderer/before-frame-starts/runnables/setup-root-mac-class.injectable.ts
View File

@ -8,18 +8,15 @@ import { beforeFrameStartsInjectionToken } from "../tokens";
const setupRootMacClassnameInjectable = getInjectable({
id: "setup-root-mac-classname",
instantiate: (di) => {
const isMac = di.inject(isMacInjectable);
instantiate: (di) => ({
id: "setup-root-mac-classname",
run: () => {
const isMac = di.inject(isMacInjectable);
const rootElem = document.getElementById("app");
return {
id: "setup-root-mac-classname",
run: () => {
const rootElem = document.getElementById("app");
rootElem?.classList.toggle("is-mac", isMac);
},
};
},
rootElem?.classList.toggle("is-mac", isMac);
},
}),
injectionToken: beforeFrameStartsInjectionToken,
});

32
src/renderer/before-frame-starts/runnables/setup-weblink-context-menu-open.injectable.tsx
View File

@ -11,25 +11,23 @@ import { beforeFrameStartsInjectionToken } from "../tokens";
const setupWeblickContextMenuOpenInjectable = getInjectable({
id: "setup-weblick-context-menu-open",
instantiate: (di) => {
const catalogCategoryRegistry = di.inject(catalogCategoryRegistryInjectable);
const commandOverlay = di.inject(commandOverlayInjectable);
instantiate: (di) => ({
id: "setup-weblick-context-menu-open",
run: () => {
const catalogCategoryRegistry = di.inject(catalogCategoryRegistryInjectable);
const commandOverlay = di.inject(commandOverlayInjectable);
return {
id: "setup-weblick-context-menu-open",
run: () => {
catalogCategoryRegistry
.getForGroupKind("entity.k8slens.dev", "WebLink")
?.on("catalogAddMenu", ctx => {
ctx.menuItems.push({
title: "Add web link",
icon: "public",
onClick: () => commandOverlay.open(<WeblinkAddCommand />),
});
catalogCategoryRegistry
.getForGroupKind("entity.k8slens.dev", "WebLink")
?.on("catalogAddMenu", ctx => {
ctx.menuItems.push({
title: "Add web link",
icon: "public",
onClick: () => commandOverlay.open(<WeblinkAddCommand />),
});
},
};
},
});
},
}),
injectionToken: beforeFrameStartsInjectionToken,
});

28
src/renderer/components/layout/top-bar/start-state-sync.injectable.ts
View File

@ -11,23 +11,21 @@ import topBarStateInjectable from "./state.injectable";
// TODO: replace with a SyncBox
const startTopbarStateSyncInjectable = getInjectable({
id: "start-topbar-state-sync",
instantiate: (di) => {
const state = di.inject(topBarStateInjectable);
const ipcRenderer = di.inject(ipcRendererInjectable);
instantiate: (di) => ({
id: "start-topbar-state-sync",
run: () => {
const state = di.inject(topBarStateInjectable);
const ipcRenderer = di.inject(ipcRendererInjectable);
return {
id: "start-topbar-state-sync",
run: () => {
ipcRenderer.on("history:can-go-back", action((event, canGoBack: boolean) => {
state.prevEnabled = canGoBack;
}));
ipcRenderer.on("history:can-go-back", action((event, canGoBack: boolean) => {
state.prevEnabled = canGoBack;
}));
ipcRenderer.on("history:can-go-forward", action((event, canGoForward: boolean) => {
state.nextEnabled = canGoForward;
}));
},
};
},
ipcRenderer.on("history:can-go-forward", action((event, canGoForward: boolean) => {
state.nextEnabled = canGoForward;
}));
},
}),
injectionToken: beforeFrameStartsInjectionToken,
causesSideEffects: true,
});

18
src/renderer/utils/channel/channel-listeners/start-listening-of-channels.injectable.ts
View File

@ -5,20 +5,20 @@
import { getInjectable } from "@ogre-tools/injectable";
import { beforeFrameStartsInjectionToken } from "../../../before-frame-starts/tokens";
import listeningOnMessageChannelsInjectable from "../../../../common/utils/channel/listening-on-message-channels.injectable";
import setupAppPathsInjectable from "../../../app-paths/setup-app-paths.injectable";
const startListeningOfChannelsInjectable = getInjectable({
id: "start-listening-of-channels-renderer",
instantiate: (di) => {
const listeningOfChannels = di.inject(listeningOnMessageChannelsInjectable);
instantiate: (di) => ({
id: "start-listening-of-channels-renderer",
run: () => {
const listeningOfChannels = di.inject(listeningOnMessageChannelsInjectable);
return {
id: "start-listening-of-channels-renderer",
run: () => {
listeningOfChannels.start();
},
};
},
listeningOfChannels.start();
},
runAfter: di.inject(setupAppPathsInjectable),
}),
injectionToken: beforeFrameStartsInjectionToken,
});

39
src/renderer/utils/sync-box/provide-initial-values-for-sync-boxes.injectable.ts
View File

@ -8,38 +8,29 @@ import { syncBoxInitialValueChannel } from "../../../common/utils/sync-box/chann
import createSyncBoxStateInjectable from "../../../common/utils/sync-box/sync-box-state.injectable";
import { requestFromChannelInjectionToken } from "../../../common/utils/channel/request-from-channel-injection-token";
import { runInAction } from "mobx";
import type { SyncBox } from "../../../common/utils/sync-box/sync-box-injection-token";
import { syncBoxInjectionToken } from "../../../common/utils/sync-box/sync-box-injection-token";
import assert from "assert";
const provideInitialValuesForSyncBoxesInjectable = getInjectable({
id: "provide-initial-values-for-sync-boxes",
instantiate: (di) => {
const requestFromChannel = di.inject(requestFromChannelInjectionToken);
instantiate: (di) => ({
id: "provide-initial-values-for-sync-boxes",
run: async () => {
const requestFromChannel = di.inject(requestFromChannelInjectionToken);
const syncBoxes = di.injectMany(syncBoxInjectionToken);
const initialValues = await requestFromChannel(syncBoxInitialValueChannel);
const syncBoxes = di.injectMany(syncBoxInjectionToken);
runInAction(() => {
for (const { id, value } of initialValues) {
const syncBox = syncBoxes.find((box) => box.id === id);
const setSyncBoxState = (syncBox: SyncBox<any>, state: any) =>
di.inject(createSyncBoxStateInjectable, syncBox.id).set(state);
return {
id: "provide-initial-values-for-sync-boxes",
run: async () => {
const initialValues = await requestFromChannel(syncBoxInitialValueChannel);
runInAction(() => {
initialValues.forEach(({ id, value }) => {
const syncBox = syncBoxes.find((box) => box.id === id);
assert(syncBox);
setSyncBoxState(syncBox, value);
});
});
},
};
},
assert(syncBox);
di.inject(createSyncBoxStateInjectable, syncBox.id).set(value);
}
});
},
}),
injectionToken: beforeFrameStartsInjectionToken,
});

14
src/renderer/vars/build-version/init.injectable.ts
View File

@ -8,14 +8,14 @@ import buildVersionInjectable from "./build-version.injectable";
const initializeBuildVersionInjectable = getInjectable({
id: "initialize-build-version",
instantiate: (di) => {
const buildVersion = di.inject(buildVersionInjectable);
instantiate: (di) => ({
id: "initialize-build-version",
run: async () => {
const buildVersion = di.inject(buildVersionInjectable);
return {
id: "initialize-build-version",
run: () => buildVersion.init(),
};
},
await buildVersion.init();
},
}),
injectionToken: beforeFrameStartsInjectionToken,
});

16
src/renderer/vars/default-update-channel/init.injectable.ts
View File

@ -9,15 +9,15 @@ import defaultUpdateChannelInjectable from "../../../features/application-update
const initDefaultUpdateChannelInjectable = getInjectable({
id: "init-default-update-channel",
instantiate: (di) => {
const defaultUpdateChannel = di.inject(defaultUpdateChannelInjectable);
instantiate: (di) => ({
id: "init-default-update-channel",
run: async () => {
const defaultUpdateChannel = di.inject(defaultUpdateChannelInjectable);
return {
id: "init-default-update-channel",
run: () => defaultUpdateChannel.init(),
runAfter: di.inject(initReleaseChannelInjectable),
};
},
await defaultUpdateChannel.init();
},
runAfter: di.inject(initReleaseChannelInjectable),
}),
injectionToken: beforeFrameStartsInjectionToken,
});

16
src/renderer/vars/release-channel/init.injectable.ts
View File

@ -9,15 +9,15 @@ import initSemanticBuildVersionInjectable from "../semantic-build-version/init.i
const initReleaseChannelInjectable = getInjectable({
id: "init-release-channel",
instantiate: (di) => {
const releaseChannel = di.inject(releaseChannelInjectable);
instantiate: (di) => ({
id: "init-release-channel",
run: async () => {
const releaseChannel = di.inject(releaseChannelInjectable);
return {
id: "init-release-channel",
run: () => releaseChannel.init(),
runAfter: di.inject(initSemanticBuildVersionInjectable),
};
},
await releaseChannel.init();
},
runAfter: di.inject(initSemanticBuildVersionInjectable),
}),
injectionToken: beforeFrameStartsInjectionToken,
});

16
src/renderer/vars/semantic-build-version/init.injectable.ts
View File

@ -9,15 +9,15 @@ import initializeBuildVersionInjectable from "../build-version/init.injectable";
const initSemanticBuildVersionInjectable = getInjectable({
id: "init-semantic-build-version",
instantiate: (di) => {
const buildSemanticVersion = di.inject(buildSemanticVersionInjectable);
instantiate: (di) => ({
id: "init-semantic-build-version",
run: async () => {
const buildSemanticVersion = di.inject(buildSemanticVersionInjectable);
return {
id: "init-semantic-build-version",
run: () => buildSemanticVersion.init(),
runAfter: di.inject(initializeBuildVersionInjectable),
};
},
await buildSemanticVersion.init();
},
runAfter: di.inject(initializeBuildVersionInjectable),
}),
injectionToken: beforeFrameStartsInjectionToken,
});