@v-ibe/core 0.1.0

package/dist/reactivity/reactive-context.js

@@ -0,0 +1,184 @@
+class ReactiveContext {
+  constructor() {
+    this.stack = [];
+    this.onTrack = null;
+  }
+  // --- API Principal (Nueva) ---
+  /**
+   * 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, tracking, type) {
+    this.stack.push({ computation, tracking, type });
+    let disposed = false;
+    return () => {
+      if (!disposed) {
+        disposed = true;
+        this.exit();
+      }
+    };
+  }
+  /**
+   * 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() {
+    if (this.stack.length === 0) {
+      return;
+    }
+    this.stack.pop();
+  }
+  // --- Getters Principales ---
+  /**
+   * 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() {
+    if (this.stack.length === 0) {
+      return null;
+    }
+    return this.stack[this.stack.length - 1].computation;
+  }
+  /**
+   * 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() {
+    if (this.stack.length === 0) {
+      return false;
+    }
+    return this.stack[this.stack.length - 1].tracking;
+  }
+  // --- Método Utilitario ---
+  /**
+   * 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(fn) {
+    const exit = this.enter(this.currentComputation, false, "untrack");
+    try {
+      return fn();
+    } finally {
+      exit();
+    }
+  }
+  // --- API de Compatibilidad (Deprecated pero funcional) ---
+  /**
+   * @deprecated Usar enter() en su lugar
+   * Push un contexto al stack (para compatibilidad)
+   */
+  pushContext(computation, tracking) {
+    this.stack.push({ computation, tracking, type: "legacy" });
+  }
+  /**
+   * @deprecated Usar exit() en su lugar
+   * Pop del stack (para compatibilidad)
+   * @throws Error si el stack está vacío (para compatibilidad con tests)
+   */
+  popContext() {
+    if (this.stack.length === 0) {
+      throw new Error("Cannot pop context: stack is empty");
+    }
+    this.stack.pop();
+  }
+  /**
+   * @deprecated Usar enter() en su lugar
+   * Agrega una computation al contexto (para compatibilidad con computed.ts)
+   */
+  pushComputation(comp) {
+    this.stack.push({ computation: comp, tracking: true, type: "computed" });
+  }
+  /**
+   * @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) {
+  }
+  /**
+   * @deprecated Usar enter() con tracking específico
+   * Modifica el tracking del frame actual (para compatibilidad)
+   */
+  setTracking(tracking) {
+    if (this.stack.length > 0) {
+      this.stack[this.stack.length - 1].tracking = tracking;
+    }
+  }
+  // --- Métodos de Debug/Testing ---
+  /**
+   * @internal - Solo para testing
+   * Obtiene el tamaño del stack
+   */
+  getContextStackSize() {
+    return this.stack.length;
+  }
+  /**
+   * @internal - Solo para testing/compatibilidad
+   * En el sistema unificado, esto es equivalente a getContextStackSize
+   */
+  getComputationStackSize() {
+    return this.stack.length;
+  }
+  /**
+   * @internal - Solo para testing/debugging
+   * Obtiene una copia del stack actual (para inspección)
+   */
+  getStackSnapshot() {
+    return [...this.stack];
+  }
+  /**
+   * @internal - Solo para testing
+   * Limpia completamente el stack (útil en beforeEach de tests)
+   */
+  clearStack() {
+    this.stack = [];
+  }
+  // --- Compatibilidad con tests que acceden a propiedades privadas ---
+  /**
+   * @internal - Solo para compatibilidad con tests existentes
+   * Getter/setter para simular el computationStack antiguo
+   */
+  get computationStack() {
+    return this.stack.filter((f) => f.computation !== null).map((f) => f.computation);
+  }
+  set computationStack(value) {
+    this.stack = [];
+  }
+  /**
+   * @internal - Solo para compatibilidad con tests existentes
+   * Getter/setter para simular el contextStack antiguo
+   */
+  get contextStack() {
+    return this.stack.map((f) => ({ computation: f.computation, tracking: f.tracking }));
+  }
+  set contextStack(value) {
+    this.stack = [];
+  }
+}
+const reactiveContext = new ReactiveContext();
+export {
+  reactiveContext
+};

