issue_comments: 1134554277

I can confirm that after implementing these changes in my local xarray package, everything works es expected.

I added a check on each dimension/coordinate to make sure it is of datetime dtype before making any changes.

Starting on line https://github.com/pydata/xarray/blob/4da7fdbd85bb82e338ad65a532dd7a9707e18ce0/xarray/plot/plot.py#L1316 I now have:

```python @_plot2d def imshow(x, y, z, ax, **kwargs): """ Image plot of 2D DataArray.

Wraps :py:func:`matplotlib:matplotlib.pyplot.imshow`.

While other plot methods require the DataArray to be strictly
two-dimensional, ``imshow`` also accepts a 3D array where some
dimension can be interpreted as RGB or RGBA color channels and
allows this dimension to be specified via the kwarg ``rgb=``.

Unlike :py:func:`matplotlib:matplotlib.pyplot.imshow`, which ignores ``vmin``/``vmax``
for RGB(A) data,
xarray *will* use ``vmin`` and ``vmax`` for RGB(A) data
by applying a single scaling factor and offset to all bands.
Passing  ``robust=True`` infers ``vmin`` and ``vmax``
:ref:`in the usual way <robust-plotting>`.

.. note::
    This function needs uniformly spaced coordinates to
    properly label the axes. Call :py:meth:`DataArray.plot` to check.

The pixels are centered on the coordinates. For example, if the coordinate
value is 3.2, then the pixels for those coordinates will be centered on 3.2.
"""

if x.ndim != 1 or y.ndim != 1:
    raise ValueError(
        "imshow requires 1D coordinates, try using pcolormesh or contour(f)"
    )

def _center_pixels(x):
    """Center the pixels on the coordinates."""
    if np.issubdtype(x.dtype, str):
        # When using strings as inputs imshow converts it to
        # integers. Choose extent values which puts the indices in
        # in the center of the pixels:
        return 0 - 0.5, len(x) - 0.5

    # vvvvvv added vvvvvv
    elif np.issubdtype(x.dtype, np.datetime64):
        from matplotlib.dates import date2num
        x = date2num(x)
    # ^^^^^^ added ^^^^^^

    try:
        # Center the pixels assuming uniform spacing:
        xstep = 0.5 * (x[1] - x[0])
    except IndexError:
        # Arbitrary default value, similar to matplotlib behaviour:
        xstep = 0.1

    return x[0] - xstep, x[-1] + xstep

# Center the pixels:
left, right = _center_pixels(x)
top, bottom = _center_pixels(y)

defaults = {"origin": "upper", "interpolation": "nearest"}

if not hasattr(ax, "projection"):
    # not for cartopy geoaxes
    defaults["aspect"] = "auto"

# Allow user to override these defaults
defaults.update(kwargs)

if defaults["origin"] == "upper":
    defaults["extent"] = [left, right, bottom, top]
else:
    defaults["extent"] = [left, right, top, bottom]

if z.ndim == 3:
    # matplotlib imshow uses black for missing data, but Xarray makes
    # missing data transparent.  We therefore add an alpha channel if
    # there isn't one, and set it to transparent where data is masked.
    if z.shape[-1] == 3:
        alpha = np.ma.ones(z.shape[:2] + (1,), dtype=z.dtype)
        if np.issubdtype(z.dtype, np.integer):
            alpha *= 255
        z = np.ma.concatenate((z, alpha), axis=2)
    else:
        z = z.copy()
    z[np.any(z.mask, axis=-1), -1] = 0

primitive = ax.imshow(z, **defaults)

# If x or y are strings the ticklabels have been replaced with
# integer indices. Replace them back to strings:
for axis, v in [("x", x), ("y", y)]:
    if np.issubdtype(v.dtype, str):
        getattr(ax, f"set_{axis}ticks")(np.arange(len(v)))
        getattr(ax, f"set_{axis}ticklabels")(v)

    # vvvvvv added vvvvvv
    elif np.issubdtype(v.dtype, np.datetime64):
        getattr(ax, f"{axis}axis_date")()
    # ^^^^^^ added ^^^^^^


return primitive

```