@v-ibe/core 0.1.0

package/dist/reactivity/decorators/effect.js

@@ -0,0 +1,24 @@
+import { effect } from "../signals/effect.js";
+function Effect(target, context) {
+  if (context.kind !== "method") {
+    throw new Error("@Effect solo se puede aplicar a métodos de clase.");
+  }
+  context.addInitializer(function() {
+    const userMethod = target;
+    const instance = this;
+    const effectRunner = (onCleanup) => {
+      userMethod.call(this, onCleanup);
+    };
+    const registerEffect = () => {
+      effect(effectRunner);
+    };
+    if (typeof instance.queueEffect === "function") {
+      instance.queueEffect(registerEffect);
+    } else {
+      queueMicrotask(registerEffect);
+    }
+  });
+}
+export {
+  Effect
+};

package/dist/reactivity/decorators/resource.d.ts

@@ -0,0 +1,48 @@
+import { IResource } from '../signals/resource';
+export declare const RESOURCE_PROPERTY_KEYS: unique symbol;
+/**
+ * Tipo para la función source que obtiene los datos del resource.
+ * Recibe un AbortSignal como primer parámetro que puede usarse para cancelar
+ * la operación si el resource necesita refetch antes de que complete.
+ */
+type ResourceSourceFn<Ctx extends object, T> = (this: Ctx, signal: AbortSignal) => Promise<T>;
+/**
+ * Metadata interna que guarda el framework sobre cada resource.
+ */
+export interface ResourceMetadata<T = any> {
+    key: string | symbol;
+    source: ResourceSourceFn<any, T>;
+}
+/**
+ * Decorador @Resource para crear propiedades reactivas que cargan datos asíncronos.
+ *
+ * La función source recibe un AbortSignal como primer parámetro que debe pasarse
+ * a cualquier operación asíncrona que soporte cancelación. Esto permite que el
+ * framework cancele automáticamente operaciones obsoletas cuando las dependencias
+ * del resource cambian.
+ *
+ * @example
+ * // Resource con fetch cancelable
+ * @Resource((signal) =>
+ *   fetch('/api/user', { signal }).then(r => r.json())
+ * )
+ * userResource!: IResource<User>;
+ *
+ * @example
+ * // Resource que usa el signal en operaciones personalizadas
+ * @Resource((signal) => {
+ *   return new Promise((resolve, reject) => {
+ *     signal.addEventListener('abort', () => {
+ *       reject(new Error('Operation cancelled'));
+ *     });
+ *
+ *     // Tu lógica asíncrona aquí
+ *     fetchDataSomehow().then(resolve);
+ *   });
+ * })
+ * dataResource!: IResource<Data>;
+ *
+ * @param source Función que recibe un AbortSignal y retorna una Promise con los datos
+ */
+export declare function Resource<Ctx extends object, T>(source: ResourceSourceFn<Ctx, T>): (target: undefined, context: ClassFieldDecoratorContext<Ctx, IResource<T>>) => void;
+export {};

package/dist/reactivity/decorators/resource.js

@@ -0,0 +1,20 @@
+const RESOURCE_PROPERTY_KEYS = Symbol("ResourcePropertyKeys");
+function Resource(source) {
+  return function(target, context) {
+    if (context.kind !== "field") {
+      throw new Error(
+        "@Resource solo se puede aplicar a campos de clase."
+      );
+    }
+    const metadata = context.metadata;
+    metadata.resourceKeys ??= [];
+    metadata.resourceKeys.push({
+      key: context.name,
+      source
+    });
+  };
+}
+export {
+  RESOURCE_PROPERTY_KEYS,
+  Resource
+};

package/dist/reactivity/decorators/state.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @State es un decorador para campos de clase que los convierte en señales reactivas.
+ * Automáticamente detecta el tipo de valor y crea la señal apropiada:
+ * - Primitivos (string, number, boolean, etc.) → Signal
+ * - Objetos → CompositeSignal con Proxy para sintaxis nativa
+ * - Arrays → ReactiveArray con Proxy para sintaxis nativa
+ */
+export declare function State<This extends object, Value>(target: undefined, context: ClassFieldDecoratorContext<This, Value>): (this: This, initialValue: Value) => Value;

package/dist/reactivity/decorators/state.js

