@ea-lab/reactive-json-docs 1.0.0-alpha.0 → 1.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ea-lab/reactive-json-docs",
-  "version": "1.0.0-alpha.0",
+  "version": "1.0.0",
   "description": "Complete documentation for Reactive-JSON - Components, examples and LLM-parsable guides",
   "main": "public/rjbuild/docs/index.yaml",
   "files": [
@@ -26,7 +26,7 @@
   "private": false,
   "devDependencies": {
     "@craco/craco": "^7.1.0",
-    "@ea-lab/reactive-json": "^1.0.0-alpha.6",
+    "@ea-lab/reactive-json": "^1.0.1",
     "@ea-lab/reactive-json-chartjs": "^1.0.0",
     "@npmcli/fs": "^4.0.0",
     "@reduxjs/toolkit": "^2.6.1",

package/public/rjbuild/docs/advanced-concepts/attribute-transformers.md

@@ -0,0 +1,168 @@
+# Attribute Transformers
+
+> **Note**: Reactive-JSON provides two systems for attribute modification:
+> 
+> - **Attribute Transformers** (this section): Execute **before rendering**, modify attributes for child components
+> - **[Attribute Actions](../core/action/Attribute/index.md)**: Execute **after rendering**, modify DOM attributes directly
+> 
+> Choose transformers for pre-render attribute conditioning and actions for post-render DOM manipulation.
+
+Attribute Transformers in Reactive-JSON allow you to modify element attributes before rendering based on dynamic conditions. They are evaluated during the attribute evaluation phase and provide pre-render attribute manipulation capabilities.
+
+## Key Differences from Actions
+
+- **Timing**: Attribute transformers execute **before rendering**, while actions execute **after rendering**
+- **Impact**: Transformers affect attributes passed to child components, actions modify the DOM directly
+- **Use case**: Transformers are ideal for conditional attribute values that need to be available to child components
+
+## Available Transformers
+
+For a complete list of built-in attribute transformers, see **[Attribute Transformers Reference](../core/attributeTransformer/index.md)**.
+
+## Extensibility
+
+The Attribute Transformer system is fully extensible through the plugin system. You can create custom transformers to handle specific attribute manipulation needs in your application.
+
+### Creating Custom Attribute Transformers
+
+Attribute transformers are JavaScript functions that receive attributes and transformation properties, then return the modified attributes:
+
+```javascript
+// customTransformer.js
+export const myCustomTransformer = ({ attributes, globalDataContext, singleTransformProps, templateContext }) => {
+    const { name, customProperty } = singleTransformProps;
+    
+    // Your custom logic here
+    // Modify the attributes object
+    
+    return attributes;
+};
+```
+
+### Plugin Registration
+
+Include your custom transformers in a plugin and register them with ReactiveJsonRoot:
+
+```javascript
+// myPlugin.js
+import { myCustomTransformer } from "./transformers/customTransformer.js";
+
+export const myPlugin = {
+    attributeTransformer: {
+        myCustomTransformer,
+    }
+};
+```
+
+```javascript
+// App.js
+import { ReactiveJsonRoot, mergeComponentCollections } from "@ea-lab/reactive-json";
+import { myPlugin } from "./plugins/myPlugin.js";
+
+const App = () => {
+    return (
+        <ReactiveJsonRoot
+            plugins={mergeComponentCollections([myPlugin])}
+        />
+    );
+};
+```
+
+### Usage in RjBuild
+
+Once registered, your custom transformer can be used in any element:
+
+```yaml
+renderView:
+  - type: div
+    attributes:
+      class: "base-class"
+    attributeTransforms:
+      - what: myCustomTransformer
+        name: "data-custom"
+        customProperty: "value"
+        when: ~~.someCondition
+        is: true
+```
+
+For detailed component development guidance, see **[Plugin Development](./plugins/index.md)**.
+
+## Basic Usage
+
+Attribute transformers are defined in the `attributeTransforms` array on any element:
+
+```yaml
+renderView:
+  - type: div
+    attributes:
+      class: "base-class"
+      data-status: "default"
+    attributeTransforms:
+      # Add class conditionally
+      - what: setAttributeValue
+        name: "class"
+        value: "active"
+        when: ~~.isActive
+        is: true
+      
+      # Remove attribute entirely
+      - what: unsetAttribute
+        name: "data-status"
+        when: ~~.hideStatus
+        is: true
+      
+      # Toggle between states
+      - what: toggleAttributeValue
+        name: "class"
+        value: ["theme-light", "theme-dark"]
+        when: ~~.toggleTheme
+        isNotEmpty:
+```
+
+## Execution Order
+
+Attribute transformers are applied in the order they appear in the `attributeTransforms` array:
+
+1. Base attributes are evaluated (template resolution)
+2. Each transformer is applied sequentially
+3. The final attributes are passed to the component/element
+
+## Conditional Execution
+
+All attribute transformers support the same conditional system as actions:
+
+- **`when`**: Specifies the data value to evaluate
+- **`is`**: Exact value comparison
+- **`isEmpty`/`isNotEmpty`**: Empty/non-empty checks
+- **Template evaluation**: Full support for `~.`, `~~.`, `~>`, `~~>` patterns
+
+## Common Patterns
+
+### Conditional Styling
+```yaml
+attributeTransforms:
+  - what: setAttributeValue
+    name: "class"
+    value: "error"
+    when: ~~.validation.hasErrors
+    is: true
+```
+
+### State-based Attributes
+```yaml
+attributeTransforms:
+  - what: toggleAttributeValue
+    name: "aria-expanded"
+    value: "true"
+    when: ~~.menu.isOpen
+    is: true
+```
+
+### Dynamic Data Attributes
+```yaml
+attributeTransforms:
+  - what: setAttributeValue
+    name: "data-user-role"
+    value: ~~.currentUser.role
+    mode: "replace"
+```

package/public/rjbuild/docs/advanced-concepts/attribute-transformers.yaml

@@ -0,0 +1,151 @@
+renderView:
+  - type: Markdown
+    content: |
+      # Attribute Transformers
+
+      > **Note**: Reactive-JSON provides two systems for attribute modification:
+      > 
+      > - **Attribute Transformers** (this section): Execute **before rendering**, modify attributes for child components
+      > - **[Attribute Actions](../core/action/Attribute/index)**: Execute **after rendering**, modify DOM attributes directly
+      > 
+      > Choose transformers for pre-render attribute conditioning and actions for post-render DOM manipulation.
+
+      Attribute Transformers in Reactive-JSON allow you to modify element attributes before rendering based on dynamic conditions. They are evaluated during the attribute evaluation phase and provide pre-render attribute manipulation capabilities.
+
+  - type: TabbedSerializer
+    yamlSerializedContent: |
+      renderView:
+        - type: div
+          attributes:
+            class: "base-class"
+            data-status: "default"
+          attributeTransforms:
+            # Add class conditionally
+            - what: setAttributeValue
+              name: "class"
+              value: "active"
+              when: ~~.isActive
+              is: true
+            
+            # Remove attribute entirely
+            - what: unsetAttribute
+              name: "data-status"
+              when: ~~.hideStatus
+              is: true
+            
+            # Toggle between states
+            - what: toggleAttributeValue
+              name: "class"
+              value: ["theme-light", "theme-dark"]
+              when: ~~.toggleTheme
+              isNotEmpty:
+
+  - type: Markdown
+    content: |
+      ## Key Differences from Actions
+
+      - **Timing**: Attribute transformers execute **before rendering**, while actions execute **after rendering**
+      - **Impact**: Transformers affect attributes passed to child components, actions modify the DOM directly
+      - **Use case**: Transformers are ideal for conditional attribute values that need to be available to child components
+
+      ## Available Transformers
+
+      For a complete list of built-in attribute transformers, see **[Attribute Transformers Reference](../core/attributeTransformer/index)**.
+
+      ## Extensibility
+
+      The Attribute Transformer system is fully extensible through the plugin system. You can create custom transformers to handle specific attribute manipulation needs in your application.
+
+      ### Creating Custom Attribute Transformers
+
+      Attribute transformers are JavaScript functions that receive attributes and transformation properties, then return the modified attributes:
+
+  - type: SyntaxHighlighter
+    language: javascript
+    content: |
+      // customTransformer.js
+      export const myCustomTransformer = ({ attributes, globalDataContext, singleTransformProps, templateContext }) => {
+          const { name, customProperty } = singleTransformProps;
+          
+          // Your custom logic here
+          // Modify the attributes object
+          
+          return attributes;
+      };
+
+  - type: Markdown
+    content: |
+      ### Plugin Registration
+
+      Include your custom transformers in a plugin and register them with ReactiveJsonRoot:
+
+  - type: SyntaxHighlighter
+    language: javascript
+    content: |
+      // myPlugin.js
+      import { myCustomTransformer } from "./transformers/customTransformer.js";
+
+      export const myPlugin = {
+          attributeTransformer: {
+              myCustomTransformer,
+          }
+      };
+
+  - type: SyntaxHighlighter
+    language: javascript
+    content: |
+      // App.js
+      import { ReactiveJsonRoot, mergeComponentCollections } from "@ea-lab/reactive-json";
+      import { myPlugin } from "./plugins/myPlugin.js";
+
+      const App = () => {
+          return (
+              <ReactiveJsonRoot
+                  plugins={mergeComponentCollections([myPlugin])}
+              />
+          );
+      };
+
+  - type: Markdown
+    content: |
+      ### Usage in RjBuild
+
+      Once registered, your custom transformer can be used in any element:
+
+  - type: TabbedSerializer
+    yamlSerializedContent: |
+      renderView:
+        - type: div
+          attributes:
+            class: "base-class"
+          attributeTransforms:
+            - what: myCustomTransformer
+              name: "data-custom"
+              customProperty: "value"
+              when: ~~.someCondition
+              is: true
+
+  - type: Markdown
+    content: |
+      For detailed component development guidance, see **[Plugin Development](./plugins/index)**.
+
+      ## Execution Order
+
+      Attribute transformers are applied in the order they appear in the `attributeTransforms` array:
+
+      1. Base attributes are evaluated (template resolution)
+      2. Each transformer is applied sequentially
+      3. The final attributes are passed to the component/element
+
+      ## Conditional Execution
+
+      All attribute transformers support the same conditional system as actions:
+
+      - **`when`**: Specifies the data value to evaluate
+      - **`is`**: Exact value comparison
+      - **`isEmpty`/`isNotEmpty`**: Empty/non-empty checks
+      - **Template evaluation**: Full support for `~.`, `~~.`, `~>`, `~~>` patterns
+
+data:
+  page_title: "Attribute Transformers - Reactive-JSON Documentation"
+

package/public/rjbuild/docs/advanced-concepts/data-mapping.md

@@ -1,14 +1,14 @@
-# Data Mapping System
+# Data mapping
 
-Data Mapping is a powerful, extensible system in Reactive-JSON that allows you to selectively dispatch and transform response data from HTTP requests to specific locations in your application state.
+Data mapping is a powerful, extensible system in Reactive-JSON that allows you to selectively dispatch and transform response data from HTTP requests to specific locations in your application state.
 
 ## System Architecture
 
-The Data Mapping system operates **after** Data Processors have processed the response, providing a clean separation of concerns:
+The Data mapping system operates **after** Data Processors have processed the response, providing a clean separation of concerns:
 
 1. **HTTP Request** → Server responds with raw data
 2. **Data Processors** → Transform/validate the raw response  
-3. **Data Mapping** → Selectively dispatch transformed data to application state
+3. **Data mapping** → Selectively dispatch transformed data to application state
 4. **Application State** → Updated with mapped data
 
 ## Core Components
@@ -26,7 +26,7 @@ Reactive-JSON includes **simpleMapping** as a core data mapper, providing string
 
 ## Custom Data Mappers
 
-The Data Mapping system is extensible through custom mapper plugins. You can create specialized mappers for complex transformation logic, integration with external libraries, or domain-specific processing needs.
+The Data mapping system is extensible through custom mapper plugins. You can create specialized mappers for complex transformation logic, integration with external libraries, or domain-specific processing needs.
 
 ### Creating Custom Mappers
 
@@ -53,7 +53,7 @@ Custom mappers are automatically merged with core mappers, allowing you to exten
 
 ## Usage Context
 
-Data Mapping can be used with all HTTP-based data operations in Reactive-JSON:
+Data mapping can be used with all HTTP-based data operations in Reactive-JSON:
 
 - **fetchData & submitData reactions**: Process API responses selectively
 - **additionalDataSources**: Map initial data loading responses

package/public/rjbuild/docs/advanced-concepts/data-mapping.yaml

@@ -1,18 +1,18 @@
 renderView:
   - type: Markdown
     content: |
-      # Data Mapping System
+      # Data mapping
 
-      Data Mapping is a powerful, extensible system in Reactive-JSON that allows you to selectively dispatch and transform response data from HTTP requests to specific locations in your application state. This system provides fine-grained control over how incoming data is processed and stored after HTTP operations.
+      Data mapping is a powerful, extensible system in Reactive-JSON that allows you to selectively dispatch and transform response data from HTTP requests to specific locations in your application state. This system provides fine-grained control over how incoming data is processed and stored after HTTP operations.
 
       Data mapping occurs after the [Data Processors](data-processors) have processed the response.
 
       ## System Architecture
 
-      The Data Mapping system processes HTTP response data to selectively dispatch it to application state:
+      The Data mapping system processes HTTP response data to selectively dispatch it to application state:
 
       1. **HTTP Request** → Server responds with data
-      2. **Data Mapping** → Selectively dispatch response data to application state
+      2. **Data mapping** → Selectively dispatch response data to application state
       3. **Application State** → Updated with mapped data
 
       ## Core Components
@@ -30,7 +30,7 @@ renderView:
 
       ## Custom Data Mappers
 
-      The Data Mapping system is extensible through custom mapper plugins. You can create specialized mappers for complex transformation logic, integration with external libraries, or domain-specific processing needs.
+      The Data mapping system is extensible through custom mapper plugins. You can create specialized mappers for complex transformation logic, integration with external libraries, or domain-specific processing needs.
 
       ### Creating Custom Mappers
 
@@ -68,7 +68,7 @@ renderView:
 
       ## Usage Context
 
-      Data Mapping can be used with all HTTP-based data operations in Reactive-JSON:
+      Data mapping can be used with all HTTP-based data operations in Reactive-JSON:
 
   - type: Markdown
     content: |
@@ -100,7 +100,7 @@ renderView:
 
       ## Plugin System Integration
 
-      The Data Mapping system integrates with Reactive-JSON's plugin architecture:
+      The Data mapping system integrates with Reactive-JSON's plugin architecture:
 
       ```javascript
       import { mergeComponentCollections, ReactiveJsonRoot } from "@ea-lab/reactive-json";

package/public/rjbuild/docs/advanced-concepts/data-processors.md

@@ -1,10 +1,10 @@
-# Data Processors
+# Data processors
 
-Data Processors are a powerful feature in Reactive-JSON that allow you to intercept and modify data received via `fetchData`, `submitData`, and `additionalDataSources`. This enables you to implement data transformation, validation, security filtering, and other data processing logic in a centralized and reusable way.
+Data processors are a powerful feature in Reactive-JSON that allow you to intercept and modify data received via `fetchData`, `submitData`, and `additionalDataSources`. This enables you to implement data transformation, validation, security filtering, and other data processing logic in a centralized and reusable way.
 
-## How Data Processors Work
+## How Data processors Work
 
-When Reactive-JSON receives data from HTTP requests, it automatically passes the data through all registered Data Processors in order. Each processor:
+When Reactive-JSON receives data from HTTP requests, it automatically passes the data through all registered Data processors in order. Each processor:
 
 1. **Examines the request and response context** (URL, method, headers, status, etc.)
 2. **Receives the current data** being processed
@@ -54,14 +54,14 @@ Information about the HTTP response:
 - `data`: Raw response data
 
 ### dataToProcess
-The data currently being processed. This may have been modified by previous Data Processors in the chain.
+The data currently being processed. This may have been modified by previous Data processors in the chain.
 
 ### originalDataToProcess
 The original data before any processing, useful for comparison or logging.
 
 ## Plugin Registration
 
-Data Processors are registered through the plugin system:
+Data processors are registered through the plugin system:
 
 ```javascript
 import { mergeComponentCollections } from "@ea-lab/reactive-json";
@@ -222,7 +222,7 @@ additionalDataSource:
 ## Best Practices
 
 ### Always Return Data
-Data Processors **must always return data**. To skip processing, return the original data:
+Data processors **must always return data**. To skip processing, return the original data:
 
 ```javascript
 const myProcessor = ({ requestContext, responseContext, dataToProcess, originalDataToProcess }) => {

package/public/rjbuild/docs/advanced-concepts/data-processors.yaml

@@ -1,13 +1,13 @@
 renderView:
   - type: Markdown
     content: |
-      # Data Processors
+      # Data processors
 
-      Data Processors are a powerful feature in Reactive-JSON that allow you to intercept and modify data received via `fetchData`, `submitData`, and `additionalDataSources`. This enables you to implement data transformation, validation, security filtering, and other data processing logic in a centralized and reusable way.
+      Data processors are a powerful feature in Reactive-JSON that allow you to intercept and modify data received via `fetchData`, `submitData`, and `additionalDataSources`. This enables you to implement data transformation, validation, security filtering, and other data processing logic in a centralized and reusable way.
 
-      ## How Data Processors Work
+      ## How Data processors Work
 
-      When Reactive-JSON receives data from HTTP requests, it automatically passes the data through all registered Data Processors in order. Each processor:
+      When Reactive-JSON receives data from HTTP requests, it automatically passes the data through all registered Data processors in order. Each processor:
 
       1. **Examines the request and response context** (URL, method, headers, status, etc.)
       2. **Receives the current data** being processed
@@ -73,7 +73,7 @@ renderView:
         details:
           type: Markdown
           content: |
-            The data currently being processed. This may have been modified by previous Data Processors in the chain.
+            The data currently being processed. This may have been modified by previous Data processors in the chain.
 
       - term: originalDataToProcess
         details:
@@ -85,7 +85,7 @@ renderView:
     content: |
       ## Plugin Registration
 
-      Data Processors are registered through the plugin system:
+      Data processors are registered through the plugin system:
 
   - type: SyntaxHighlighter
     language: javascript
@@ -213,7 +213,7 @@ renderView:
       ## Best Practices
 
       ### Always Return Data
-      Data Processors **must always return data**. To skip processing, return the original data:
+      Data processors **must always return data**. To skip processing, return the original data:
 
   - type: SyntaxHighlighter
     language: javascript

package/public/rjbuild/docs/advanced-concepts/forward-update.md

@@ -1,10 +1,10 @@
-# Forward Update Pattern (Event Placeholders)
+# Forward update
 
 Added in **reactive-json@0.0.43**.
 
 > Use the special placeholder `<reactive-json:event>` to reference values coming directly from the DOM or the custom event that triggered a reaction.
 
-The **Forward Update** pattern lets you use the special placeholder `<reactive-json:event>` inside any reaction arguments. It is primarily useful with `setData`, but can be applied to any reaction. Instead of reading a value *after* the global data has been updated, you can forward the fresh value carried by the event itself.
+The **Forward update** pattern lets you use the special placeholder `<reactive-json:event>` inside any reaction arguments. It is primarily useful with `setData`, but can be applied to any reaction. Instead of reading a value *after* the global data has been updated, you can forward the fresh value carried by the event itself.
 
 ## Syntax
 

package/public/rjbuild/docs/advanced-concepts/forward-update.yaml

@@ -7,11 +7,11 @@ renderView:
 
   - type: Markdown
     content: |
-      # Forward Update Pattern (Event Placeholders)
+      # Forward update
 
       > Use the special placeholder `<reactive-json:event>` to reference values coming directly from the DOM or custom event that triggered a reaction.
 
-      The **Forward Update** pattern lets you use the special placeholder `<reactive-json:event>` inside any reaction arguments. 
+      The **Forward update** pattern lets you use the special placeholder `<reactive-json:event>` inside any reaction arguments. 
       It is primarily useful with `setData`, but can be applied to any reaction.  
       Instead of reading a value *after* the global data has been updated, you can forward the fresh value carried by the event itself.
 

package/public/rjbuild/docs/advanced-concepts/index.md

@@ -4,6 +4,7 @@ This section covers advanced features and concepts in Reactive-JSON that enable
 
 ## Topics
 
+- **[Attribute Transformers](attribute-transformers.md)**: Details on how element attributes can be modified by the app state.
 - **[Data Mapping](data-mapping.md)**: Learn how to selectively dispatch and transform response data using the Data Mapping system
 - **[Data Processors](data-processors.md)**: Learn how to intercept and modify data from HTTP requests using the DataProcessor system
 - **[Forward Update](forward-update.md)**: Implementation details about the retrieval of event values.

package/public/rjbuild/docs/advanced-concepts/index.yaml

@@ -7,6 +7,7 @@ renderView:
 
       ## Topics
 
+      - **[Attribute Transformers](attribute-transformers)**: Details on how element attributes can be modified by the app state.
       - **[Data Mapping](data-mapping)**: Learn how to selectively dispatch and transform response data using the Data Mapping system.
       - **[Data Processors](data-processors)**: Learn how to intercept and modify data from HTTP requests using the DataProcessor system.
       - **[Forward Update](forward-update)**: Implementation details about the retrieval of event values.

package/public/rjbuild/docs/advanced-concepts/plugins/component-development.md

@@ -1,4 +1,4 @@
-# Component Development Guide
+# Component development guide
 
 ## Overview
 

package/public/rjbuild/docs/advanced-concepts/plugins/component-development.yaml

@@ -1,7 +1,7 @@
 renderView:
   - type: Markdown
     content: |
-      # Component Development Guide
+      # Component development guide
 
       ## Overview
 

package/public/rjbuild/docs/advanced-concepts/plugins/plugin-system.md

@@ -1,4 +1,4 @@
-# Plugin System Guide
+# Plugin system guide
 
 ## Overview
 

package/public/rjbuild/docs/advanced-concepts/plugins/plugin-system.yaml

@@ -1,7 +1,7 @@
 renderView:
   - type: Markdown
     content: |
-      # Plugin System Guide
+      # Plugin system guide
 
       ## Overview
 

package/public/rjbuild/docs/core/action/Attribute/SetAttributeValue.md

@@ -1,5 +1,7 @@
 # SetAttributeValue
 
+> **Alternative**: For pre-render attribute modification, see the [setAttributeValue transformer](../../attributeTransformer/setAttributeValue.md).
+
 Dynamically sets or modifies the value of an HTML attribute on an element.
 
 ## Basic Syntax

package/public/rjbuild/docs/core/action/Attribute/SetAttributeValue.yaml

@@ -3,6 +3,8 @@ renderView:
     content: |
       # SetAttributeValue
 
+      > **Alternative**: For pre-render attribute modification, see the [setAttributeValue transformer](../../attributeTransformer/setAttributeValue).
+
       Dynamically sets or modifies the value of an HTML attribute on an element.
 
       ## Basic Syntax

package/public/rjbuild/docs/core/action/Attribute/ToggleAttributeValue.md

@@ -1,5 +1,7 @@
 # ToggleAttributeValue
 
+> **Alternative**: For pre-render attribute modification, see the [toggleAttributeValue transformer](../../attributeTransformer/toggleAttributeValue.md).
+
 Toggles the presence of a specific value in an HTML attribute. Supports both simple on-off toggles and cyclic toggling through multiple values.
 
 ## Important Notes

package/public/rjbuild/docs/core/action/Attribute/ToggleAttributeValue.yaml

@@ -3,6 +3,8 @@ renderView:
     content: |
       # ToggleAttributeValue
 
+      > **Alternative**: For pre-render attribute modification, see the [toggleAttributeValue transformer](../../attributeTransformer/toggleAttributeValue).
+
       Toggles the presence of a specific value in an HTML attribute. Supports both simple on-off toggles and cyclic toggling through multiple values.
 
       ## Important Notes

package/public/rjbuild/docs/core/action/Attribute/UnsetAttribute.md

@@ -1,5 +1,7 @@
 # UnsetAttribute
 
+> **Alternative**: For pre-render attribute modification, see the [unsetAttribute transformer](../../attributeTransformer/unsetAttribute.md).
+
 Completely removes an HTML attribute from an element.
 
 ## Basic Syntax

package/public/rjbuild/docs/core/action/Attribute/UnsetAttribute.yaml

@@ -3,6 +3,8 @@ renderView:
     content: |
       # UnsetAttribute
 
+      > **Alternative**: For pre-render attribute modification, see the [unsetAttribute transformer](../../attributeTransformer/unsetAttribute).
+
       Completely removes an HTML attribute from an element.
 
       ## Basic Syntax

package/public/rjbuild/docs/core/action/Attribute/UnsetAttributeValue.md

@@ -1,5 +1,7 @@
 # UnsetAttributeValue
 
+> **Alternative**: For pre-render attribute modification, see the [unsetAttributeValue transformer](../../attributeTransformer/unsetAttributeValue.md).
+
 Removes a specific value from an HTML attribute while preserving other values.
 
 ## Basic Syntax

package/public/rjbuild/docs/core/action/Attribute/UnsetAttributeValue.yaml

@@ -3,6 +3,8 @@ renderView:
     content: |
       # UnsetAttributeValue
 
+      > **Alternative**: For pre-render attribute modification, see the [unsetAttributeValue transformer](../../attributeTransformer/unsetAttributeValue).
+
       Removes a specific value from an HTML attribute while preserving other values.
 
       ## Basic Syntax