Rename Datastar attributes from _ds prefix to _data prefix

sln/src/Docs/docs/datastar.md

@@ -12,19 +12,6 @@ open type Html
 open type Datastar
 ```
 
-## Generic Attribute
-
-### data-*
-
-Use `_ds` for any Datastar `data-*` attribute:
-
-```fsharp
-div {
-    _ds ("star", "true")
-    _ds "loading"
-}
-```
-
 ## Core Attributes
 
 ### data-signals
@@ -33,8 +20,8 @@ Define reactive signals on an element:
 
 ```fsharp
 div {
-    _dsSignals ("count", "0")
-    _dsSignals ("name", "'World'")
+    _dataSignals ("count", "0")
+    _dataSignals ("name", "'World'")
 }
 ```
 
@@ -44,7 +31,7 @@ Listen for events and run expressions:
 
 ```fsharp
 button {
-    _dsOn ("click", "$count++")
+    _dataOn ("click", "$count++")
     "Increment"
 }
 ```
@@ -54,155 +41,152 @@ button {
 Two-way bind a signal to an input element:
 
 ```fsharp
-input { _type "text"; _dsBind "name" }
-input { _type "text"; _dsBind ("name", "value") }
+input { _type "text"; _dataBind "name" }
 ```
 
 ### data-show
 
 Conditionally show or hide an element:
 
 ```fsharp
-div { _dsShow "$count > 0"; "Count is positive" }
+div { _dataShow "$count > 0"; "Count is positive" }
 ```
 
 ### data-text
 
 Set the text content of an element reactively:
 
 ```fsharp
-span { _dsText "$count" }
+span { _dataText "$count" }
 ```
 
 ### data-effect
 
 Run an expression whenever its dependencies change:
 
 ```fsharp
-div { _dsEffect "console.log($count)" }
+div { _dataEffect "console.log($count)" }
 ```
 
 ### data-init
 
 Run an expression when the element is initialized:
 
 ```fsharp
-div { _dsInit "console.log('initialized')" }
+div { _dataInit "console.log('initialized')" }
 ```
 
 ### data-attr
 
 Dynamically set an HTML attribute:
 
 ```fsharp
-div { _dsAttr ("disabled", "$count === 0") }
+div { _dataAttr ("disabled", "$count === 0") }
 ```
 
 ### data-class
 
 Toggle a CSS class based on an expression:
 
 ```fsharp
-div { _dsClass ("active", "$isActive") }
+div { _dataClass ("active", "$isActive") }
 ```
 
 ### data-computed
 
 Define a computed signal derived from other signals:
 
 ```fsharp
-div { _dsComputed ("double", "$count * 2") }
+div { _dataComputed ("double", "$count * 2") }
 ```
 
 ### data-style
 
 Dynamically set a CSS style property:
 
 ```fsharp
-div { _dsStyle ("color", "$isError ? 'red' : 'green'") }
+div { _dataStyle ("color", "$isError ? 'red' : 'green'") }
 ```
 
 ### data-ref
 
 Reference an element by name:
 
 ```fsharp
-input { _dsRef "myInput" }
-input { _dsRef ("myInput", "value") }
+input { _dataRef "myInput" }
 ```
 
 ### data-indicator
 
 Bind a loading indicator signal:
 
 ```fsharp
-button { _dsIndicator "loading" }
-button { _dsIndicator ("loading", "true") }
+button { _dataIndicator "loading" }
 ```
 
 ### data-json-signals
 
-Merge JSON signals into the signal store:
+Render signals as JSON for debugging:
 
 ```fsharp
-div { _dsJsonSignals """{"count": 0}""" }
-div { _dsJsonSignals () }
+pre { _dataJsonSignals () }
+pre { _dataJsonSignals "{include: /counter/, exclude: /temp$/}" }
 ```
 
 ### data-ignore
 
 Prevent Datastar from processing an element:
 
 ```fsharp
-div { _dsIgnore }
+div { _dataIgnore }
 ```
 
 ### data-ignore-morph
 
 Prevent morphing of an element during updates:
 
 ```fsharp
-div { _dsIgnoreMorph }
+div { _dataIgnoreMorph }
 ```
 
 ### data-on-intersect
 
 Run an expression when an element enters the viewport:
 
 ```fsharp
-div { _dsOnIntersect "$count++" }
+div { _dataOnIntersect "$count++" }
 ```
 
 ### data-on-interval
 
 Run an expression on a timed interval:
 
 ```fsharp