@@ -0,0 +1,68 @@
+import { Signal } from "../signals/signal.js";
+import { CompositeSignal } from "../signals/composite.js";
+import { ReactiveArray } from "../signals/reactive-array.js";
+import { createArrayProxy, createObjectProxy } from "../signals/reactive-proxy.js";
+function State(target, context) {
+  if (context.kind !== "field") {
+    throw new Error("@State solo se puede aplicar a campos de clase.");
+  }
+  const signalKey = Symbol(`signal_${String(context.name)}`);
+  const signalPropName = `$${String(context.name)}`;
+  return function(initialValue) {
+    let signal;
+    if (Array.isArray(initialValue)) {
+      signal = new ReactiveArray(initialValue);
+    } else if (initialValue !== null && typeof initialValue === "object") {
+      signal = new CompositeSignal(initialValue);
+    } else {
+      signal = new Signal(initialValue);
+    }
+    this[signalKey] = signal;
+    Object.defineProperty(this, context.name, {
+      get: () => {
+        const sig = this[signalKey];
+        if (sig instanceof ReactiveArray) {
+          return createArrayProxy(sig);
+        } else if (sig instanceof CompositeSignal) {
+          return createObjectProxy(sig);
+        } else if (sig instanceof Signal) {
+          return sig.get();
+        }
+        return sig;
+      },
+      set: (newValue) => {
+        const currentSig = this[signalKey];
+        if (Array.isArray(newValue)) {
+          if (currentSig instanceof ReactiveArray) {
+            this[signalKey] = new ReactiveArray(newValue);
+          } else {
+            this[signalKey] = new ReactiveArray(newValue);
+          }
+        } else if (newValue !== null && typeof newValue === "object") {
+          if (currentSig instanceof CompositeSignal) {
+            this[signalKey] = new CompositeSignal(newValue);
+          } else {
+            this[signalKey] = new CompositeSignal(newValue);
+          }
+        } else {
+          if (currentSig instanceof Signal && !(currentSig instanceof CompositeSignal) && !(currentSig instanceof ReactiveArray)) {
+            currentSig.set(newValue);
+          } else {
+            this[signalKey] = new Signal(newValue);
+          }
+        }
+      },
+      enumerable: true,
+      configurable: true
+    });
+    Object.defineProperty(this, signalPropName, {
+      get: () => this[signalKey],
+      enumerable: false,
+      configurable: true
+    });
+    return initialValue;
+  };
+}
+export {
+  State
+};

package/dist/reactivity/decorators/store.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @Store es un decorador para campos de clase que convierte un objeto o array
+ * en un "store" reactivo profundo. Cada propiedad del objeto se vuelve
+ * reactiva de forma granular.
+ */
+export declare function Store<This extends object, Value extends object>(target: undefined, context: ClassFieldDecoratorContext<This, Value>): (this: This, initialValue: Value) => Value;

package/dist/reactivity/decorators/store.js

@@ -0,0 +1,25 @@
+import { createStore } from "../signals/reactive-proxy.js";
+function Store(target, context) {
+  if (context.kind !== "field") {
+    throw new Error("@Store solo se puede aplicar a campos de clase.");
+  }
+  const storeKey = Symbol(`store_${String(context.name)}`);
+  return function(initialValue) {
+    const store = createStore(initialValue);
+    this[storeKey] = store;
+    Object.defineProperty(this, context.name, {
+      // El getter devuelve el store reactivo (el Proxy).
+      get: () => this[storeKey],
+      // El setter permite reemplazar el store completo por un nuevo objeto/array.
+      set: (newValue) => {
+        this[storeKey] = createStore(newValue);
+      },
+      enumerable: true,
+      configurable: true
+    });
+    return initialValue;
+  };
+}
+export {
+  Store
+};

package/dist/reactivity/phase-scheduler.d.ts