package/dist/reactivity/signals/__tests__/composicion-automatica.test.d.ts

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

package/dist/reactivity/signals/__tests__/composite/nivel-1-estructura-basica.test.d.ts

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

package/dist/reactivity/signals/__tests__/composite/nivel-2-registro-subscribers.test.d.ts

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

package/dist/reactivity/signals/__tests__/composite/nivel-3-notificaciones-basicas.test.d.ts

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

package/dist/reactivity/signals/__tests__/composite/nivel-4-comparacion-valores.test.d.ts

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

package/dist/reactivity/signals/__tests__/composite/nivel-5-tracking-automatico.test.d.ts

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

package/dist/reactivity/signals/__tests__/composite/nivel-6-anti-glitch.test.d.ts

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

package/dist/reactivity/signals/__tests__/composite/nivel-7-objetos-anidados.test.d.ts

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

package/dist/reactivity/signals/__tests__/composite/nivel-8-observable-array-support.test.d.ts

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

package/dist/reactivity/signals/__tests__/composite-shallow-tracking.test.d.ts

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

package/dist/reactivity/signals/__tests__/effect.test.d.ts

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

package/dist/reactivity/signals/__tests__/reactive-array/nivel-1-estructura-basica.test.d.ts

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

package/dist/reactivity/signals/__tests__/reactive-array/nivel-2-metodos-mutadores.test.d.ts

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

package/dist/reactivity/signals/__tests__/reactive-array/nivel-3-tracking-por-indice.test.d.ts

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

package/dist/reactivity/signals/__tests__/reactive-array/nivel-4-tracking-length.test.d.ts

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

package/dist/reactivity/signals/__tests__/reactive-array/nivel-5-tracking-mutation.test.d.ts

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

package/dist/reactivity/signals/__tests__/reactive-array/nivel-6-metodos-no-mutadores.test.d.ts

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

package/dist/reactivity/signals/__tests__/reactive-array/nivel-7-composicion-bidireccional.test.d.ts

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

package/dist/reactivity/signals/__tests__/reactive-array/nivel-8-proxies.test.d.ts

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

package/dist/reactivity/signals/__tests__/reactive-array/nivel-9-derived-cache-optimization.test.d.ts

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

package/dist/reactivity/signals/__tests__/resource.test.d.ts

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

package/dist/reactivity/signals/__tests__/signal.test.d.ts

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

package/dist/reactivity/signals/array-strategies.d.ts

