Added Niels changes from GitBook

Author: eshanrnh

17/umbraco-cms/customizing/extending-overview/extension-types/workspaces/workspace-context.md

@@ -1,24 +1,20 @@
 ---
 description: >-
-  Learn how to create workspace contexts that manage shared state and enable communication between extensions in a workspace.
+  Workspace Contexts manages shared state and enables communication between extensions in a workspace.
 ---
 
 # Workspace Context
 
-Workspace Contexts serve as the central communication hub for workspace extensions, providing shared state management within workspace boundaries. They enable different workspace components to interact through a common data layer.
+Workspace Contexts serve as the central communication hub for workspace extensions, providing shared state management within the boundaries of the Workspace. They enable different Workspace components to interact through a common data layer.
 
 ## Purpose
 
 Workspace Contexts provide:
 
-- **Shared state** scoped to a specific workspace instance
-- **Communication layer** between extensions in the workspace
-- **Entity lifecycle management** for workspace data
-- **Context isolation** ensures workspace independence
-
-{% hint style="info" %}
-Workspace Contexts are automatically scoped to their workspace. Extensions in different workspaces cannot access each other's contexts.
-{% endhint %}
+- **Shared state** scoped to a specific workspace instance.
+- **Communication layer** between extensions in the workspace.
+- **Entity lifecycle management** for workspace data.
+- **Context isolation** ensures workspace independence.
 
 ## Manifest
 
@@ -39,7 +35,7 @@ Workspace Contexts are automatically scoped to their workspace. Extensions in di
 ```
 {% endcode %}
 
-## Implementation
+## API Implementation
 
 Create a workspace context by extending `UmbContextBase` and providing a unique context token. Add this to your project to enable shared state management between workspace extensions:
 
@@ -50,7 +46,7 @@ import { UmbContextBase } from '@umbraco-cms/backoffice/class-api';
 import type { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
 import { UmbNumberState } from '@umbraco-cms/backoffice/observable-api';
 
-export class WorkspaceContextCounterElement extends UmbContextBase {
+export class WorkspaceContextCounter extends UmbContextBase {
 	#counter = new UmbNumberState(0);
 	readonly counter = this.#counter.asObservable();
 
@@ -67,139 +63,55 @@ export class WorkspaceContextCounterElement extends UmbContextBase {
 	}
 }
 
-export const api = WorkspaceContextCounterElement;
-
-export const EXAMPLE_COUNTER_CONTEXT = new UmbContextToken<WorkspaceContextCounterElement>(
-	'UmbWorkspaceContext',
-	'example.workspaceContext.counter',
-);
+export const api = WorkspaceContextCounter;
 ```
 {% endcode %}
 
-## Context Token Pattern
+## Context Token
 
-Always use `'UmbWorkspaceContext'` as the first parameter in your context token to ensure proper workspace scoping and isolation:
+A Context Token is used to consume or get a Context. Read more about [Context Consumption here](../../../foundation/context-api/consume-a-context.md).
 
 ```typescript
-export const MY_WORKSPACE_CONTEXT = new UmbContextToken<MyWorkspaceContext>(
+export const EXAMPLE_COUNTER_CONTEXT = new UmbContextToken<WorkspaceContextCounter>(
 	'UmbWorkspaceContext', // Ensures workspace scoping
-	'my.extension.alias',   // Must match manifest alias
+	'example.workspaceContext.counter',   // Must match manifest alias
 );
 ```
 
-## Workspace Lifecycle
-
-### Initialization
-
-- Created when workspace loads
-- Available to all extensions within that workspace
-- Destroyed when workspace closes
-
-### Scoping
-
-- Context instances are isolated per workspace
-- Extensions can only access contexts from their own workspace
-- Context requests automatically scope to the nearest workspace
-
-### Conditions
-
-Workspace contexts only initialize when their conditions match:
-
-```typescript
-conditions: [
-	{
-		alias: UMB_WORKSPACE_CONDITION_ALIAS,
-		match: 'Umb.Workspace.Document', // Only available in document workspaces
-	},
-],
-```
-
-## Entity Data Patterns
+When declaring a Workspace Context, always use `'UmbWorkspaceContext'` as the first parameter in your Context Token to ensure proper context isolation.
 
-### Draft State Management
+## Extension Communication
 