@@ -0,0 +1,81 @@
+import { Subscriber } from './types';
+/**
+ * Fases de ejecución del scheduler reactivo
+ */
+export declare enum Phase {
+    IDLE = 0,// No hay actualizaciones pendientes
+    COLLECT = 1,// Recolectando cambios (señales marcadas como dirty)
+    EXECUTE = 2,// Ejecutando effects
+    COMMIT = 3
+}
+/**
+ * PhaseScheduler Simplificado - Sistema reactivo basado en fases
+ *
+ * FILOSOFÍA:
+ * - Effects NO tienen dependencias entre sí
+ * - Effects solo LEEN signals y producen side effects
+ * - Transformaciones de datos se hacen con Computed signals
+ *
+ * Si parece que un effect depende de otro effect, falta un Computed signal intermedio.
+ *
+ * Ventajas sobre sistema de prioridades:
+ * - Elimina glitches mediante batching
+ * - Orden de ejecución predecible (insertion order)
+ * - Más simple y rápido (sin grafos ni ordenamiento topológico)
+ * - No hay "starvation" de procesos
+ *
+ * Ejemplo CORRECTO:
+ * ```typescript
+ * const a = new Signal(1);
+ * const b = computed(() => a.get() * 2);     // Computed, no effect
+ * const c = computed(() => b.get() + 10);    // Computed, no effect
+ * effect(() => console.log(c.get()));         // Effect solo lee
+ * ```
+ *
+ * Ejemplo INCORRECTO (anti-pattern):
+ * ```typescript
+ * effect(() => b.set(a.get() * 2));    // ❌ Effect modificando signal
+ * effect(() => c.set(b.get() + 10));   // ❌ Otro effect leyendo
+ * ```
+ */
+declare class PhaseScheduler {
+    private currentPhase;
+    private dirtyEffects;
+    private isFlushScheduled;
+    /**
+     * Marca un effect como dirty (necesita re-ejecutarse)
+     * FASE: COLLECT
+     */
+    schedule(effect: Subscriber): void;
+    /**
+     * Agenda la ejecución del ciclo de fases
+     */
+    private scheduleFlush;
+    /**
+     * Ejecuta el ciclo completo de fases
+     *
+     * Simple y directo:
+     * 1. COLLECT: Marcar effects como dirty (ya hecho en schedule())
+     * 2. EXECUTE: Ejecutar todos los effects dirty en orden
+     * 3. COMMIT: Limpiar
+     */
+    flush(): void;
+    /**
+     * Ejecuta un effect inmediatamente si está scheduled
+     * Útil para evitar lecturas de valores viejos (glitch-free reads)
+     */
+    runIfScheduled(effect: Subscriber): void;
+    /**
+     * Obtiene la fase actual (útil para debugging)
+     */
+    getCurrentPhase(): Phase;
+    /**
+     * Obtiene información del scheduler (útil para debugging)
+     */
+    getInfo(): {
+        dirtyEffects: number;
+        currentPhase: Phase;
+    };
+}
+export declare const phaseScheduler: PhaseScheduler;
+export {};

package/dist/reactivity/phase-scheduler.js

@@ -0,0 +1,88 @@
+class PhaseScheduler {
+  constructor() {
+    this.currentPhase = 0;
+    this.dirtyEffects = /* @__PURE__ */ new Set();
+    this.isFlushScheduled = false;
+  }
+  /**
+   * Marca un effect como dirty (necesita re-ejecutarse)
+   * FASE: COLLECT
+   */
+  schedule(effect) {
+    this.dirtyEffects.add(effect);
+    this.scheduleFlush();
+  }
+  /**
+   * Agenda la ejecución del ciclo de fases
+   */
+  scheduleFlush() {
+    if (!this.isFlushScheduled) {
+      this.isFlushScheduled = true;
+      queueMicrotask(() => this.flush());
+    }
+  }
+  /**
+   * Ejecuta el ciclo completo de fases
+   * 
+   * Simple y directo:
+   * 1. COLLECT: Marcar effects como dirty (ya hecho en schedule())
+   * 2. EXECUTE: Ejecutar todos los effects dirty en orden
+   * 3. COMMIT: Limpiar
+   */
+  flush() {
+    this.isFlushScheduled = false;
+    if (this.dirtyEffects.size === 0) {
+      this.currentPhase = 0;
+      return;
+    }
+    this.currentPhase = 1;
+    const effectsToRun = Array.from(this.dirtyEffects);
+    this.dirtyEffects.clear();
+    this.currentPhase = 2;
+    effectsToRun.forEach((effect) => {
+      try {
+        effect();
+      } catch (error) {
+        console.error("Error executing effect:", error);
+      }
+    });
+    this.currentPhase = 3;
+    if (this.dirtyEffects.size > 0) {
+      this.scheduleFlush();
+    }
+    this.currentPhase = 0;
+  }
+  /**
+   * Ejecuta un effect inmediatamente si está scheduled
+   * Útil para evitar lecturas de valores viejos (glitch-free reads)
+   */
+  runIfScheduled(effect) {
+    if (this.dirtyEffects.has(effect)) {
+      this.dirtyEffects.delete(effect);
+      try {
+        effect();
+      } catch (error) {
+        console.error("Error executing effect:", error);
+      }
+    }
+  }
+  /**
+   * Obtiene la fase actual (útil para debugging)
+   */
+  getCurrentPhase() {
+    return this.currentPhase;
+  }
+  /**
+   * Obtiene información del scheduler (útil para debugging)
+   */
+  getInfo() {
+    return {
+      dirtyEffects: this.dirtyEffects.size,
+      currentPhase: this.currentPhase
+    };
+  }
+}
+const phaseScheduler = new PhaseScheduler();
+export {
+  phaseScheduler
+};

