feat: progress on initializing window from config

packages/client-api/src/desktop/current-window.ts

@@ -66,7 +66,10 @@ export async function setWindowStyles(styles: Partial<WindowStyles>) {
   ]);
 }
 
-async function setWindowZOrder(window: Window, zOrder?: WindowZOrder) {
+export async function setWindowZOrder(
+  window: Window,
+  zOrder?: WindowZOrder,
+) {
   if (zOrder === 'always_on_bottom') {
     await window.setAlwaysOnBottom(true);
   } else if (zOrder === 'always_on_top') {

packages/client-api/src/desktop/desktop-commands.ts

@@ -4,34 +4,24 @@ import {
 } from '@tauri-apps/api/core';
 
 import { createLogger } from '../utils';
-import type { ProviderConfig } from '~/user-config';
-import type { OpenWindowArgs } from './shared';
+import type { WindowState } from './shared';
+import type { ProviderConfig } from '~/providers';
 
 const logger = createLogger('desktop-commands');
 
 /**
- * Reads config file from disk. Creates file if it doesn't exist.
+ * Get state associated with the given {@link windowId}.
  */
-export function readConfigFile(): Promise<string> {
-  return invoke<string>('read_config_file');
-}
-
-/**
- * Get args used to open the window with the {@link windowLabel}.
- */
-export function getInitialState(
-  windowLabel: string,
-): Promise<OpenWindowArgs | null> {
-  return invoke<OpenWindowArgs | null>('get_open_window_args', {
-    windowLabel,
+export function getWindowState(
+  windowId: string,
+): Promise<WindowState | null> {
+  return invoke<WindowState | null>('get_window_state', {
+    windowId,
   });
 }
 
-export function openWindow(
-  windowId: string,
-  args: Record<string, string> = {},
-): Promise<void> {
-  return invoke<void>('open_window', { windowId, args });
+export function openWindow(configPath: string): Promise<void> {
+  return invoke<void>('open_window', { configPath });
 }
 
 // TODO: Add support for only fetching selected variables.

packages/client-api/src/desktop/get-open-window-args.ts

@@ -1,6 +1,6 @@
 import { getCurrentWindow } from '@tauri-apps/api/window';
 
-import { getInitialState } from './desktop-commands';
+import { getWindowState } from './desktop-commands';
 
 let promise: Promise<any> | null = null;
 
@@ -13,5 +13,5 @@ async function fetchOpenWindowArgs() {
     return window.__ZEBAR_INITIAL_STATE;
   }
 
-  return getInitialState(getCurrentWindow().label);
+  return getWindowState(getCurrentWindow().label);
 }

packages/client-api/src/desktop/shared/index.ts

@@ -1,2 +1,2 @@
 export * from './monitor-info.model';
-export * from './open-window-args.model';
+export * from './window-state.model';

packages/client-api/src/desktop/shared/window-state.model.ts

@@ -0,0 +1,9 @@
+import type { WindowConfig } from '~/user-config';
+
+export interface WindowState {
+  windowId: string;
+
+  config: WindowConfig;
+
+  configPath: string;
+}

packages/client-api/src/init.ts

@@ -1,7 +1,13 @@
 import { getCurrentWindow } from '@tauri-apps/api/window';
+import { join } from '@tauri-apps/api/path';
 import { createRoot, getOwner, runWithOwner } from 'solid-js';
 
-import { getInitialState, openWindow, showErrorDialog } from './desktop';
+import {
+  getWindowState,
+  openWindow,
+  setWindowZOrder,
+  showErrorDialog,
+} from './desktop';
 import { createLogger } from '~/utils';
 import type { ZebarContext } from './zebar-context.model';
 import { createProvider } from './providers';
@@ -32,9 +38,9 @@ export async function init(
     try {
       const currentWindow = getCurrentWindow();
 
-      const initialState =
+      const windowState =
         window.__ZEBAR_INITIAL_STATE ??
-        (await getInitialState(currentWindow.label));
+        (await getWindowState(currentWindow.label));
 
       // Load default CSS unless explicitly disabled.
       if (options?.includeDefaultCss !== false) {
@@ -45,13 +51,25 @@ export async function init(
 
       // @ts-ignore - TODO
       return {
-        // @ts-ignore - TODO
-        config: initialState.config,
-        openWindow,
+        openWindow: async (configPath: string) => {
+          const absolutePath = await join(
+            windowState.windowId,
+            '../',
+            configPath,
+          );
+
+          return openWindow(absolutePath);
+        },
         createProvider: config => {
           return createProvider(config, getOwner()!);
         },
-        currentWindow: {},
+        currentWindow: {
+          ...windowState,
+          tauri: currentWindow,
+          setZOrder: zOrder => {
+            return setWindowZOrder(currentWindow, zOrder);
+          },
+        },
         allWindows: [],
         currentMonitor: {},
         allMonitors: [],

packages/client-api/src/shims.d.ts

@@ -1,6 +1,6 @@
 interface Window {
   __TAURI__: any;
-  __ZEBAR_INITIAL_STATE: import('./desktop').OpenWindowArgs;
+  __ZEBAR_INITIAL_STATE: import('./desktop').WindowState;
 }
 
 declare module '*.css' {

packages/client-api/src/zebar-context.model.ts

@@ -37,8 +37,11 @@ export interface ZebarContext {
 }
 
 export interface ZebarWindow {
+  windowId: string;
+  config: WindowConfig;
+  configPath: string;
   tauri: TauriWindow;
-  setZOrder: (zOrder: WindowZOrder) => Promise<void>;
+  setZOrder(zOrder: WindowZOrder): Promise<void>;
 }
 
 export interface Monitor {

packages/desktop/src/cli.rs

@@ -32,12 +32,6 @@ pub enum CliCommand {
 pub struct OpenWindowArgs {
   /// Relative file path within the Zebar config directory.
   pub config_path: String,
-
-  /// Arguments to pass to the window.
-  ///
-  /// These become available via the `self` provider.
-  #[clap(short, long, num_args = 1.., value_parser=parse_open_args)]
-  pub args: Option<Vec<(String, String)>>,
 }
 
 #[derive(Args, Debug)]
@@ -63,15 +57,3 @@ pub fn print_and_exit(output: anyhow::Result<String>) {
     }
   }
 }
-
-/// Parses arguments passed to the `open` CLI command into a string tuple.
-fn parse_open_args(
-  input: &str,
-) -> anyhow::Result<(String, String), String> {
-  let mut parts = input.split('=');
-
-  match (parts.next(), parts.next()) {
-    (Some(key), Some(value)) => Ok((key.into(), value.into())),
-    _ => Err("Arguments must be of format KEY1=VAL1".into()),
-  }
-}

packages/desktop/src/config.rs

@@ -230,6 +230,23 @@ impl Config {
     Ok(())
   }
 
+  /// Returns the window config at the given absolute path.
+  pub fn window_config_by_path(
+    &self,
+    config_path: &str,
+  ) -> anyhow::Result<Option<WindowConfig>> {
+    let config_pathbuf = PathBuf::from(config_path).canonicalize()?;
+
+    let config_entry = self
+      .window_configs
+      .iter()
+      .find(|entry| entry.path == config_pathbuf);
+
+    let config = config_entry.map(|entry| entry.config.clone());
+
+    Ok(config)
+  }
+
   /// Opens the config directory in the OS-dependent file explorer.
   pub fn open_config_dir(&self) -> anyhow::Result<()> {
     #[cfg(target_os = "windows")]

packages/desktop/src/main.rs

@@ -1,6 +1,7 @@
 #![feature(async_closure)]
-use std::{collections::HashMap, env};
+use std::env;
 
+use anyhow::Context;
 use clap::Parser;
 use config::Config;
 use tauri::{Manager, State, Window};
@@ -25,23 +26,25 @@ mod sys_tray;
 mod window_factory;
 
 #[tauri::command]
-async fn get_open_window_args(
-  window_label: String,
+async fn get_window_state(
+  window_id: String,
   window_factory: State<'_, WindowFactory>,
-  config: State<'_, Config>,
 ) -> anyhow::Result<Option<WindowState>, String> {
-  println!("{:?}", config.config_dir);
-  Ok(window_factory.state_by_window_label(window_label).await)
+  Ok(window_factory.state_by_id(&window_id).await)
 }
 
 #[tauri::command]
-fn open_window(
+async fn open_window(
   config_path: String,
-  args: HashMap<String, String>,
+  config: State<'_, Config>,
   window_factory: State<'_, WindowFactory>,
 ) -> anyhow::Result<(), String> {
-  // TODO: Pass in `WindowConfig`.
-  window_factory.try_open();
+  let window_config = config
+    .window_config_by_path(&config_path)
+    .map_err(|err| err.to_string())?
+    .context("Window config not found.")?;
+
+  window_factory.open_one(window_config);
 
   Ok(())
 }
@@ -149,7 +152,7 @@ fn start_app(cli: Cli) {
 
           // CLI command is guaranteed to be an open command here.
           if let CliCommand::Open(args) = cli.command {
-            app.state::<WindowFactory>().try_open();
+            app.state::<WindowFactory>().open_one();
           }
         },
       ))?;
@@ -161,7 +164,7 @@ fn start_app(cli: Cli) {
       // Open window with the given args and initialize
       // `WindowFactory` in Tauri state.
       let window_factory = WindowFactory::new(app.handle());
-      window_factory.try_open();
+      window_factory.open_one();
       app.manage(window_factory);
 
       app.handle().plugin(tauri_plugin_shell::init())?;
@@ -179,7 +182,7 @@ fn start_app(cli: Cli) {
       Ok(())
     })
     .invoke_handler(tauri::generate_handler![
-      get_open_window_args,
+      get_window_state,
       open_window,
       listen_provider,
       unlisten_provider,

packages/desktop/src/window_factory.rs

@@ -11,7 +11,7 @@ use tauri::{AppHandle, WebviewUrl, WebviewWindowBuilder};
 use tokio::{sync::Mutex, task};
 use tracing::{error, info};
 
-use crate::common::WindowExt;
+use crate::{common::WindowExt, config::WindowConfig};
 
 /// Manages the creation of Zebar windows.
 pub struct WindowFactory {
@@ -30,10 +30,16 @@ pub struct WindowFactory {
 #[derive(Serialize, Clone, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct WindowState {
+  /// Unique identifier for the window.
+  ///
+  /// Used as the window label.
   pub window_id: String,
-  pub window_label: String,
-  pub args: HashMap<String, String>,
-  pub env: HashMap<String, String>,
+
+  /// User-defined config for the window.
+  pub config: WindowConfig,
+
+  /// Absolute path to the window's config file.
+  pub config_path: String,
 }
 
 impl WindowFactory {
@@ -45,23 +51,27 @@ impl WindowFactory {
     }
   }
 
-  /// TODO: Pass in `WindowConfig`.
-  pub fn try_open(&self) {
+  pub fn open_all(&self, configs: Vec<WindowConfig>) {
+    for config in configs {
+      self.open_one(config);
+    }
+  }
+
+  pub fn open_one(&self, config: WindowConfig) {
     let app_handle = self.app_handle.clone();
     let window_states = self.window_states.clone();
-    let app_handle = app_handle.clone();
     let window_count = self.window_count.clone();
 
     task::spawn(async move {
       // Increment number of windows.
       let new_count = window_count.fetch_add(1, Ordering::Relaxed) + 1;
 
-      let open_res = Self::open(&app_handle, new_count);
+      let open_res = Self::create_window(&app_handle, new_count, config);
 
       match open_res {
         Ok(state) => {
           let mut window_states = window_states.lock().await;
-          window_states.insert(state.window_label.clone(), state);
+          window_states.insert(state.window_id.clone(), state);
         }
         Err(err) => {
           error!("Failed to open window: {:?}", err);
@@ -70,9 +80,10 @@ impl WindowFactory {
     });
   }
 
-  fn open(
+  fn create_window(
     app_handle: &AppHandle,
     window_count: u32,
+    config: WindowConfig,
   ) -> anyhow::Result<WindowState> {
     info!("Creating window #{}", window_count);
 
@@ -95,9 +106,7 @@ impl WindowFactory {
 
     let state = WindowState {
       window_id: window_count.to_string(),
-      window_label: window_count.to_string(),
-      args: HashMap::new(),
-      env: std::env::vars().collect(),
+      config,
     };
 
     _ = window.eval(&format!(
@@ -113,11 +122,8 @@ impl WindowFactory {
     Ok(state)
   }
 
-  /// Gets an open window's state by a given window label.
-  pub async fn state_by_window_label(
-    &self,
-    window_label: String,
-  ) -> Option<WindowState> {
-    self.window_states.lock().await.get(&window_label).cloned()
+  /// Gets an open window's state by a given window ID.
+  pub async fn state_by_id(&self, window_id: &str) -> Option<WindowState> {
+    self.window_states.lock().await.get(window_id).cloned()
   }
 }