Automatically add appropriate case mods for data-computed and data-on

Author: gazpachoking

sdk/python/src/datastar_py/attributes.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 import json
+import re
 from collections.abc import Mapping
-from typing import Any, Literal, Iterable, TYPE_CHECKING, overload, TypeVar
+from typing import Literal, Iterable, TYPE_CHECKING, overload, TypeVar
 
 if TYPE_CHECKING:
     from typing import Self
@@ -227,6 +228,21 @@ def case(self: TAttr, case: Literal["camel", "kebab", "snake", "pascal"]) -> TAt
         self._mods["case"] = [case]
         return self
 
+    def _to_kebab_suffix(self: TAttr, signal_name: str):
+        if "-" in signal_name:
+             kebab_name, from_case = signal_name.lower(), "kebab"
+        elif "_" in signal_name:
+            kebab_name, from_case = signal_name.lower().replace("_", "-"), "snake"
+        elif signal_name[0].isupper():
+            kebab_name, from_case = re.sub(r"([A-Z])", r"-\1", signal_name).lstrip("-").lower(), "pascal"
+        elif signal_name.lower() != signal_name:
+            kebab_name, from_case = re.sub(r"([A-Z])", r"-\1", signal_name).lower(), "camel"
+        else:
+            kebab_name, from_case = signal_name, None
+        self._suffix = kebab_name
+        if from_case:
+            self._mods["case"] = [from_case]
+
 
 class TimingMod:
     def debounce(
@@ -280,7 +296,7 @@ def ifmissing(self) -> Self:
 class ComputedAttr(BaseAttr, CaseMod):
     def __init__(self, signal_name: str, expression: str):
         super().__init__("computed")
-        self._suffix = signal_name
+        self._to_kebab_suffix(signal_name)
         self._value = expression
 
 
@@ -331,7 +347,7 @@ def __init__(self, class_object: dict | str):
 class OnAttr(BaseAttr, TimingMod, ViewtransitionMod, CaseMod):
     def __init__(self, event: str, expression: str):
         super().__init__("on")
-        self._suffix = event
+        self._to_kebab_suffix(event)
         self._value = expression
 
     @property
@@ -487,3 +503,28 @@ def __init__(self, expression: str):
 
 
 data = Attributes()
+
+print(data.persist)
+print(data.persist('mysignal').session)
+print(data.bind('mysignal'))
+print(data.signals({'foo': 'bar'}))
+# If you need expressions you have to fall back to a string
+print(data.signals('{foo: Date.now()}'))
+print(data.computed('foo', '$bar * $baz'))
+print(data.on("load", "console.log('loaded')").delay(100))
+print(data.on("click", "console.log('clicked')").window.debounce(100))
+# timings are ms if numbers, but you can use strings
+print(data.on("raf", "console.log('raf')").debounce("1s"))
+# attr and class_ don't use json, so that the values become expressions rather than strings
+print(data.attr({'checked': '$mysignal'}))
+print(data.class_({'coolclass': '$mysignal'}))
+# on and computed are the only ones that allow that need the 'case' modifier
+print(data.computed('FooBar', '$bar * $baz'))
+print(data.computed('fooBar', '$bar * $baz'))
+print(data.computed('foo-bar', '$bar * $baz'))
+print(data.computed('foo_bar', '$bar * $baz'))
+print(data.computed('foobar', '$bar * $baz'))
+# Dunno if it's a good idea, but since some things are properties, and some are methods
+# it always allows calling so you don't have to remember the difference
+print(data.persist.session)
+print(data.persist().session())