package/dist/reactivity/phase-scheduler.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/reactivity/reactive-cache.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Obtiene o crea una versión reactiva de un valor
+ *
+ * REGLAS:
+ * - Valores primitivos → se devuelven tal cual
+ * - Objetos → se envuelven en CompositeSignal
+ * - Arrays → se envuelven en ReactiveArray
+ * - Objetos especiales (Date, RegExp, etc.) → se devuelven tal cual
+ * - Instancias ya reactivas → se devuelven tal cual
+ *
+ * Usa un caché global para garantizar que el mismo objeto/array
+ * siempre devuelve la misma instancia reactiva.
+ */
+export declare function getOrCreateReactive<T>(value: T): T;
+/**
+ * Limpia el caché (útil para testing)
+ * Nota: WeakMap no tiene método clear(), así que esta función
+ * es principalmente documentativa. El GC limpiará automáticamente
+ * las entradas cuando los objetos originales sean recolectados.
+ */
+export declare function clearReactiveCache(): void;

package/dist/reactivity/reactive-cache.js

@@ -0,0 +1,31 @@
+import { CompositeSignal } from "./signals/composite.js";
+import { ReactiveArray } from "./signals/reactive-array.js";
+const reactiveCache = /* @__PURE__ */ new WeakMap();
+function getOrCreateReactive(value) {
+  if (value instanceof CompositeSignal || value instanceof ReactiveArray) {
+    return value;
+  }
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  const cached = reactiveCache.get(value);
+  if (cached) {
+    return cached;
+  }
+  let reactive;
+  if (Array.isArray(value)) {
+    reactive = new ReactiveArray(value);
+  } else if (isWrappableObject(value)) {
+    reactive = new CompositeSignal(value);
+  } else {
+    return value;
+  }
+  reactiveCache.set(value, reactive);
+  return reactive;
+}
+function isWrappableObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof RegExp) && !(value instanceof Map) && !(value instanceof Set) && !(value instanceof CompositeSignal) && !(value instanceof ReactiveArray);
+}
+export {
+  getOrCreateReactive
+};

package/dist/reactivity/reactive-cache.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/reactivity/reactive-context.d.ts

