Refactorings towards usage as library

Author: forman

dashi/package-lock.json

@@ -40,6 +40,7 @@
     "prettier": "^3.3.3",
     "typescript": "^5.6.2",
     "vite": "^5.4.6",
+    "vite-plugin-dts": "^4.2.4",
     "vitest": "^2.1.1"
   }
 }

dashi/package.json

@@ -11,7 +11,6 @@ export interface DashiButtonProps extends Omit<ButtonState, "type"> {
 function DashiButton({
   id,
   name,
-  value,
   style,
   text,
   disabled,
@@ -33,7 +32,6 @@ function DashiButton({
     <Button
       id={id}
       name={name}
-      value={value}
       style={style}
       disabled={disabled}
       onClick={handleClick}

dashi/src/components/DashiButton.tsx

@@ -1,9 +1,16 @@
 import { defineConfig } from "vitest/config";
 import react from "@vitejs/plugin-react-swc";
+import dts from "vite-plugin-dts";
 
 // https://vitejs.dev/config/
 export default defineConfig({
-  plugins: [react()],
+  plugins: [
+    react(),
+    dts({
+      include: ["src"],
+      exclude: ["src/app/**/*", "src/utils/**/*"],
+    }),
+  ],
   test: {
     environment: "jsdom",
     onConsoleLog: (/*_log: string, _type: "stdout" | "stderr"*/):

dashi/vite.config.ts

@@ -0,0 +1,5 @@
+from .callback import get_callback_results
+from .contributions import get_contributions
+from .extensioncontext import ExtensionContext
+from .layout import get_layout
+from .response import Response

dashipy/dashipy/contribs/__init__.py

@@ -0,0 +1,62 @@
+from typing import Any
+
+from .extensioncontext import ExtensionContext
+from .response import Response
+
+
+# POST /dashi/callback
+def get_callback_results(ext_ctx: ExtensionContext, data: dict[str, Any]):
+    """Generate the response for `POST /dashi/callback`.
+
+    Args:
+        ext_ctx: Extension context.
+        data: A dictionary deserialized from a request JSON body
+            that may contain a key `callbackRequests` of type `list`.
+    Returns:
+        A JSON-serializable list.
+    """
+    # TODO: validate data
+    callback_requests: list[dict] = data.get("callbackRequests") or []
+
+    context = ext_ctx.app_ctx
+
+    # TODO: assert correctness, set status code on error
+    state_change_requests: list[dict] = []
+    for callback_request in callback_requests:
+        contrib_point_name: str = callback_request["contribPoint"]
+        contrib_index: int = callback_request["contribIndex"]
+        callback_index: int = callback_request["callbackIndex"]
+        input_values: list = callback_request["inputValues"]
+
+        contributions = ext_ctx.contributions[contrib_point_name]
+        contribution = contributions[contrib_index]
+        callback = contribution.callbacks[callback_index]
+        output_values = callback.invoke(context, input_values)
+
+        if len(callback.outputs) == 1:
+            output_values = (output_values,)
+
+        state_changes: list[dict] = []
+        for output_index, output in enumerate(callback.outputs):
+            output_value = output_values[output_index]
+            state_changes.append(
+                {
+                    **output.to_dict(),
+                    "value": (
+                        output_value.to_dict()
+                        if hasattr(output_value, "to_dict")
+                        and callable(output_value.to_dict)
+                        else output_value
+                    ),
+                }
+            )
+
+        state_change_requests.append(
+            {
+                "contribPoint": contrib_point_name,
+                "contribIndex": contrib_index,
+                "stateChanges": state_changes,
+            }
+        )
+
+    return Response.success(state_change_requests)

dashipy/dashipy/controllers/__init__.py

@@ -0,0 +1,16 @@
+from .extensioncontext import ExtensionContext
+from .response import Response
+
+
+def get_contributions(ext_ctx: ExtensionContext) -> Response:
+    """Generate the response for `GET /dashi/contributions`."""
+    extensions = ext_ctx.extensions
+    contributions = ext_ctx.contributions
+    return Response.success(
+        {
+            "extensions": [e.to_dict() for e in extensions],
+            "contributions": {
+                cpk: [c.to_dict() for c in cpv] for cpk, cpv in contributions.items()
+            },
+        }
+    )

dashipy/dashipy/controllers/callback.py

@@ -0,0 +1,50 @@
+import importlib
+from typing import Any
+
+from dashipy.lib import Extension, Contribution
+
+
+class ExtensionContext:
+    def __init__(self, app_ctx: Any, extensions: list[Extension]):
+        self._app_ctx = app_ctx
+        self._extensions = extensions
+        contributions_map: dict[str, list[Contribution]] = {}
+        for contrib_point_name in Extension.get_contrib_point_names():
+            # noinspection PyTypeChecker
+            contributions: list[Contribution] = []
+            for extension in extensions:
+                contributions.extend(getattr(extension, contrib_point_name))
+            # noinspection PyTypeChecker
+            contributions_map[contrib_point_name] = contributions
+        self._contributions = contributions_map
+
+    @property
+    def app_ctx(self) -> Any:
+        return self._app_ctx
+
+    @property
+    def extensions(self) -> list[Extension]:
+        return self._extensions
+
+    @property
+    def contributions(self) -> dict[str, list[Contribution]]:
+        return self._contributions
+
+    @classmethod
+    def load_extensions(cls, extension_refs: list[str]) -> list[Extension]:
+        extensions: list[Extension] = []
+        for ext_ref in extension_refs:
+            try:
+                module_name, attr_name = ext_ref.rsplit(".", maxsplit=2)
+            except (ValueError, AttributeError):
+                raise TypeError(f"contribution syntax error: {ext_ref!r}")
+            module = importlib.import_module(module_name)
+            extension = getattr(module, attr_name)
+            if not isinstance(extension, Extension):
+                raise TypeError(
+                    f"extension {ext_ref!r} must refer to an"
+                    f" instance of {Extension.__qualname__!r},"
+                    f" but was {type(extension).__qualname__!r}"
+                )
+            extensions.append(extension)
+        return extensions

dashipy/dashipy/controllers/contributions.py

@@ -0,0 +1,48 @@
+from typing import Any
+
+from .extensioncontext import ExtensionContext
+from .response import Response
+
+
+def get_layout(
+    ext_ctx: ExtensionContext,
+    contrib_point_name: str,
+    contrib_index: int,
+    data: dict[str, Any],
+) -> Response:
+    """Generate the response for
+    `POST /dashi/layout/{contrib_point_name}/{contrib_index}`.
+
+    Args:
+        ext_ctx: Extension context.
+        contrib_point_name: Contribution point name.
+        contrib_index: Contribution index.
+        data: A dictionary deserialized from a request JSON body
+            that may contain a key `inputValues` of type `list`.
+    Returns:
+        A JSON-serializable dictionary.
+    """
+    # TODO: validate data
+    input_values = data.get("inputValues") or []
+
+    try:
+        contributions = ext_ctx.contributions[contrib_point_name]
+    except KeyError:
+        return Response.failed(
+            404, f"contribution point {contrib_point_name!r} not found"
+        )
+
+    contrib_ref = f"{contrib_point_name}[{contrib_index}]"
+
+    try:
+        contribution = contributions[contrib_index]
+    except IndexError:
+        return Response.failed(404, f"contribution {contrib_ref!r} not found")
+
+    callback = contribution.layout_callback
+    if callback is None:
+        return Response.failed(400, f"contribution {contrib_ref!r} has no layout")
+
+    component = callback.invoke(ext_ctx.app_ctx, input_values)
+
+    return Response.success(component.to_dict())