mutts 1.0.0 → 1.0.1

package/docs/reactive.md

@@ -1,5 +1,21 @@
 # Reactive Documentation
 
+## Table of Contents
+
+- [Introduction](#introduction)
+- [Getting Started](#getting-started)
+- [Core API](#core-api)
+- [Effect System](#effect-system)
+- [Evolution Tracking](#evolution-tracking)
+- [Collections](#collections)
+- [ReactiveArray](#reactivearray)
+- [Class Reactivity](#class-reactivity)
+- [Non-Reactive System](#non-reactive-system)
+- [Computed Properties](#computed-properties)
+- [Atomic Operations](#atomic-operations)
+- [Advanced Patterns](#advanced-patterns)
+- [Debugging and Development](#debugging-and-development)
+- [API Reference](#api-reference)
 
 ## Introduction
 
@@ -12,6 +28,7 @@ Reactivity is a programming paradigm where the system automatically tracks depen
 - **Reactive Objects**: Plain JavaScript objects wrapped with reactive capabilities
 - **Effects**: Functions that automatically re-run when their dependencies change
 - **Dependencies**: Reactive properties that an effect depends on
+- **Atomic Operations**: Batching multiple state changes to execute effects only once
 - **Evolution Tracking**: Built-in change history for reactive objects
 - **Collections**: Reactive wrappers for Array, Map, Set, WeakMap, and WeakSet
 
@@ -1509,6 +1526,544 @@ state.count = 5
 // effect logs and updates title
 ```
 
+## Atomic Operations
+
+The `atomic` function and `@atomic` decorator are powerful tools for batching reactive effects. When applied to a method or function, they ensure that all effects triggered by reactive state changes within that scope are batched together and executed only once, rather than after each individual change.
+
+### Overview
+
+In reactive systems, each state change typically triggers its dependent effects immediately. However, when you need to make multiple related changes as a single unit, this can lead to:
+
+- Multiple unnecessary effect executions
+- Inconsistent intermediate states being observed
+- Performance overhead from redundant computations
+
+The `atomic` function and `@atomic` decorator solve this by deferring effect execution until the function or method completes, treating all changes as a single atomic operation.
+
+### Basic Usage
+
+#### Decorator Syntax
+
+```typescript
+import { reactive, effect, atomic } from 'mutts'
+
+const state = reactive({ a: 0, b: 0, c: 0 })
+let effectCount = 0
+
+effect(() => {
+  effectCount++
+  console.log(`Effect ran: a=${state.a}, b=${state.b}, c=${state.c}`)
+})
+
+class StateManager {
+  @atomic
+  updateAll() {
+    state.a = 1
+    state.b = 2
+    state.c = 3
+  }
+}
+
+const manager = new StateManager()
+manager.updateAll()
+
+// Output:
+// Effect ran: a=0, b=0, c=0  (initial run)
+// Effect ran: a=1, b=2, c=3  (only one additional run despite 3 changes)
+```
+
+#### Function Syntax
+
+For standalone functions or when you need more flexibility, you can use the `atomic` function directly:
+
+```typescript
+import { reactive, effect, atomic } from 'mutts'
+
+const state = reactive({ a: 0, b: 0, c: 0 })
+let effectCount = 0
+
+effect(() => {
+  effectCount++
+  console.log(`Effect ran: a=${state.a}, b=${state.b}, c=${state.c}`)
+})
+
+// Using atomic function
+atomic(() => {
+  state.a = 1
+  state.b = 2
+  state.c = 3
+})
+
+// Output:
+// Effect ran: a=0, b=0, c=0  (initial run)
+// Effect ran: a=1, b=2, c=3  (only one additional run despite 3 changes)
+```
+
+#### Returning Values
+
+The atomic function can return values:
+
+```typescript
+const result = atomic(() => {
+  state.a = 10
+  state.b = 20
+  return state.a + state.b
+})
+
+console.log(result) // 30
+```
+
+#### Atomic Method Return Values
+
+The `@atomic` decorator also supports return values from methods:
+
+```typescript
+@reactive
+class Calculator {
+  @atomic
+  updateAndCalculate(a: number, b: number) {
+    this.a = a
+    this.b = b
+    return { sum: a + b, product: a * b }
+  }
+}
+
+const calc = new Calculator()
+const result = calc.updateAndCalculate(5, 10)
+console.log(result) // { sum: 15, product: 50 }
+```
+
+**Key Points:**
+- Atomic methods can return any value type (primitives, objects, functions)
+- Return values are computed during method execution
+- Effects are batched until the method completes, regardless of return values
+- Both read-only and state-modifying methods can return values
+
+```typescript
+@reactive
+class DataProcessor {
+  @atomic
+  processData(items: Item[]) {
+    // Read-only method with return value
+    const total = items.reduce((sum, item) => sum + item.value, 0)
+    return total
+  }
+
+  @atomic
+  updateAndProcess(items: Item[]) {
+    // State-modifying method with return value
+    this.items = items
+    this.processedCount = items.length
+    this.lastProcessed = new Date()
+    
+    return {
+      count: items.length,
+      total: items.reduce((sum, item) => sum + item.value, 0)
+    }
+  }
+}
+```
+
+### When to Use Each Approach
+
+#### Use `@atomic` Decorator When:
+- You're working with class methods
+- You want to declare atomic behavior at the method level
+- You prefer declarative syntax
+- The method is part of a reactive class
+
+```typescript
+@reactive
+class TodoManager {
+  @atomic
+  addTodo(text: string) {
+    this.todos.push({ id: Date.now(), text, completed: false })
+    this.updateStats()
+  }
+}
+```
+
+#### Use `atomic()` Function When:
+- You need atomic behavior for standalone functions
+- You're working with functional code
+- You need to conditionally apply atomic behavior
+- You're working outside of classes
+
+```typescript
+// Conditional atomic behavior
+const updateState = (shouldBatch: boolean) => {
+  const updateFn = () => {
+    state.a = 1
+    state.b = 2
+  }
+  
+  return shouldBatch ? atomic(updateFn) : updateFn()
+}
+
+// Functional approach
+const processItems = (items: Item[]) => {
+  return atomic(() => {
+    items.forEach(item => state.items.set(item.id, item))
+    state.count = state.items.size
+    return state.count
+  })
+}
+```
+
+### Key Behaviors
+
+#### Immediate Execution, Batched Effects
+
+The decorated method executes immediately, but effects are deferred until completion:
+
+```typescript
+class TestClass {
+  @atomic
+  updateAndLog() {
+    console.log('Method starts')
+    state.a = 1
+    console.log('After setting a')
+    state.b = 2
+    console.log('After setting b')
+    console.log('Method ends')
+  }
+}
+
+// Execution order:
+// Method starts
+// After setting a
+// After setting b
+// Method ends
+// Effect runs with final values
+```
+
+#### Nested Atomic Methods
+
+Multiple atomic methods can be nested, and all effects are batched at the outermost level:
+
+```typescript
+class TestClass {
+  @atomic
+  updateA() {
+    state.a = 1
+  }
+
+  @atomic
+  updateB() {
+    state.b = 2
+  }
+
+  @atomic
+  updateAll() {
+    this.updateA()
+    this.updateB()
+    state.c = 3
+  }
+}
+
+// Calling updateAll() will batch all effects from updateA, updateB, and the direct assignment
+```
+
+#### Cascading Effects
+
+Effects that trigger other effects are also batched within atomic methods:
+
+```typescript
+// Create cascading effects
+effect(() => {
+  state.b = state.a * 2
+})
+effect(() => {
+  state.c = state.b + 1
+})
+
+class TestClass {
+  @atomic
+  triggerCascade() {
+    state.a = 5  // This triggers the cascade
+  }
+}
+
+// All cascading effects are batched together
+```
+
+### Advanced Usage
+
+#### Working with Reactive Classes
+
+The `@atomic` decorator works seamlessly with `@reactive` classes:
+
+```typescript
+@reactive
+class Counter {
+  value = 0
+  multiplier = 1
+
+  @atomic
+  updateBoth(newValue: number, newMultiplier: number) {
+    this.value = newValue
+    this.multiplier = newMultiplier
+  }
+}
+
+const counter = new Counter()
+let effectCount = 0
+
+effect(() => {
+  effectCount++
+  console.log(`Counter: ${counter.value} * ${counter.multiplier}`)
+})
+
+counter.updateBoth(5, 2)
+// Effect runs only once despite two property changes
+```
+
+#### Complex Data Structures
+
+Atomic methods work with arrays, maps, sets, and other complex data structures:
+
+```typescript
+const state = reactive({
+  items: [1, 2, 3],
+  metadata: new Map([['count', 3]]),
+  tags: new Set(['active'])
+})
+
+class DataManager {
+  @atomic
+  addItem(item: number) {
+    state.items.push(item)
+    state.metadata.set('count', state.items.length)
+    state.tags.add('modified')
+  }
+
+  @atomic
+  clearAll() {
+    state.items.length = 0
+    state.metadata.clear()
+    state.tags.clear()
+  }
+}
+```
+
+#### Error Handling
+
+If an atomic method throws an error, effects are still executed for the changes that were made before the error:
+
+```typescript
+class TestClass {
+  @atomic
+  updateWithError() {
+    state.a = 1
+    throw new Error('Something went wrong')
+    // state.b = 2  // This line never executes
+  }
+}
+
+// Effect will run once for the change to state.a
+// state.b remains unchanged due to the error
+```
+
+#### Async Operations
+
+Atomic methods can be async, but effects are still batched:
+
+```typescript
+class TestClass {
+  @atomic
+  async updateAsync() {
+    state.a = 1
+    await someAsyncOperation()
+    state.b = 2
+  }
+}
+
+// Effects are batched even with async operations
+```
+
+### Performance Benefits
+
+#### Reduced Effect Executions
+
+Without `atomic`:
+```typescript
+// This would trigger the effect 3 times
+state.a = 1  // Effect runs
+state.b = 2  // Effect runs
+state.c = 3  // Effect runs
+```
+
+With `atomic`:
+```typescript
+@atomic
+updateAll() {
+  state.a = 1
+  state.b = 2
+  state.c = 3
+}
+// Effect runs only once
+```
+
+#### Consistent State
+
+Atomic operations ensure that effects always see a consistent state:
+
+```typescript
+effect(() => {
+  // This will never see inconsistent intermediate states
+  if (state.a > 0 && state.b > 0) {
+    console.log('Both values are positive')
+  }
+})
+
+@atomic
+updateBoth() {
+  state.a = 1  // Effect doesn't run yet
+  state.b = 2  // Effect doesn't run yet
+  // Effect runs once with both values updated
+}
+```
+
+### Best Practices
+
+#### Use for Related Changes
+
+Apply `atomic` to methods that make logically related changes:
+
+```typescript
+// Good: Related user profile updates
+@atomic
+updateProfile(name: string, age: number, email: string) {
+  this.name = name
+  this.age = age
+  this.email = email
+}
+
+// Good: Complex state initialization
+@atomic
+initialize() {
+  this.loading = false
+  this.data = fetchedData
+  this.error = null
+  this.lastUpdated = new Date()
+}
+```
+
+#### Combine with Other Decorators
+
+The `@atomic` decorator works well with other decorators:
+
+```typescript
+@reactive
+class UserManager {
+  @atomic
+  updateUser(id: string, updates: Partial<User>) {
+    this.users.set(id, { ...this.users.get(id), ...updates })
+    this.lastModified = new Date()
+  }
+}
+```
+
+#### Consider Performance
+
+For methods that make many changes, `atomic` provides significant performance benefits:
+
+```typescript
+@atomic
+updateManyItems(items: Item[]) {
+  for (const item of items) {
+    this.items.set(item.id, item)
+  }
+  this.count = this.items.size
+  this.lastUpdate = new Date()
+}
+// Without @atomic: effect would run for each item + count + timestamp
+// With @atomic: effect runs only once
+```
+
+### Limitations
+
+- **Method-only**: The decorator only works on class methods, not standalone functions (use `atomic()` function instead)
+- **Synchronous batching**: Effects are batched until the method completes, but async operations within the method don't affect the batching
+- **Error handling**: If a method throws, effects still run for changes made before the error
+
+### Integration
+
+The `atomic` function and `@atomic` decorator integrate seamlessly with:
+
+- `@reactive` classes
+- `@unreactive` property marking
+- `effect()` functions
+- `computed()` values
+- Native collection types (Array, Map, Set, etc.)
+
+### Complete Example
+
+```typescript
+import { reactive, effect, atomic } from 'mutts'
+
+@reactive
+class TodoManager {
+  todos: Todo[] = []
+  filter: 'all' | 'active' | 'completed' = 'all'
+  loading = false
+
+  @atomic
+  addTodo(text: string) {
+    const todo: Todo = {
+      id: Date.now().toString(),
+      text,
+      completed: false,
+      createdAt: new Date()
+    }
+    this.todos.push(todo)
+    this.updateStats()
+  }
+
+  @atomic
+  toggleTodo(id: string) {
+    const todo = this.todos.find(t => t.id === id)
+    if (todo) {
+      todo.completed = !todo.completed
+      this.updateStats()
+    }
+  }
+
+  @atomic
+  setFilter(filter: 'all' | 'active' | 'completed') {
+    this.filter = filter
+    this.loading = false
+  }
+
+  private updateStats() {
+    // This method is called from within atomic methods
+    // Effects will be batched until the calling atomic method completes
+    const activeCount = this.todos.filter(t => !t.completed).length
+    const completedCount = this.todos.length - activeCount
+    
+    // Update derived state
+    this.activeCount = activeCount
+    this.completedCount = completedCount
+    this.allCompleted = completedCount === this.todos.length && this.todos.length > 0
+  }
+}
+
+// Usage
+const todoManager = new TodoManager()
+
+effect(() => {
+  console.log(`Active: ${todoManager.activeCount}, Completed: ${todoManager.completedCount}`)
+})
+
+// Adding a todo triggers updateStats, but effect runs only once
+todoManager.addTodo('Learn MutTs atomic operations')
+
+// Toggling a todo also triggers updateStats, effect runs only once
+todoManager.toggleTodo('some-id')
+```
+
+This example demonstrates how `atomic` ensures that complex state updates are treated as single, consistent operations, improving both performance and reliability.
+
 ## Advanced Patterns
 
 ### Custom Reactive Objects
@@ -1738,6 +2293,49 @@ const result = computed(myExpensiveCalculus);
 By how JS works, writing `computed(()=> ...)` will always be wrong, as the notation `()=> ...` internally is a `new Function(...)`.
 So, even if the return value is cached, it will never be used.
 
+#### `@atomic`
+
+Marks a class method as atomic, batching all effects triggered within the method until it completes.
+
+```typescript
+class MyClass {
+  @atomic
+  updateMultiple() {
+    this.a = 1
+    this.b = 2
+    this.c = 3
+    // Effects are batched and run only once after this method completes
+  }
+
+  @atomic
+  updateAndReturn() {
+    this.a = 10
+    this.b = 20
+    return { sum: this.a + this.b, product: this.a * this.b }
+  }
+}
+
+// Function usage
+const result = atomic(() => {
+  state.a = 1
+  state.b = 2
+  return state.a + state.b
+})
+```
+
+**Use Cases:**
+- Batching multiple related state changes
+- Performance optimization for methods with multiple updates
+- Ensuring consistent state in effects
+- Reducing unnecessary effect executions
+- Returning computed values from atomic operations
+
+**Notes:**
+- Effects are deferred until the method/function completes
+- Nested atomic methods are batched at the outermost level
+- Works with both class methods and standalone functions
+- Methods and functions can return values (primitives, objects, functions)
+
 #### `@unreactive`
 
 Marks a class property as non-reactive. The property change will not be tracked by the reactive system.
@@ -1803,6 +2401,24 @@ const cleanup = effect((dep) => {
 });
 ```
 
+#### `atomic<T>(fn: () => T): T`
+
+Creates an atomic operation that batches all effects triggered within the function until it completes.
+
+**Use Cases:**
+- Batching multiple related state changes
+- Performance optimization for functions with multiple updates
+- Ensuring consistent state in effects
+- Reducing unnecessary effect executions
+
+```typescript
+const result = atomic(() => {
+  state.a = 1
+  state.b = 2
+  return state.a + state.b
+})
+```
+
 #### `computed<T>(getter: ComputedFunction<T>): T`
 
 Creates a computed value that caches its result and recomputes when dependencies change.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mutts",
   "description": "Modern UTility TS: A collection of TypeScript utilities",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "main": "dist/index.js",
   "module": "dist/index.esm.js",
   "types": "dist/index.d.ts",
@@ -70,7 +70,6 @@
   },
   "files": [
     "dist",
-    "src",
     "README.md",
     "docs"
   ],

package/dist/chunks/decorator-BXsign4Z.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"decorator-BXsign4Z.js","sources":["../../src/utils.ts","../../src/decorator.ts"],"sourcesContent":["type ElementTypes<T extends readonly unknown[]> = {\n\t[K in keyof T]: T[K] extends readonly (infer U)[] ? U : T[K]\n}\n\nexport function zip<T extends (readonly unknown[])[]>(...args: T): ElementTypes<T>[] {\n\tif (!args.length) return []\n\tconst minLength = Math.min(...args.map((arr) => arr.length))\n\tconst result: ElementTypes<T>[] = []\n\n\tfor (let i = 0; i < minLength; i++) {\n\t\tconst tuple = args.map((arr) => arr[i]) as ElementTypes<T>\n\t\tresult.push(tuple)\n\t}\n\n\treturn result\n}\n\nconst nativeConstructors = new Set<Function>([\n\tObject,\n\tArray,\n\tDate,\n\tFunction,\n\tSet,\n\tMap,\n\tWeakMap,\n\tWeakSet,\n\tPromise,\n\tError,\n\tTypeError,\n\tReferenceError,\n\tSyntaxError,\n\tRangeError,\n\tURIError,\n\tEvalError,\n\tReflect,\n\tProxy,\n\tRegExp,\n\tString,\n\tNumber,\n\tBoolean,\n] as Function[])\nexport function isConstructor(fn: Function): boolean {\n\treturn fn && (nativeConstructors.has(fn) || fn.toString().startsWith('class '))\n}\n\nexport function renamed<F extends Function>(fct: F, name: string): F {\n\treturn Object.defineProperties(fct, {\n\t\tname: {\n\t\t\tvalue: name,\n\t\t},\n\t})\n}\n","// biome-ignore-all lint/suspicious/noConfusingVoidType: We *love* voids\n// Standardized decorator system that works with both Legacy and Modern decorators\n\nimport { isConstructor } from './utils'\n\nexport class DecoratorError extends Error {\n\tconstructor(message: string) {\n\t\tsuper(message)\n\t\tthis.name = 'DecoratorException'\n\t}\n}\n//#region all decorator types\n\n// Used for get/set and method decorators\nexport type LegacyPropertyDecorator<T> = (\n\ttarget: T,\n\tname: string | symbol,\n\tdescriptor: PropertyDescriptor\n) => any\n\nexport type LegacyClassDecorator<T> = (target: T) => any\n\nexport type ModernMethodDecorator<T> = (target: T, context: ClassMethodDecoratorContext) => any\n\nexport type ModernGetterDecorator<T> = (target: T, context: ClassGetterDecoratorContext) => any\n\nexport type ModernSetterDecorator<T> = (target: T, context: ClassSetterDecoratorContext) => any\n\nexport type ModernAccessorDecorator<T> = (target: T, context: ClassAccessorDecoratorContext) => any\n\nexport type ModernClassDecorator<T> = (target: T, context: ClassDecoratorContext) => any\n\n//#endregion\n\ntype DDMethod<T> = (\n\toriginal: (this: T, ...args: any[]) => any,\n\tname: PropertyKey\n) => ((this: T, ...args: any[]) => any) | void\n\ntype DDGetter<T> = (original: (this: T) => any, name: PropertyKey) => ((this: T) => any) | void\n\ntype DDSetter<T> = (\n\toriginal: (this: T, value: any) => void,\n\tname: PropertyKey\n) => ((this: T, value: any) => void) | void\n\ntype DDClass<T> = <Ctor extends new (...args: any[]) => T = new (...args: any[]) => T>(\n\ttarget: Ctor\n) => Ctor | void\nexport interface DecoratorDescription<T> {\n\tmethod?: DDMethod<T>\n\tclass?: DDClass<T>\n\tgetter?: DDGetter<T>\n\tsetter?: DDSetter<T>\n\tdefault?: (...args: any[]) => any\n}\n\nexport type Decorator<T, Description extends DecoratorDescription<T>> = (Description extends {\n\tmethod: DDMethod<T>\n}\n\t? LegacyPropertyDecorator<T> & ModernMethodDecorator<T>\n\t: unknown) &\n\t(Description extends { class: DDClass<new (...args: any[]) => T> }\n\t\t? LegacyClassDecorator<new (...args: any[]) => T> &\n\t\t\t\tModernClassDecorator<new (...args: any[]) => T>\n\t\t: unknown) &\n\t(Description extends { getter: DDGetter<T> }\n\t\t? LegacyPropertyDecorator<T> & ModernGetterDecorator<T> & ModernAccessorDecorator<T>\n\t\t: unknown) &\n\t(Description extends { setter: DDSetter<T> }\n\t\t? LegacyPropertyDecorator<T> & ModernSetterDecorator<T> & ModernAccessorDecorator<T>\n\t\t: unknown) &\n\t(Description extends { default: infer Signature } ? Signature : unknown)\n\nexport type DecoratorFactory<T> = <Description extends DecoratorDescription<T>>(\n\tdescription: Description\n) => (Description extends { method: DDMethod<T> }\n\t? LegacyPropertyDecorator<T> & ModernMethodDecorator<T>\n\t: unknown) &\n\t(Description extends { class: DDClass<new (...args: any[]) => T> }\n\t\t? LegacyClassDecorator<new (...args: any[]) => T> &\n\t\t\t\tModernClassDecorator<new (...args: any[]) => T>\n\t\t: unknown) &\n\t(Description extends { getter: DDGetter<T> }\n\t\t? LegacyPropertyDecorator<T> & ModernGetterDecorator<T> & ModernAccessorDecorator<T>\n\t\t: unknown) &\n\t(Description extends { setter: DDSetter<T> }\n\t\t? LegacyPropertyDecorator<T> & ModernSetterDecorator<T> & ModernAccessorDecorator<T>\n\t\t: unknown) &\n\t(Description extends { default: infer Signature } ? Signature : unknown)\n\nexport function legacyDecorator<T = any>(description: DecoratorDescription<T>): any {\n\treturn function (\n\t\ttarget: any,\n\t\tpropertyKey?: PropertyKey,\n\t\tdescriptor?: PropertyDescriptor,\n\t\t...args: any[]\n\t) {\n\t\tif (propertyKey === undefined) {\n\t\t\tif (isConstructor(target)) {\n\t\t\t\tif (!('class' in description)) throw new Error('Decorator cannot be applied to a class')\n\t\t\t\treturn description.class?.(target)\n\t\t\t}\n\t\t} else if (typeof target === 'object' && ['string', 'symbol'].includes(typeof propertyKey)) {\n\t\t\tif (!descriptor) throw new Error('Decorator cannot be applied to a field')\n\t\t\telse if (typeof descriptor === 'object' && 'configurable' in descriptor) {\n\t\t\t\tif ('get' in descriptor || 'set' in descriptor) {\n\t\t\t\t\tif (!('getter' in description || 'setter' in description))\n\t\t\t\t\t\tthrow new Error('Decorator cannot be applied to a getter or setter')\n\t\t\t\t\tif ('getter' in description) {\n\t\t\t\t\t\tconst newGetter = description.getter?.(descriptor.get, propertyKey)\n\t\t\t\t\t\tif (newGetter) descriptor.get = newGetter\n\t\t\t\t\t}\n\t\t\t\t\tif ('setter' in description) {\n\t\t\t\t\t\tconst newSetter = description.setter?.(descriptor.set, propertyKey)\n\t\t\t\t\t\tif (newSetter) descriptor.set = newSetter\n\t\t\t\t\t}\n\t\t\t\t\treturn descriptor\n\t\t\t\t} else if (typeof descriptor.value === 'function') {\n\t\t\t\t\tif (!('method' in description)) throw new Error('Decorator cannot be applied to a method')\n\t\t\t\t\tconst newMethod = description.method?.(descriptor.value, propertyKey)\n\t\t\t\t\tif (newMethod) descriptor.value = newMethod\n\t\t\t\t\treturn descriptor\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (!('default' in description))\n\t\t\tthrow new Error('Decorator do not have a default implementation')\n\t\treturn description.default.call(this, target, propertyKey, descriptor, ...args)\n\t}\n}\n\nexport function modernDecorator<T = any>(description: DecoratorDescription<T>): any {\n\treturn function (target: any, context?: DecoratorContext, ...args: any[]) {\n\t\tif (!context?.kind || typeof context.kind !== 'string') {\n\t\t\tif (!('default' in description))\n\t\t\t\tthrow new Error('Decorator do not have a default implementation')\n\t\t\treturn description.default.call(this, target, context, ...args)\n\t\t}\n\t\tswitch (context.kind) {\n\t\t\tcase 'class':\n\t\t\t\tif (!('class' in description)) throw new Error('Decorator cannot be applied to a class')\n\t\t\t\treturn description.class?.(target)\n\t\t\tcase 'field':\n\t\t\t\tthrow new Error('Decorator cannot be applied to a field')\n\t\t\tcase 'getter':\n\t\t\t\tif (!('getter' in description)) throw new Error('Decorator cannot be applied to a getter')\n\t\t\t\treturn description.getter?.(target, context.name)\n\t\t\tcase 'setter':\n\t\t\t\tif (!('setter' in description)) throw new Error('Decorator cannot be applied to a setter')\n\t\t\t\treturn description.setter?.(target, context.name)\n\t\t\tcase 'method':\n\t\t\t\tif (!('method' in description)) throw new Error('Decorator cannot be applied to a method')\n\t\t\t\treturn description.method?.(target, context.name)\n\t\t\tcase 'accessor': {\n\t\t\t\tif (!('getter' in description || 'setter' in description))\n\t\t\t\t\tthrow new Error('Decorator cannot be applied to a getter or setter')\n\t\t\t\tconst rv: Partial<ClassAccessorDecoratorResult<any, any>> = {}\n\t\t\t\tif ('getter' in description) {\n\t\t\t\t\tconst newGetter = description.getter?.(target.get, context.name)\n\t\t\t\t\tif (newGetter) rv.get = newGetter\n\t\t\t\t}\n\t\t\t\tif ('setter' in description) {\n\t\t\t\t\tconst newSetter = description.setter?.(target.set, context.name)\n\t\t\t\t\tif (newSetter) rv.set = newSetter\n\t\t\t\t}\n\t\t\t\treturn rv\n\t\t\t}\n\t\t\t//return description.accessor?.(target, context.name, target)\n\t\t}\n\t}\n}\n\n/**\n * Detects if the decorator is being called in modern (Modern) or legacy (Legacy) mode\n * based on the arguments passed to the decorator function\n */\nfunction detectDecoratorMode(\n\t_target: any,\n\tcontextOrKey?: any,\n\t_descriptor?: any\n): 'modern' | 'legacy' {\n\t// Modern decorators have a context object as the second parameter\n\t// Legacy decorators have a string/symbol key as the second parameter\n\tif (\n\t\ttypeof contextOrKey === 'object' &&\n\t\tcontextOrKey !== null &&\n\t\ttypeof contextOrKey.kind === 'string'\n\t) {\n\t\treturn 'modern'\n\t}\n\treturn 'legacy'\n}\n\nexport const decorator: DecoratorFactory<any> = (description: DecoratorDescription<any>) => {\n\treturn ((target: any, contextOrKey?: any, ...args: any[]) => {\n\t\tconst mode = detectDecoratorMode(target, contextOrKey, args[0])\n\t\treturn mode === 'modern'\n\t\t\t? modernDecorator(description)(target, contextOrKey, ...args)\n\t\t\t: legacyDecorator(description)(target, contextOrKey, ...args)\n\t}) as any\n}\n\nexport type GenericClassDecorator<T> = LegacyClassDecorator<new (...args: any[]) => T> &\n\tModernClassDecorator<new (...args: any[]) => T>\n"],"names":[],"mappings":"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"}