@@ -0,0 +1,152 @@
+import { Subscriber } from './types';
+export type OnTrackCallback = (signal: any) => void;
+/**
+ * ReactiveFrame - Representa un nivel en el stack de contextos reactivos
+ *
+ * Cada frame contiene toda la información necesaria para ese contexto:
+ * - computation: El subscriber (effect/computed) que debe recibir suscripciones
+ * - tracking: Si el tracking está activo (lecturas de signals crean suscripciones)
+ * - type: El tipo de contexto (para debugging y semántica)
+ */
+export interface ReactiveFrame {
+    computation: Subscriber | null;
+    tracking: boolean;
+    type: 'effect' | 'computed' | 'untrack' | 'batch' | 'legacy';
+}
+/**
+ * ReactiveContext - Gestiona el contexto reactivo usando un STACK UNIFICADO
+ *
+ * ARQUITECTURA (POST-FIX):
+ * - Un solo stack que contiene todo el estado de contexto
+ * - Cada operación (effect, computed, untrack) push/pop un frame
+ * - Elimina la ambigüedad de dos stacks con prioridades conflictivas
+ * - Garantiza que effects anidados dentro de untrack tengan su propio contexto
+ *
+ * PROBLEMA QUE RESUELVE:
+ * El sistema anterior tenía dos stacks (computationStack y contextStack)
+ * donde contextStack tenía prioridad. Esto causaba que effects creados
+ * dentro de untrack() usaran la computation del padre en lugar de la propia.
+ */
+declare class ReactiveContext {
+    /**
+     * Stack unificado de contextos reactivos
+     * El último frame (top) es siempre el contexto actual
+     */
+    private stack;
+    onTrack: OnTrackCallback | null;
+    /**
+     * Entra a un nuevo contexto reactivo.
+     * Retorna una función para salir del contexto (dispose).
+     *
+     * @param computation - El subscriber que recibirá suscripciones
+     * @param tracking - Si el tracking está activo
+     * @param type - Tipo de contexto (para debugging)
+     * @returns Función dispose para salir del contexto
+     *
+     * @example
+     * const exit = reactiveContext.enter(computation, true, 'effect');
+     * try {
+     *   // código reactivo...
+     * } finally {
+     *   exit();
+     * }
+     */
+    enter(computation: Subscriber | null, tracking: boolean, type: ReactiveFrame['type']): () => void;
+    /**
+     * Sale del contexto actual (pop del stack)
+     *
+     * NOTA: No lanza error si el stack está vacío.
+     * Esto es intencional para manejar casos donde:
+     * 1. Tests limpian el stack manualmente
+     * 2. Async effects intentan cerrar contexto después de cleanup
+     */
+    exit(): void;
+    /**
+     * Obtiene la computación actual del contexto.
+     * Si hay un frame en el stack, retorna su computation.
+     * Si el stack está vacío, retorna null.
+     */
+    get currentComputation(): Subscriber | null;
+    /**
+     * Obtiene el estado de tracking actual.
+     * Si hay un frame en el stack, retorna su tracking.
+     * Si el stack está vacío, retorna false (no tracking por defecto).
+     */
+    get isTracking(): boolean;
+    /**
+     * Ejecuta una función sin tracking.
+     * Útil para operaciones que no deben crear suscripciones.
+     *
+     * @param fn - Función a ejecutar sin tracking
+     * @returns El resultado de la función
+     */
+    untrack<T>(fn: () => T): T;
+    /**
+     * @deprecated Usar enter() en su lugar
+     * Push un contexto al stack (para compatibilidad)
+     */
+    pushContext(computation: Subscriber | null, tracking: boolean): void;
+    /**
+     * @deprecated Usar exit() en su lugar
+     * Pop del stack (para compatibilidad)
+     * @throws Error si el stack está vacío (para compatibilidad con tests)
+     */
+    popContext(): void;
+    /**
+     * @deprecated Usar enter() en su lugar
+     * Agrega una computation al contexto (para compatibilidad con computed.ts)
+     */
+    pushComputation(comp: Subscriber): void;
+    /**
+     * @deprecated El sistema unificado no necesita esto
+     * Intenta remover una computation (no-op en el nuevo sistema)
+     * Nota: En el sistema unificado, el context se maneja via push/pop,
+     * no necesitamos remover computaciones específicas.
+     */
+    removeComputation(computationToRemove: Subscriber): void;
+    /**
+     * @deprecated Usar enter() con tracking específico
+     * Modifica el tracking del frame actual (para compatibilidad)
+     */
+    setTracking(tracking: boolean): void;
+    /**
+     * @internal - Solo para testing
+     * Obtiene el tamaño del stack
+     */
+    getContextStackSize(): number;
+    /**
+     * @internal - Solo para testing/compatibilidad
+     * En el sistema unificado, esto es equivalente a getContextStackSize
+     */
+    getComputationStackSize(): number;
+    /**
+     * @internal - Solo para testing/debugging
+     * Obtiene una copia del stack actual (para inspección)
+     */
+    getStackSnapshot(): ReactiveFrame[];
+    /**
+     * @internal - Solo para testing
+     * Limpia completamente el stack (útil en beforeEach de tests)
+     */
+    clearStack(): void;
+    /**
+     * @internal - Solo para compatibilidad con tests existentes
+     * Getter/setter para simular el computationStack antiguo
+     */
+    get computationStack(): Subscriber[];
+    set computationStack(value: Subscriber[]);
+    /**
+     * @internal - Solo para compatibilidad con tests existentes
+     * Getter/setter para simular el contextStack antiguo
+     */
+    get contextStack(): Array<{
+        computation: Subscriber | null;
+        tracking: boolean;
+    }>;
+    set contextStack(value: Array<{
+        computation: Subscriber | null;
+        tracking: boolean;
+    }>);
+}
+export declare const reactiveContext: ReactiveContext;
+export {};