-```typescript
-export class EntityWorkspaceContext extends UmbContextBase {
-	#entity = new UmbObjectState<MyEntity | null>(null);
-	#isDirty = new UmbBooleanState(false);
-
-	readonly entity = this.#entity.asObservable();
-	readonly isDirty = this.#isDirty.asObservable();
-
-	updateEntity(changes: Partial<MyEntity>) {
-		const current = this.#entity.getValue();
-		if (current) {
-			this.#entity.setValue({ ...current, ...changes });
-			this.#isDirty.setValue(true);
-		}
-	}
-}
-```
+### Workspace Action
 
-### Server Integration
+The following example shows how to call the increment method from a Workspace Action API.
 
 ```typescript
-export class ServerEntityContext extends UmbContextBase {
-	#repository = inject(MyEntityRepository);
-
-	async save() {
-		const entity = this.#entity.getValue();
-		const saved = await this.#repository.save(entity);
-		this.#entity.setValue(saved);
-		this.#isDirty.setValue(false);
+export class MyIncreaseCounterWorkspaceAction extends UmbWorkspaceActionBase {
+	override async execute() {
+		const context = await this.getContext(EXAMPLE_COUNTER_CONTEXT);
+		context.increment();
 	}
 }
 ```
 
-## Extension Communication
+### Workspace View
 
-### In Workspace Actions
+The following example shows how a Workspace View Element can consume a context.
 
 ```typescript
-export class MyWorkspaceAction extends UmbWorkspaceActionBase {
-	override async execute() {
-		const context = await this.getContext(MY_WORKSPACE_CONTEXT);
-		context.performAction();
-	}
-}
-```
+export class MyWorkspaceView extends UmbElementMixin(LitElement) {
 
-### In Workspace Views
+	@state()
+	_count?: number;
 
-```typescript
-export class MyWorkspaceView extends UmbElementMixin(LitElement) {
 	constructor() {
 		super();
-		this.consumeContext(MY_WORKSPACE_CONTEXT, (context) => {
-			this.observe(context.data, (data) => this.requestUpdate());
+		this.consumeContext(EXAMPLE_COUNTER_CONTEXT, (context) => {
+			this.observe(context.counter, (count) => this._count = count);
 		});
 	}
+	
+	// A render using _count
 }
 ```
-
-## Best Practices
-
-### State Encapsulation
-
-```typescript
-// ✅ Private state with public observables
-#data = new UmbObjectState(initialData);
-readonly data = this.#data.asObservable();
-
-// ❌ Direct state exposure
-data = new UmbObjectState(initialData);
-```
-
-### Context Token Consistency
-
-```typescript
-// ✅ Use workspace scoping
-new UmbContextToken<T>('UmbWorkspaceContext', 'my.alias');
-
-// ❌ Generic context (not workspace-scoped)
-new UmbContextToken<T>('MyContext', 'my.alias');
-```
-
-### Conditional Availability
-
-Only provide contexts when they are meaningful for the workspace type.

17/umbraco-cms/customizing/foundation/states.md

@@ -1,19 +1,23 @@
 ---
 description: >-
   Make reactivity with Umbraco States, enabling you to provide a value that
-  multiple others can observe and thereby be updated when the value changes.
+  others can observe and thereby be updated when the value changes.
 ---
 
 # States
 
-An Umbraco State is a container for a value, it enables you to create [Observables](states.md#observables), which is the name of a hook into the States value — An Observable can then be Observed, such observation provides the current value and if the value of the State changes they will all be updated accordingly.
-
-A typical use case is when you need to implement reactivity across class instances. For example, a State is in a Context and the Observer is a Element. For a concrete example, see the [Extension Type Workspace Context](../extending-overview/extension-types/workspaces/workspace-context.md) article.
-
 {% hint style="info" %}
-Umbraco States are not relevant when dealing with the reactivity of a Web Component. For that, see the [Lit Element](lit-element.md) article.
+Umbraco States are not relevant when dealing with the reactivity of a Web Component. For more information, see the [Lit Element](lit-element.md) article.
 {% endhint %}
 
+An Umbraco State is a container for a value. You create [Observables](../foundation/states.md#observe), which is the name of a hook into the State's value. An Observable can then be observed, providing the current value, and if the value of the State changes, all Observables will be updated accordingly.
+
+A typical use case is to bring reactivity across class instances. For example, a Context may provide a value that an Element needs to utilize.
+
+In this case, the Context would implement a State and an Observable of it. The Element would then observe the Observable of the Context.
+
+You can see an example of this pattern in the [Extension Type Workspace Context](../extending-overview/extension-types/workspaces/workspace-context.md) article.
+
 The example below demonstrates the basics of working with a State and observing its changes:
 
 ```