@@ -0,0 +1,120 @@
+import { ReactiveArray } from './reactive-array.js';
+/**
+ * Estrategia interna para manejar el acceso a elementos
+ * Permite que ReactiveArray funcione tanto con datos propios como derivados
+ */
+export interface ArrayStrategy<T> {
+    getLength(): number;
+    getAt(index: number): T | undefined;
+    getItems(): T[];
+    isOwned(): boolean;
+}
+/**
+ * Estrategia normal: array con datos propios que pueden ser mutados
+ * Envuelve automáticamente objetos y arrays con getOrCreateReactive para composición bidireccional
+ */
+export declare class OwnedArrayStrategy<T> implements ArrayStrategy<T> {
+    private items;
+    constructor(items: T[]);
+    getLength(): number;
+    getAt(index: number): T | undefined;
+    getItems(): T[];
+    isOwned(): boolean;
+    push(...items: T[]): number;
+    pop(): T | undefined;
+    shift(): T | undefined;
+    unshift(...items: T[]): number;
+    splice(start: number, deleteCount?: number, ...items: T[]): T[];
+    sort(compareFn?: (a: T, b: T) => number): void;
+    reverse(): void;
+    fill(value: T, start?: number, end?: number): void;
+}
+/**
+ * Estrategia derivada: array que computa sus valores desde otro array
+ * Implementa memoización granular por elemento
+ *
+ * El truco clave aquí es que cada elemento tiene su propio subscriber,
+ * entonces cuando se transforma un elemento, registramos qué propiedades
+ * del objeto fuente se leyeron. Solo invalidamos el caché del elemento
+ * si esas propiedades específicas cambian.
+ *
+ * OPTIMIZACIÓN DE CACHÉ:
+ * - push: NO limpia el caché, solo marca que hay nuevos elementos
+ * - pop: Solo remueve el último elemento del caché
+ * - Otras operaciones: Comportamiento conservador (limpia caché afectado)
+ */
+export declare class DerivedArrayStrategy<TSource, TResult> implements ArrayStrategy<TResult> {
+    private notifyChange;
+    private sourceArray;
+    private transformFn;
+    private cache;
+    private elementSubscribers;
+    private structurallyInvalid;
+    private knownSourceLength;
+    constructor(sourceArray: ReactiveArray<TSource>, transformFn: (value: TSource, index: number) => TResult, notifyChange: () => void);
+    /**
+     * Configura el tracking para cambios estructurales (longitud y mutation)
+     *
+     * Usa DOS mecanismos:
+     * 1. onChange() para saber qué tipo de operación y optimizar el caché
+     * 2. Suscripción reactiva a 'mutation' para disparar re-ejecución de effects externos
+     */
+    private setupSourceTracking;
+    /**
+     * Maneja cambios del array fuente de forma inteligente según la operación
+     */
+    private handleSourceChange;
+    /**
+     * Invalida todo el caché (comportamiento conservador)
+     */
+    private invalidateAll;
+    getLength(): number;
+    /**
+     * Este es el método más importante: obtiene un elemento con memoización granular
+     *
+     * La magia sucede aquí:
+     * 1. Si el elemento está en caché y no hay invalidación estructural, lo devuelve
+     * 2. Si no, ejecuta la transformación en un contexto de tracking
+     * 3. Las propiedades accedidas durante la transformación se registran
+     * 4. Solo si esas propiedades específicas cambian, se invalida el caché
+     */
+    getAt(index: number): TResult | undefined;
+    getItems(): TResult[];
+    isOwned(): boolean;
+}
+/**
+ * Estrategia derivada para arrays filtrados
+ * Mantiene una relación entre índices filtrados y fuente
+ *
+ * La complejidad aquí es que los índices no son lineales:
+ * - filtered[0] podría corresponder a source[2]
+ * - filtered[1] podría corresponder a source[4]
+ *
+ * Esta estrategia mantiene dos mapeos:
+ * 1. sourceIndex -> filteredIndex (o -1 si no pasa el filtro)
+ * 2. filteredIndex -> sourceIndex
+ */
+export declare class FilteredArrayStrategy<T> implements ArrayStrategy<T> {
+    private notifyChange;
+    private sourceArray;
+    private predicateFn;
+    private filteredCache;
+    private sourceToFiltered;
+    private filteredToSource;
+    private elementSubscribers;
+    private structurallyInvalid;
+    private structuralSubscriber?;
+    constructor(sourceArray: ReactiveArray<T>, predicateFn: (value: T, index: number, array: T[]) => boolean, notifyChange: () => void);
+    /**
+     * Configura tracking para cambios estructurales y mutation
+     */
+    private setupSourceTracking;
+    /**
+     * Recalcula los mapeos y cache si es necesario
+     */
+    private recalculateIfNeeded;
+    getLength(): number;
+    getAt(index: number): T | undefined;
+    getItems(): T[];
+    isOwned(): boolean;
+}

package/dist/reactivity/signals/array-strategies.js