-div { _dsOnInterval "$count++" }
+div { _dataOnInterval "$count++" }
 ```
 
 ### data-on-signal-patch
 
 Run an expression when signals are patched:
 
 ```fsharp
-div { _dsOnSignalPatch "console.log('patched')" }
+div { _dataOnSignalPatch "console.log('patched')" }
 ```
 
 ### data-on-signal-patch-filter
 
 Filter which signal patches trigger the expression:
 
 ```fsharp
-div { _dsOnSignalPatchFilter "count" }
+div { _dataOnSignalPatchFilter "{include: /^count$/}" }
 ```
 
 ### data-preserve-attr
 
 Preserve specified attributes during morphing:
 
 ```fsharp
-div { _dsPreserveAttr "class" }
+div { _dataPreserveAttr "class" }
 ```
 
 ## Pro Attributes
@@ -212,81 +196,82 @@ div { _dsPreserveAttr "class" }
 Apply animations to an element:
 
 ```fsharp
-div { _dsAnimate "fadeIn 0.5s" }
+div { _dataAnimate "fadeIn 0.5s" }
 ```
 
 ### data-custom-validity
 
 Set custom validation messages:
 
 ```fsharp
-input { _dsCustomValidity "$name === '' ? 'Name is required' : ''" }
+input { _dataCustomValidity "$name === '' ? 'Name is required' : ''" }
 ```
 
 ### data-on-raf
 
 Run an expression on every animation frame:
 
 ```fsharp
-canvas { _dsOnRaf "draw()" }
+canvas { _dataOnRaf "draw()" }
 ```
 
 ### data-on-resize
 
 Run an expression when the element is resized:
 
 ```fsharp
-div { _dsOnResize "console.log('resized')" }
+div { _dataOnResize "console.log('resized')" }
 ```
 
 ### data-persist
 
-Persist signals to local storage:
+Persist signals to local storage (or session storage with modifiers):
 
 ```fsharp
-div { _dsPersist "count" }
-div { _dsPersist ("count", "session") }
+div { _dataPersist () }                                  // default key: datastar
+div { _dataPersist "mykey" }                           // custom storage key
+div { _dataPersist ("mykey", "{include: /foo/}") }    // key + filter object
 ```
 
 ### data-query-string
 
 Sync signals with URL query parameters:
 
 ```fsharp
-div { _dsQueryString "count" }
-div { _dsQueryString () }
+div { _dataQueryString () }
+div { _dataQueryString "{include: /foo/, exclude: /temp$/}" }
 ```
 
 ### data-replace-url
 
 Replace the current URL:
 
 ```fsharp
-div { _dsReplaceUrl "/new-path" }
+div { _dataReplaceUrl "/new-path" }
 ```
 
 ### data-rocket
 
-Prefetch pages for instant navigation:
+Create a Rocket web component:
 
 ```fsharp
-a { _dsRocket "true"; _href "/next-page"; "Next" }
+div { _dataRocket "{ endpoint: '/stream' }" }
 ```
 
 ### data-scroll-into-view
 
 Scroll the element into view:
 
 ```fsharp
-div { _dsScrollIntoView }
+div { _dataScrollIntoView }
 ```
 
 ### data-view-transition
 
 Apply view transitions:
 
 ```fsharp
-div { _dsViewTransition "fade" }
+div { _dataViewTransition "fade" }
 ```
 
 ## Complete Example
@@ -295,19 +280,19 @@ Here's a complete example combining multiple Datastar attributes:
 
 ```fsharp
 div {
-    _dsSignals ("count", "0")
-    _dsSignals ("name", "'World'")
-    _dsComputed ("greeting", "'Hello, ' + $name + '!'")
+    _dataSignals ("count", "0")
+    _dataSignals ("name", "'World'")
+    _dataComputed ("greeting", "'Hello, ' + $name + '!'")
 
-    input { _type "text"; _dsBind "name" }
-    span { _dsText "$greeting" }
+    input { _type "text"; _dataBind "name" }
+    span { _dataText "$greeting" }
 
     button {
-        _dsOn ("click", "$count++")
-        _dsClass ("active", "$count > 0")
+        _dataOn ("click", "$count++")
+        _dataClass ("active", "$count > 0")
         "Clicked "
     }
-    span { _dsText "$count" }
-    span { _dsShow "$count > 0"; " times" }
+    span { _dataText "$count" }
+    span { _dataShow "$count > 0"; " times" }
 }
 ```