2.home-manager/modules/misc/xdg/default.nix

{
  config,
  lib,
  pkgs,
  ...
}:

let
  inherit (lib)
    mkAfter
    mkOptionDefault
    mkIf
    mkOption
    types
    ;

  cfg = config.xdg;

  inherit
    (
      (import ../../lib/file-type.nix {
        inherit (config.home) homeDirectory;
        inherit lib pkgs;
      })
    )
    fileType
    ;

  defaultCacheHome = "${config.home.homeDirectory}/.cache";
  defaultConfigHome = "${config.home.homeDirectory}/.config";
  defaultDataHome = "${config.home.homeDirectory}/.local/share";
  defaultStateHome = "${config.home.homeDirectory}/.local/state";
  defaultBinHome = "${config.home.homeDirectory}/.local/bin";

  getEnvFallback =
    name: fallback:
    let
      value = builtins.getEnv name;
    in
    if value != "" then value else fallback;

in
{
  imports = [
    ./autostart.nix
    ./desktop-entries.nix
    ./mime.nix
    ./mime-apps.nix
    ./portal.nix
    ./system-dirs.nix
    ./terminal-exec.nix
    ./user-dirs.nix
  ];

  options.xdg = {
    enable = lib.mkEnableOption "management of XDG base directories";

    cacheFile = mkOption {
      type = fileType "xdg.cacheFile" "{var}`xdg.cacheHome`" cfg.cacheHome;
      default = { };
      description = ''
        Attribute set of files to link into the user's XDG
        cache home.
      '';
    };

    cacheHome = mkOption {
      type = types.path;
      defaultText = "~/.cache";
      apply = toString;
      description = ''
        Absolute path to directory holding application caches.

        Sets `XDG_CACHE_HOME` for the user if `xdg.enable` is set `true`.
      '';
    };

    configFile = mkOption {
      type = fileType "xdg.configFile" "{var}`xdg.configHome`" cfg.configHome;
      default = { };
      description = ''
        Attribute set of files to link into the user's XDG
        configuration home.
      '';
    };

    configHome = mkOption {
      type = types.path;
      defaultText = "~/.config";
      apply = toString;
      description = ''
        Absolute path to directory holding application configurations.

        Sets `XDG_CONFIG_HOME` for the user if `xdg.enable` is set `true`.
      '';
    };

    dataFile = mkOption {
      type = fileType "xdg.dataFile" "<varname>xdg.dataHome</varname>" cfg.dataHome;
      default = { };
      description = ''
        Attribute set of files to link into the user's XDG
        data home.
      '';
    };

    dataHome = mkOption {
      type = types.path;
      defaultText = "~/.local/share";
      apply = toString;
      description = ''
        Absolute path to directory holding application data.

        Sets `XDG_DATA_HOME` for the user if `xdg.enable` is set `true`.
      '';
    };

    binHome = mkOption {
      type = types.path;
      defaultText = "~/.local/bin";
      apply = toString;
      description = ''
        Absolute path to directory holding user-specific executables.

        Sets `XDG_BIN_HOME` for the user if `xdg.enable` is set `true`.
      '';
    };

    stateFile = mkOption {
      type = fileType "xdg.stateFile" "<varname>xdg.stateHome</varname>" cfg.stateHome;
      default = { };
      description = ''
        Attribute set of files to link into the user's XDG
        state home.
      '';
    };

    stateHome = mkOption {
      type = types.path;
      defaultText = "~/.local/state";
      apply = toString;
      description = ''
        Absolute path to directory holding application states.

        Sets `XDG_STATE_HOME` for the user if `xdg.enable` is set `true`.
      '';
    };

    localBinInPath = mkOption {
      type = types.bool;
      default = false;
      description = ''
        Whether to add {option}`xdg.binHome` to {env}`PATH` when
        {option}`xdg.enable` is enabled.
      '';
    };
  };

  config = lib.mkMerge [
    (
      let
        variables = {
          XDG_BIN_HOME = cfg.binHome;
          XDG_CACHE_HOME = cfg.cacheHome;
          XDG_CONFIG_HOME = cfg.configHome;
          XDG_DATA_HOME = cfg.dataHome;
          XDG_STATE_HOME = cfg.stateHome;
        };
      in
      mkIf cfg.enable {
        xdg.cacheHome = mkOptionDefault defaultCacheHome;
        xdg.configHome = mkOptionDefault defaultConfigHome;
        xdg.dataHome = mkOptionDefault defaultDataHome;
        xdg.binHome = mkOptionDefault defaultBinHome;
        xdg.stateHome = mkOptionDefault defaultStateHome;

        home.sessionVariables = variables;
        systemd.user.sessionVariables = variables;

        home.sessionPath = mkIf cfg.localBinInPath (mkAfter [ cfg.binHome ]);
      }
    )

    # Legacy non-deterministic setup.
    (mkIf (!cfg.enable && lib.versionOlder config.home.stateVersion "20.09") {
      xdg.cacheHome = mkOptionDefault (getEnvFallback "XDG_CACHE_HOME" defaultCacheHome);
      xdg.configHome = mkOptionDefault (getEnvFallback "XDG_CONFIG_HOME" defaultConfigHome);
      xdg.dataHome = mkOptionDefault (getEnvFallback "XDG_DATA_HOME" defaultDataHome);
      xdg.binHome = mkOptionDefault (getEnvFallback "XDG_BIN_HOME" defaultBinHome);
      xdg.stateHome = mkOptionDefault (getEnvFallback "XDG_STATE_HOME" defaultStateHome);
    })

    # "Modern" deterministic setup.
    (mkIf (!cfg.enable && lib.versionAtLeast config.home.stateVersion "20.09") {
      xdg.cacheHome = mkOptionDefault defaultCacheHome;
      xdg.configHome = mkOptionDefault defaultConfigHome;
      xdg.dataHome = mkOptionDefault defaultDataHome;
      xdg.binHome = mkOptionDefault defaultBinHome;
      xdg.stateHome = mkOptionDefault defaultStateHome;
    })

    {
      home.file = lib.mkMerge [
        (lib.mapAttrs' (name: file: lib.nameValuePair "${cfg.cacheHome}/${name}" file) cfg.cacheFile)
        (lib.mapAttrs' (name: file: lib.nameValuePair "${cfg.configHome}/${name}" file) cfg.configFile)
        (lib.mapAttrs' (name: file: lib.nameValuePair "${cfg.dataHome}/${name}" file) cfg.dataFile)
        (lib.mapAttrs' (name: file: lib.nameValuePair "${cfg.stateHome}/${name}" file) cfg.stateFile)
        { "${cfg.cacheHome}/.keep".text = ""; }
        { "${cfg.stateHome}/.keep".text = ""; }
      ];
    }
  ];
}