rename variantEditor -> sharedVariantEditor

src/components/OutputsTable/VariantEditor.tsx

@@ -7,7 +7,7 @@ import { useAppStore } from "~/state/store";
 // import openAITypes from "~/codegen/openai.types.ts.txt";
 
 export default function VariantConfigEditor(props: { variant: PromptVariant }) {
-  const monaco = useAppStore.use.variantEditor.monaco();
+  const monaco = useAppStore.use.sharedVariantEditor.monaco();
   const editorRef = useRef<ReturnType<NonNullable<typeof monaco>["editor"]["create"]> | null>(null);
   const [editorId] = useState(() => `editor_${Math.random().toString(36).substring(7)}`);
   const [isChanged, setIsChanged] = useState(false);

src/state/sharedVariantEditor.slice.ts

@@ -3,7 +3,7 @@ import { type SliceCreator } from "./store";
 import loader from "@monaco-editor/loader";
 import openAITypes from "~/codegen/openai.types.ts.txt";
 
-export type VariantEditorSlice = {
+export type SharedVariantEditorSlice = {
   monaco: null | ReturnType<typeof loader.__getMonacoInstance>;
   loadMonaco: () => Promise<void>;
   scenarios: RouterOutputs["scenarios"]["list"];
@@ -11,7 +11,7 @@ export type VariantEditorSlice = {
   setScenarios: (scenarios: RouterOutputs["scenarios"]["list"]) => void;
 };
 
-export const createVariantEditorSlice: SliceCreator<VariantEditorSlice> = (set, get) => ({
+export const createVariantEditorSlice: SliceCreator<SharedVariantEditorSlice> = (set, get) => ({
   monaco: loader.__getMonacoInstance(),
   loadMonaco: async () => {
     const monaco = await loader.init();
@@ -41,27 +41,27 @@ export const createVariantEditorSlice: SliceCreator<VariantEditorSlice> = (set,
     );
 
     set((state) => {
-      state.variantEditor.monaco = monaco;
+      state.sharedVariantEditor.monaco = monaco;
     });
-    get().variantEditor.updateScenariosModel();
+    get().sharedVariantEditor.updateScenariosModel();
   },
   scenarios: [],
   // scenariosModel: null,
   setScenarios: (scenarios) => {
     set((state) => {
-      state.variantEditor.scenarios = scenarios;
+      state.sharedVariantEditor.scenarios = scenarios;
     });
 
-    get().variantEditor.updateScenariosModel();
+    get().sharedVariantEditor.updateScenariosModel();
   },
 
   updateScenariosModel: () => {
-    const monaco = get().variantEditor.monaco;
+    const monaco = get().sharedVariantEditor.monaco;
     if (!monaco) return;
 
     const modelContents = `
     const scenarios = ${JSON.stringify(
-      get().variantEditor.scenarios.map((s) => s.variableValues),
+      get().sharedVariantEditor.scenarios.map((s) => s.variableValues),
       null,
       2,
     )} as const;
@@ -70,8 +70,6 @@ export const createVariantEditorSlice: SliceCreator<VariantEditorSlice> = (set,
     declare var scenario: Scenario | null;
     `;
 
-    console.log(modelContents);
-
     const scenariosModel = monaco.editor.getModel(monaco.Uri.parse("file:///scenarios.ts"));
 
     if (scenariosModel) {

src/state/store.ts

@@ -1,13 +1,16 @@
 import { type StateCreator, create } from "zustand";
 import { immer } from "zustand/middleware/immer";
 import { createSelectors } from "./createSelectors";
-import { type VariantEditorSlice, createVariantEditorSlice } from "./variantEditor.slice";
+import {
+  type SharedVariantEditorSlice,
+  createVariantEditorSlice,
+} from "./sharedVariantEditor.slice";
 
 export type State = {
   drawerOpen: boolean;
   openDrawer: () => void;
   closeDrawer: () => void;
-  variantEditor: VariantEditorSlice;
+  sharedVariantEditor: SharedVariantEditorSlice;
 };
 
 export type SliceCreator<T> = StateCreator<State, [["zustand/immer", never]], [], T>;
@@ -26,10 +29,10 @@ const useBaseStore = create<State, [["zustand/immer", never]]>(
       set((state) => {
         state.drawerOpen = false;
       }),
-    variantEditor: createVariantEditorSlice(set, get, ...rest),
+    sharedVariantEditor: createVariantEditorSlice(set, get, ...rest),
   })),
 );
 
 export const useAppStore = createSelectors(useBaseStore);
 
-useAppStore.getState().variantEditor.loadMonaco().catch(console.error);
+useAppStore.getState().sharedVariantEditor.loadMonaco().catch(console.error);

src/state/sync.ts

@@ -11,7 +11,7 @@ export function useSyncVariantEditor() {
   );
   useEffect(() => {
     if (scenarios.data) {
-      useAppStore.getState().variantEditor.setScenarios(scenarios.data);
+      useAppStore.getState().sharedVariantEditor.setScenarios(scenarios.data);
     }
   }, [scenarios.data]);
 }