@@ -0,0 +1,261 @@
+import { withContext } from "../context-scope.js";
+import { getOrCreateReactive } from "../reactive-cache.js";
+class OwnedArrayStrategy {
+  constructor(items) {
+    this.items = items;
+    this.items = items.map((item) => getOrCreateReactive(item));
+  }
+  getLength() {
+    return this.items.length;
+  }
+  getAt(index) {
+    const normalized = index < 0 ? this.items.length + index : index;
+    return this.items[normalized];
+  }
+  getItems() {
+    return this.items;
+  }
+  isOwned() {
+    return true;
+  }
+  // CLAVE: Envolver elementos automáticamente en todas las mutaciones
+  push(...items) {
+    const wrappedItems = items.map((item) => getOrCreateReactive(item));
+    return this.items.push(...wrappedItems);
+  }
+  pop() {
+    return this.items.pop();
+  }
+  shift() {
+    return this.items.shift();
+  }
+  unshift(...items) {
+    const wrappedItems = items.map((item) => getOrCreateReactive(item));
+    return this.items.unshift(...wrappedItems);
+  }
+  splice(start, deleteCount, ...items) {
+    const wrappedItems = items.map((item) => getOrCreateReactive(item));
+    return this.items.splice(start, deleteCount ?? this.items.length - start, ...wrappedItems);
+  }
+  sort(compareFn) {
+    this.items.sort(compareFn);
+  }
+  reverse() {
+    this.items.reverse();
+  }
+  fill(value, start, end) {
+    const wrappedValue = getOrCreateReactive(value);
+    this.items.fill(wrappedValue, start, end);
+  }
+}
+class DerivedArrayStrategy {
+  constructor(sourceArray, transformFn, notifyChange) {
+    this.notifyChange = notifyChange;
+    this.cache = /* @__PURE__ */ new Map();
+    this.elementSubscribers = /* @__PURE__ */ new Map();
+    this.structurallyInvalid = true;
+    this.knownSourceLength = 0;
+    this.sourceArray = sourceArray;
+    this.transformFn = transformFn;
+    this.setupSourceTracking();
+  }
+  /**
+   * Configura el tracking para cambios estructurales (longitud y mutation)
+   * 
+   * Usa DOS mecanismos:
+   * 1. onChange() para saber qué tipo de operación y optimizar el caché
+   * 2. Suscripción reactiva a 'mutation' para disparar re-ejecución de effects externos
+   */
+  setupSourceTracking() {
+    this.sourceArray.onChange((operation, ...args) => {
+      this.handleSourceChange(operation, args);
+    });
+    const reactiveSubscriber = () => {
+      this.notifyChange();
+    };
+    reactiveSubscriber._isComputation = true;
+    this.sourceArray._subscribe("mutation", reactiveSubscriber);
+    this.knownSourceLength = this.sourceArray.length;
+  }
+  /**
+   * Maneja cambios del array fuente de forma inteligente según la operación
+   */
+  handleSourceChange(operation, args) {
+    const newLength = this.sourceArray.length;
+    switch (operation) {
+      case "push":
+        this.knownSourceLength = newLength;
+        break;
+      case "pop":
+        const removedIndex = this.knownSourceLength - 1;
+        if (removedIndex >= 0) {
+          this.cache.delete(removedIndex);
+          this.elementSubscribers.delete(removedIndex);
+        }
+        this.knownSourceLength = newLength;
+        break;
+      case "shift":
+      case "unshift":
+      case "splice":
+      case "sort":
+      case "reverse":
+      case "fill":
+        this.invalidateAll();
+        this.knownSourceLength = newLength;
+        break;
+      default:
+        this.invalidateAll();
+        this.knownSourceLength = newLength;
+        break;
+    }
+  }
+  /**
+   * Invalida todo el caché (comportamiento conservador)
+   */
+  invalidateAll() {
+    this.structurallyInvalid = true;
+    this.cache.clear();
+    this.elementSubscribers.clear();
+  }
+  getLength() {
+    return this.sourceArray.length;
+  }
+  /**
+   * Este es el método más importante: obtiene un elemento con memoización granular
+   * 
+   * La magia sucede aquí:
+   * 1. Si el elemento está en caché y no hay invalidación estructural, lo devuelve
+   * 2. Si no, ejecuta la transformación en un contexto de tracking
+   * 3. Las propiedades accedidas durante la transformación se registran
+   * 4. Solo si esas propiedades específicas cambian, se invalida el caché
+   */
+  getAt(index) {
+    const normalized = index < 0 ? this.getLength() + index : index;
+    if (normalized < 0 || normalized >= this.getLength()) {
+      return void 0;
+    }
+    if (!this.structurallyInvalid && this.cache.has(normalized)) {
+      return this.cache.get(normalized);
+    }
+    if (!this.elementSubscribers.has(normalized)) {
+      const elementSubscriber = () => {
+        this.cache.delete(normalized);
+        this.notifyChange();
+      };
+      elementSubscriber._isComputation = true;
+      this.elementSubscribers.set(normalized, elementSubscriber);
+    }
+    return withContext(this.elementSubscribers.get(normalized), true, () => {
+      const sourceElement = this.sourceArray.at(normalized);
+      const result = this.transformFn(sourceElement, normalized);
+      this.cache.set(normalized, result);
+      this.structurallyInvalid = false;
+      return result;
+    });
+  }
+  getItems() {
+    const length = this.getLength();
+    const result = [];
+    for (let i = 0; i < length; i++) {
+      const item = this.getAt(i);
+      result.push(item);
+    }
+    return result;
+  }
+  isOwned() {
+    return false;
+  }
+}
+class FilteredArrayStrategy {
+  constructor(sourceArray, predicateFn, notifyChange) {
+    this.notifyChange = notifyChange;
+    this.filteredCache = [];
+    this.sourceToFiltered = /* @__PURE__ */ new Map();
+    this.filteredToSource = /* @__PURE__ */ new Map();
+    this.elementSubscribers = /* @__PURE__ */ new Map();
+    this.structurallyInvalid = true;
+    this.sourceArray = sourceArray;
+    this.predicateFn = predicateFn;
+    this.setupSourceTracking();
+  }
+  /**
+   * Configura tracking para cambios estructurales y mutation
+   */
+  setupSourceTracking() {
+    const structuralSubscriber = () => {
+      this.structurallyInvalid = true;
+      this.filteredCache = [];
+      this.sourceToFiltered.clear();
+      this.filteredToSource.clear();
+      this.elementSubscribers.clear();
+      this.notifyChange();
+    };
+    structuralSubscriber._isComputation = true;
+    this.structuralSubscriber = structuralSubscriber;
+    withContext(structuralSubscriber, true, () => {
+      void this.sourceArray.length;
+      this.sourceArray._subscribe("mutation", structuralSubscriber);
+    });
+  }
+  /**
+   * Recalcula los mapeos y cache si es necesario
+   */
+  recalculateIfNeeded() {
+    if (!this.structurallyInvalid && this.filteredCache.length > 0) {
+      return;
+    }
+    this.filteredCache = [];
+    this.sourceToFiltered.clear();
+    this.filteredToSource.clear();
+    const sourceLength = this.sourceArray.length;
+    let filteredIndex = 0;
+    for (let sourceIndex = 0; sourceIndex < sourceLength; sourceIndex++) {
+      if (!this.elementSubscribers.has(sourceIndex)) {
+        const elementSubscriber = () => {
+          this.structurallyInvalid = true;
+          this.notifyChange();
+        };
+        elementSubscriber._isComputation = true;
+        this.elementSubscribers.set(sourceIndex, elementSubscriber);
+      }
+      withContext(this.elementSubscribers.get(sourceIndex), true, () => {
+        const sourceElement = this.sourceArray.at(sourceIndex);
+        const sourceItems = this.sourceArray.getPlainValue();
+        const passesFilter = this.predicateFn(sourceElement, sourceIndex, sourceItems);
+        if (passesFilter) {
+          this.filteredCache.push(sourceElement);
+          this.sourceToFiltered.set(sourceIndex, filteredIndex);
+          this.filteredToSource.set(filteredIndex, sourceIndex);
+          filteredIndex++;
+        } else {
+          this.sourceToFiltered.set(sourceIndex, -1);
+        }
+      });
+    }
+    this.structurallyInvalid = false;
+  }
+  getLength() {
+    this.recalculateIfNeeded();
+    return this.filteredCache.length;
+  }
+  getAt(index) {
+    this.recalculateIfNeeded();
+    const normalized = index < 0 ? this.filteredCache.length + index : index;
+    if (normalized < 0 || normalized >= this.filteredCache.length) {
+      return void 0;
+    }
+    return this.filteredCache[normalized];
+  }
+  getItems() {
+    this.recalculateIfNeeded();
+    return [...this.filteredCache];
+  }
+  isOwned() {
+    return false;
+  }
+}
+export {
+  DerivedArrayStrategy,
+  FilteredArrayStrategy,
+  OwnedArrayStrategy
+};