Update documentation to reflect repository name change and enhance usage examples for plotting functionality

Author: CSSFrancis

docs/api/figure.rst

@@ -1,7 +1,7 @@
 Figure
-========
+======
 
-.. automodule:: viewer.figure
+.. automodule:: anyplotlib.figure
    :members:
    :undoc-members: False
    :show-inheritance:

docs/getting_started.rst

@@ -6,40 +6,55 @@ Installation
 
 Clone the repository and install with ``uv`` (or pip)::
 
-    git clone https://github.com/your-org/viewer.git
-    cd viewer
+    git clone https://github.com/your-org/anyplotlib.git
+    cd anyplotlib
     uv sync          # installs the project + all dependencies
 
 Quick start
 -----------
 
-1-D viewer
-~~~~~~~~~~
+1-D plot
+~~~~~~~~
 
 .. code-block:: python
 
     import numpy as np
-    from viewer import Viewer1D
+    import anyplotlib as vw
 
     x = np.linspace(0, 4 * np.pi, 512)
     signal = np.sin(x)
 
-    v = Viewer1D(signal, x_axis=x, units="rad")
+    fig, ax = vw.subplots(1, 1, figsize=(620, 320))
+    v = ax.plot(signal, axes=[x], units="rad")
     v  # display in a Jupyter cell
 
-2-D viewer
-~~~~~~~~~~
+2-D image
+~~~~~~~~~
 
 .. code-block:: python
 
     import numpy as np
-    from viewer import Viewer2D
+    import anyplotlib as vw
 
     data = np.random.default_rng(0).standard_normal((256, 256))
-    v = Viewer2D(data, units="px")
+    fig, ax = vw.subplots(1, 1, figsize=(500, 500))
+    v = ax.imshow(data, units="px")
     v  # display in a Jupyter cell
 
-For more elaborate usage, see the :doc:`auto_examples/index` gallery or
-the :doc:`api/index`.
+Bar chart
+~~~~~~~~~
 
+.. code-block:: python
+
+    import numpy as np
+    import anyplotlib as vw
 
+    values = np.array([42, 55, 48, 63, 71, 68], dtype=float)
+    months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun"]
+
+    fig, ax = vw.subplots(1, 1, figsize=(560, 320))
+    bar = ax.bar(values, x_labels=months, color="#4fc3f7", show_values=True)
+    bar  # display in a Jupyter cell
+
+For more elaborate usage, see the :doc:`auto_examples/index` gallery or
+the :doc:`api/index`.

docs/index.rst

@@ -15,49 +15,47 @@ canvas renderer.  The goal is to duplicate and extend the interactive plotting c
 although the scope is intentionally limited in the following ways:
 
 1. This uses the object-oriented API of Matplotlib, not the stateful pyplot interface. This means there is
-no `plt.imshow` or `plt.plot` – instead, you create a viewer object and call methods on it to add data
-and customize the plot. This is a deliberate choice to avoid the pitfalls of the stateful API.
+   no ``plt.imshow`` or ``plt.plot`` — instead, you create a figure object and call methods on axes to add
+   data and customize the plot. This is a deliberate choice to avoid the pitfalls of the stateful API.
 
-python
-```
-import anyplotlib as apl
-import matplotlib.pyplot as plt
+   .. code-block:: python
 
-# matplotlib:
-fig, axs = plt.subplots(1,1)
-axs.imshow(...)
+      import anyplotlib as apl
+      import matplotlib.pyplot as plt
 
-# anyplotlib equivalent:
-fig, axs = apl.subplots(1,1)
-axs.imshow(...)
-```
+      # matplotlib:
+      fig, axs = plt.subplots(1, 1)
+      axs.imshow(...)
+
+      # anyplotlib equivalent:
+      fig, axs = apl.subplots(1, 1)
+      axs.imshow(...)
 
 2. In matplotlib they use vector graphics (SVG) to render the plot, which is great for static images.  It's especially
-great for making publication-quality figures.  (If you haven't try inkscape + matplotlib SVG output,
-it's pretty amazing.) For interactivity, it can be slow.  Anyplotlib uses a pure-JavaScript canvas renderer which is
-much faster for interactive applications, but the quality of the output is not as good as vector graphics.  This is a
-trade-off that we are willing to make for the sake of interactivity.
+   great for making publication-quality figures.  (If you haven't tried inkscape + matplotlib SVG output,
+   it's pretty amazing.) For interactivity, it can be slow.  Anyplotlib uses a pure-JavaScript canvas renderer which is
+   much faster for interactive applications, but the quality of the output is not as good as vector graphics.  This is a
+   trade-off that we are willing to make for the sake of interactivity.
 
 3. Matplotlib supports a wide range of marker styles, line styles, and other plot elements.  Anyplotlib focuses on a
-core set of features that are most commonly used in scientific plotting.  This means that some of the more
-esoteric features of Matplotlib may not be available in Anyplotlib. In general we try to match the lower level
-`collections` API of Matplotlib.
+   core set of features that are most commonly used in scientific plotting.  This means that some of the more
+   esoteric features of Matplotlib may not be available in Anyplotlib. In general we try to match the lower level
+   ``collections`` API of Matplotlib.
 
 4. Each collection, plot, image is rendered as a single object on the canvas.  This is highly performant and more
-importantly allows for blitting. This is one of the main reasons why the `ipympl` backend of Matplotlib is so slow.
+   importantly allows for blitting. This is one of the main reasons why the ``ipympl`` backend of Matplotlib is so slow.
 
-5. Finally `anyplotlib` uses `AnyWidget` as the underlying widget framework.  This means that it can be used in any
-environment that supports `AnyWidget`, including Jupyter notebooks, JupyterLab, and PyCharm notebook preview.  Under
-the hood, `AnyWidget` uses a pure-JavaScript implementation of the widget protocol, which allows for fast rendering
-and interactivity.
+5. Finally ``anyplotlib`` uses ``AnyWidget`` as the underlying widget framework.  This means that it can be used in any
+   environment that supports ``AnyWidget``, including Jupyter notebooks, JupyterLab, and PyCharm notebook preview.  Under
+   the hood, ``AnyWidget`` uses a pure-JavaScript implementation of the widget protocol, which allows for fast rendering
+   and interactivity.
 
 **Disclaimer**: This project is in the early stages of development.  Additionally many of the
-javascript code was optimized using LLM's. That being said, the javascript/python code is fairly minimal,
+JavaScript code was optimised using LLMs. That being said, the JavaScript/Python code is fairly minimal
 and not too difficult to understand.
 
-
-**Disclaimer #2**: Mostly this project is to see __if__ something like this is possible, it remains to be
-seen if this can be developed into a full-fledged plotting library.  The hope is that this can be.
+**Disclaimer #2**: Mostly this project is to see *if* something like this is possible; it remains to be
+seen if this can be developed into a full-fledged plotting library.  The hope is that it can.
 
 * :ref:`genindex`
 * :ref:`modindex`