def nlargest(
        self,
        n: int,
        dim: Dims = None,
        *,
        skipna: bool | None = None,
        keep_attrs: bool | None = None,
        **kwargs: Any,
    ) -> Self:

def arg_nsmallest(da: xr.DataArray, dim: str, n: int):
    """
    Return the index or indices of the ``n`` smallest values along dimension ``dim``.

    Parameters
    ----------
    da: xr.DataArray
    dim: str
        Dimension over which to find the ``n`` smallest values.
    n: int
        The number of items to retrieve.
    
    Returns
    -------
    result: xr.DataArray
    """
    # Find the axis over which to apply the partition.
    axis = da.dims.index(dim)

    # Set up output coordinates.
    dim_index = np.arange(n)
    coords = da.coords.copy()
    coords[dim] = dim_index
    shape = list(da.shape)
    shape[axis] = n
    template = xr.DataArray(
        data=dask.array.zeros(shape, dtype=int),
        coords=coords,
        dims=da.dims,
    )
    def _nsmallest(da: xr.DataArray):
        # NOTE: numpy (arg)partition moves NaNs to the back;
        # bottleneck partition does not!
        smallest = np.argpartition(da.to_numpy(), kth=n, axis=axis)
        return template.copy(data=np.take(smallest, indices=np.arange(n), axis=axis))
 
    return xr.map_blocks(_nsmallest, da, template=template)