@v-ibe/core 0.1.0

package/dist/reactivity/signals/reactive-proxy.js

@@ -0,0 +1,299 @@
+import { CompositeSignal } from "./composite.js";
+import { ReactiveArray } from "./reactive-array.js";
+import { getOrCreateReactive } from "../reactive-cache.js";
+const proxyCache = /* @__PURE__ */ new WeakMap();
+function createObjectProxy(composite) {
+  if (proxyCache.has(composite)) {
+    return proxyCache.get(composite);
+  }
+  const proxy = new Proxy(composite, {
+    get(target, prop) {
+      if (prop === "__isReactive") return true;
+      if (prop === "__getCompositeSignal") return composite;
+      if (typeof prop === "symbol") {
+        return target[prop];
+      }
+      const value = composite.get(prop);
+      if (value instanceof CompositeSignal) {
+        return createObjectProxy(value);
+      }
+      if (value instanceof ReactiveArray) {
+        return createArrayProxy(value);
+      }
+      return value;
+    },
+    set(target, prop, value) {
+      if (typeof prop === "symbol") {
+        target[prop] = value;
+        return true;
+      }
+      const reactiveValue = getOrCreateReactive(value);
+      composite.set(prop, reactiveValue);
+      return true;
+    },
+    has(target, prop) {
+      if (prop === "__isReactive" || prop === "__getCompositeSignal") return true;
+      if (typeof prop === "symbol") return prop in target;
+      return composite.get(prop) !== void 0;
+    },
+    ownKeys(target) {
+      composite.trackShallow();
+      const plainValue = composite.getPlainValue();
+      return Reflect.ownKeys(plainValue);
+    },
+    getOwnPropertyDescriptor(target, prop) {
+      if (prop === "__isReactive" || prop === "__getCompositeSignal") {
+        return {
+          configurable: true,
+          enumerable: false,
+          value: prop === "__isReactive" ? true : composite,
+          writable: false
+        };
+      }
+      if (typeof prop === "symbol") {
+        return Object.getOwnPropertyDescriptor(target, prop);
+      }
+      const plainValue = composite.getPlainValue();
+      if (!(prop in plainValue)) return void 0;
+      return {
+        configurable: true,
+        enumerable: true,
+        writable: true,
+        value: this.get(target, prop, proxy)
+      };
+    },
+    deleteProperty(target, prop) {
+      if (typeof prop === "symbol") {
+        return delete target[prop];
+      }
+      const plainValue = composite.getPlainValue();
+      if (!(prop in plainValue)) {
+        return true;
+      }
+      const deleted = delete plainValue[prop];
+      if (deleted) {
+        composite.set(prop, void 0);
+      }
+      return deleted;
+    }
+  });
+  proxyCache.set(composite, proxy);
+  return proxy;
+}
+function createArrayProxy(reactiveArray) {
+  if (proxyCache.has(reactiveArray)) {
+    return proxyCache.get(reactiveArray);
+  }
+  const proxy = new Proxy(reactiveArray, {
+    get(target, prop) {
+      if (prop === "__isReactive") return true;
+      if (prop === "__getReactiveArray") return reactiveArray;
+      if (typeof prop === "symbol") {
+        if (prop === Symbol.iterator) {
+          const iterator = reactiveArray[Symbol.iterator]();
+          return function* () {
+            for (const value2 of iterator) {
+              if (value2 instanceof CompositeSignal) {
+                yield createObjectProxy(value2);
+              } else if (value2 instanceof ReactiveArray) {
+                yield createArrayProxy(value2);
+              } else {
+                yield value2;
+              }
+            }
+          };
+        }
+        const value = target[prop];
+        if (typeof value === "function") {
+          return value.bind(target);
+        }
+        return value;
+      }
+      if (prop === "length") {
+        return reactiveArray.length;
+      }
+      const methodNames = [
+        "push",
+        "pop",
+        "shift",
+        "unshift",
+        "splice",
+        "sort",
+        "reverse",
+        "fill",
+        "map",
+        "filter",
+        "reduce",
+        "reduceRight",
+        "find",
+        "findIndex",
+        "indexOf",
+        "lastIndexOf",
+        "some",
+        "every",
+        "forEach",
+        "slice",
+        "concat",
+        "join",
+        "includes",
+        "at",
+        "entries",
+        "keys",
+        "values"
+      ];
+      if (methodNames.includes(prop)) {
+        const method = target[prop];
+        if (typeof method === "function") {
+          return function(...args) {
+            const callbackMethods = ["map", "filter", "find", "findIndex", "some", "every", "forEach", "reduce", "reduceRight"];
+            if (callbackMethods.includes(prop) && typeof args[0] === "function") {
+              const originalCallback = args[0];
+              const wrappedCallback = function(...callbackArgs) {
+                const wrappedArgs = callbackArgs.map((arg, index2) => {
+                  if (index2 === 0) {
+                    if (arg instanceof CompositeSignal) {
+                      return createObjectProxy(arg);
+                    }
+                    if (arg instanceof ReactiveArray) {
+                      return createArrayProxy(arg);
+                    }
+                  }
+                  return arg;
+                });
+                return originalCallback.apply(this, wrappedArgs);
+              };
+              args = [wrappedCallback, ...args.slice(1)];
+            }
+            const result = method.apply(target, args);
+            if (result instanceof ReactiveArray) {
+              return createArrayProxy(result);
+            }
+            if (Array.isArray(result)) {
+              return result.map((item) => {
+                if (item instanceof CompositeSignal) {
+                  return createObjectProxy(item);
+                }
+                if (item instanceof ReactiveArray) {
+                  return createArrayProxy(item);
+                }
+                return item;
+              });
+            }
+            if (result instanceof CompositeSignal) {
+              return createObjectProxy(result);
+            }
+            if (result instanceof ReactiveArray) {
+              return createArrayProxy(result);
+            }
+            return result;
+          };
+        }
+      }
+      const index = Number(prop);
+      if (!isNaN(index) && index >= 0 && Number.isInteger(index)) {
+        const value = reactiveArray.at(index);
+        if (value instanceof CompositeSignal) {
+          return createObjectProxy(value);
+        }
+        if (value instanceof ReactiveArray) {
+          return createArrayProxy(value);
+        }
+        return value;
+      }
+      return target[prop];
+    },
+    set(target, prop, value) {
+      if (typeof prop === "symbol") {
+        target[prop] = value;
+        return true;
+      }
+      if (prop === "length") {
+        const newLength = Number(value);
+        if (!isNaN(newLength) && newLength >= 0 && Number.isInteger(newLength)) {
+          const currentLength = reactiveArray.length;
+          if (newLength < currentLength) {
+            reactiveArray.splice(newLength, currentLength - newLength);
+          }
+        }
+        return true;
+      }
+      const index = Number(prop);
+      if (!isNaN(index) && index >= 0 && Number.isInteger(index)) {
+        const reactiveValue = getOrCreateReactive(value);
+        if (index < reactiveArray.length) {
+          reactiveArray.splice(index, 1, reactiveValue);
+        } else {
+          const currentLength = reactiveArray.length;
+          for (let i = currentLength; i < index; i++) {
+            reactiveArray.push(void 0);
+          }
+          reactiveArray.push(reactiveValue);
+        }
+        return true;
+      }
+      target[prop] = value;
+      return true;
+    },
+    has(target, prop) {
+      if (prop === "__isReactive" || prop === "__getReactiveArray") return true;
+      if (typeof prop === "symbol") return prop in target;
+      if (prop === "length") return true;
+      const index = Number(prop);
+      if (!isNaN(index) && index >= 0 && Number.isInteger(index)) {
+        return index < reactiveArray.length;
+      }
+      return prop in target;
+    },
+    ownKeys(target) {
+      const keys = ["length"];
+      for (let i = 0; i < reactiveArray.length; i++) {
+        keys.push(String(i));
+      }
+      return keys;
+    },
+    getOwnPropertyDescriptor(target, prop) {
+      if (prop === "__isReactive" || prop === "__getReactiveArray") {
+        return {
+          configurable: true,
+          enumerable: false,
+          value: prop === "__isReactive" ? true : reactiveArray,
+          writable: false
+        };
+      }
+      if (prop === "length") {
+        return {
+          configurable: true,
+          enumerable: false,
+          writable: true,
+          value: reactiveArray.length
+        };
+      }
+      const index = Number(prop);
+      if (!isNaN(index) && index >= 0 && Number.isInteger(index) && index < reactiveArray.length) {
+        return {
+          configurable: true,
+          enumerable: true,
+          writable: true,
+          value: this.get(target, prop, proxy)
+        };
+      }
+      return Object.getOwnPropertyDescriptor(target, prop);
+    }
+  });
+  proxyCache.set(reactiveArray, proxy);
+  return proxy;
+}
+function createStore(initialState) {
+  if (Array.isArray(initialState)) {
+    const reactiveArray = new ReactiveArray(initialState);
+    return createArrayProxy(reactiveArray);
+  } else {
+    const composite = new CompositeSignal(initialState);
+    return createObjectProxy(composite);
+  }
+}
+export {
+  createArrayProxy,
+  createObjectProxy,
+  createStore
+};

package/dist/reactivity/signals/reactive-tracking.test.d.ts

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

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

@@ -0,0 +1,9 @@
+type ResourceState = "pending" | "ready" | "error";
+export interface IResource<T> {
+    readonly isSignal: true;
+    get(): T | undefined;
+    state: ResourceState;
+    error?: Error;
+}
+export declare function createResource<T>(source: (signal: AbortSignal) => Promise<T>): IResource<T>;
+export {};

package/dist/reactivity/signals/resource.js

@@ -0,0 +1,58 @@
+import { Signal } from "./signal.js";
+import { effect } from "./effect.js";
+class Resource {
+  constructor(source) {
+    this.isSignal = true;
+    this._currentAbortController = null;
+    this._dataSignal = new Signal(void 0);
+    this._stateSignal = new Signal("pending");
+    this._errorSignal = new Signal(void 0);
+    effect((onCleanup) => {
+      const abortController = new AbortController();
+      if (this._currentAbortController) {
+        this._currentAbortController.abort();
+      }
+      this._currentAbortController = abortController;
+      this._stateSignal.set("pending");
+      let isStale = false;
+      onCleanup(() => {
+        isStale = true;
+        abortController.abort();
+      });
+      const promise = source(abortController.signal);
+      promise.then((data) => {
+        if (!isStale) {
+          this._dataSignal.set(data);
+          this._stateSignal.set("ready");
+          this._errorSignal.set(void 0);
+        }
+      }).catch((err) => {
+        if (isStale) {
+          return;
+        }
+        if (err.name === "AbortError") {
+          return;
+        }
+        const error = err instanceof Error ? err : new Error(String(err));
+        this._dataSignal.set(void 0);
+        this._stateSignal.set("error");
+        this._errorSignal.set(error);
+      });
+    });
+  }
+  get() {
+    return this._dataSignal.get();
+  }
+  get state() {
+    return this._stateSignal.get();
+  }
+  get error() {
+    return this._errorSignal.get();
+  }
+}
+function createResource(source) {
+  return new Resource(source);
+}
+export {
+  createResource
+};

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

@@ -0,0 +1,39 @@
+import { Subscriber } from '../types.js';
+export interface ISignal<T> {
+    readonly isSignal: true;
+    get(): T;
+    set(newValue: T): void;
+    update(updater: (currentValue: T) => T): void;
+}
+/**
+ * Signal con sistema de fases
+ *
+ * Diferencias clave vs sistema de prioridades:
+ * - notify() marca subscribers como dirty en lugar de ejecutarlos
+ * - El phase-scheduler maneja el ordenamiento topológico
+ * - Garantiza consistencia eliminando glitches
+ */
+export declare class Signal<T> implements ISignal<T> {
+    readonly isSignal = true;
+    private _value;
+    private _subscribers;
+    constructor(initialValue: T);
+    get(): T;
+    set(newValue: T): void;
+    update(updater: (currentValue: T) => T): void;
+    private _notify;
+    /**
+     * Permite que un computed se des-suscriba de esta signal.
+     * Usado cuando el computed hace cleanup de sus dependencias.
+     */
+    _unsubscribe(subscriber: Subscriber): void;
+    /**
+     * Método interno para obtener todos los subscribers (útil para debugging)
+     */
+    _getSubscribers(): Set<Subscriber>;
+}
+/**
+ * Helper para verificar si algo implementa ISignal
+ * Verifica la propiedad pública isSignal y el método get()
+ */
+export declare function isSignal<T>(value: unknown): value is ISignal<T>;

package/dist/reactivity/signals/signal.js

@@ -0,0 +1,56 @@
+import { reactiveContext } from "../reactive-context.js";
+import { phaseScheduler } from "../phase-scheduler.js";
+class Signal {
+  constructor(initialValue) {
+    this.isSignal = true;
+    this._subscribers = /* @__PURE__ */ new Set();
+    this._value = initialValue;
+  }
+  get() {
+    if (reactiveContext.currentComputation && reactiveContext.isTracking) {
+      this._subscribers.add(reactiveContext.currentComputation);
+      reactiveContext.onTrack?.(this);
+    }
+    return this._value;
+  }
+  set(newValue) {
+    if (!Object.is(this._value, newValue)) {
+      this._value = newValue;
+      this._notify();
+    }
+  }
+  update(updater) {
+    const currentValue = this.get();
+    const newValue = updater(currentValue);
+    this.set(newValue);
+  }
+  _notify() {
+    this._subscribers.forEach((subscriber) => {
+      if (subscriber._isComputation) {
+        subscriber();
+      } else {
+        phaseScheduler.schedule(subscriber);
+      }
+    });
+  }
+  /**
+   * Permite que un computed se des-suscriba de esta signal.
+   * Usado cuando el computed hace cleanup de sus dependencias.
+   */
+  _unsubscribe(subscriber) {
+    this._subscribers.delete(subscriber);
+  }
+  /**
+   * Método interno para obtener todos los subscribers (útil para debugging)
+   */
+  _getSubscribers() {
+    return this._subscribers;
+  }
+}
+function isSignal(value) {
+  return typeof value === "object" && value !== null && "isSignal" in value && value.isSignal === true && typeof value.get === "function";
+}
+export {
+  Signal,
+  isSignal
+};

package/dist/reactivity/signals/subscription-management.test.d.ts

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

package/dist/reactivity/types.d.ts

@@ -0,0 +1,12 @@
+export type EffectPriority = "Sync" | "Frame" | "Idle";
+export interface Subscriber extends Function {
+    priority?: EffectPriority;
+    /**
+     * Marca que indica si este subscriber es una computación (Computed)
+     * que debe ejecutarse síncronamente para evitar glitches.
+     *
+     * - true: Es un Computed, ejecutar síncronamente
+     * - false/undefined: Es un Effect, agendar en scheduler
+     */
+    _isComputation?: boolean;
+}

package/dist/router/__tests__/link-behavior-active-class.test.d.ts

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

package/dist/router/__tests__/loop-detector.test.d.ts

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

package/dist/router/__tests__/params-container-resolution.test.d.ts

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

package/dist/router/__tests__/router-generated-routes.test.d.ts

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

package/dist/router/__tests__/router-params-granular.test.d.ts

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

package/dist/router/__tests__/router-params-simple.test.d.ts

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

package/dist/router/__tests__/router-query-params.test.d.ts

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

package/dist/router/__tests__/router-route-candidates.test.d.ts

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

package/dist/router/__tests__/routeview-app-articles.test.d.ts

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

package/dist/router/__tests__/routeview-debug.test.d.ts

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

package/dist/router/__tests__/routeview-integration.test.d.ts

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

package/dist/router/__tests__/routeview-this.test.d.ts

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

package/dist/router/decorators/base-policy.d.ts

@@ -0,0 +1,141 @@
+import { Constructor } from '../../DI/types';
+/**
+ * Tipos de decisiones que una política puede tomar sobre una navegación.
+ * Cada decorador corresponde a uno de estos tipos.
+ */
+export type PolicyDecisionType = 'allow' | 'block' | 'redirect' | 'skip';
+/**
+ * Representa una regla individual dentro de una política.
+ * Una regla es un método decorado que puede tomar decisiones sobre navegación.
+ */
+export interface PolicyRule {
+    /** Nombre del método (útil para debugging) */
+    methodName: string | symbol;
+    /** La función del método que se ejecutará */
+    handler: Function;
+    /** Qué tipo de decisión toma este método cuando retorna true */
+    type: PolicyDecisionType;
+}
+/**
+ * El resultado de evaluar una política.
+ * Contiene información sobre qué se decidió y por qué.
+ */
+export interface PolicyDecision {
+    /** Qué tipo de acción debe tomarse */
+    type: PolicyDecisionType;
+    /** Si alguna regla coincidió (retornó true) */
+    matched: boolean;
+    /** Nombre del método que tomó la decisión (si matched es true) */
+    matchedRule?: string | symbol;
+}
+/**
+ * Helper para obtener las reglas almacenadas en una clase de política.
+ * Este método es usado internamente por el evaluador de políticas.
+ *
+ * @param policyClass El constructor de cualquier clase con métodos decorados
+ * @returns Array de reglas en el orden que fueron declaradas
+ */
+export declare function getPolicyRules(policyClass: Constructor<any>): PolicyRule[];
+/**
+ * Decorador @Allow()
+ *
+ * Marca un método que, cuando retorna true, indica que la navegación
+ * debe ser permitida. El componente se cargará y la ruta se activará.
+ *
+ * El método puede ser síncrono o asíncrono.
+ * Si retorna false o undefined, se considera que este método no tiene
+ * opinión sobre la navegación y se continuará evaluando otros métodos.
+ *
+ * @example
+ * ```typescript
+ * @Allow()
+ * publicRoute() {
+ *   return this.route.meta?.public === true;
+ * }
+ * ```
+ */
+export declare function Allow(): (target: Function, context: ClassMethodDecoratorContext) => void;
+/**
+ * Decorador @Block()
+ *
+ * Marca un método que, cuando retorna true, indica que la navegación
+ * debe ser bloqueada completamente. El componente no se cargará y el
+ * router intentará el siguiente candidato si existe.
+ *
+ * A diferencia de @Redirect(), este decorador no navega a ninguna otra ruta.
+ * Simplemente detiene la navegación actual.
+ *
+ * @example
+ * ```typescript
+ * @Block()
+ * maintenanceMode() {
+ *   return this.configService.isMaintenanceMode();
+ * }
+ * ```
+ */
+export declare function Block(): (target: Function, context: ClassMethodDecoratorContext) => void;
+/**
+ * Decorador @Redirect()
+ *
+ * Marca un método que, cuando retorna true, indica que ya ha manejado
+ * la navegación mediante un redirect a otra ruta. El método debe llamar
+ * a router.navigate() antes de retornar true.
+ *
+ * El router detectará que el currentPath cambió durante la ejecución
+ * y cancelará la navegación original.
+ *
+ * @example
+ * ```typescript
+ * @Redirect()
+ * redirectToLogin() {
+ *   if (!this.authService.isAuthenticated()) {
+ *     sessionStorage.setItem('return_url', this.router.currentPath);
+ *     this.router.navigate('/login');
+ *     return true;
+ *   }
+ *   return false;
+ * }
+ * ```
+ */
+export declare function Redirect(): (target: Function, context: ClassMethodDecoratorContext) => void;
+/**
+ * Decorador @Skip()
+ *
+ * Marca un método que puede explícitamente declarar que TODA LA POLÍTICA
+ * no tiene opinión sobre una navegación particular retornando true.
+ *
+ * Esto es diferente de simplemente retornar false (que continúa evaluando
+ * otros métodos de la misma política). Cuando @Skip retorna true, se detiene
+ * la evaluación de esta política completa y se pasa a la siguiente política
+ * en la cadena.
+ *
+ * Esto es crítico para la composición de políticas. Permite que una política
+ * declare "yo no soy responsable de esta navegación, pregúntenle a otra política".
+ *
+ * @example
+ * ```typescript
+ * @Skip()
+ * onlyForAdminRoutes() {
+ *   // Esta política solo se preocupa de rutas /admin/*
+ *   // Para cualquier otra ruta, explícitamente nos abstenemos
+ *   if (!this.router.currentPath.startsWith('/admin/')) {
+ *     return true; // SKIP - no somos responsables de esto
+ *   }
+ *
+ *   // Si llegamos aquí, estamos en una ruta admin
+ *   // Retornar false para continuar evaluando otros métodos de esta política
+ *   return false;
+ * }
+ *
+ * @Allow()
+ * adminWithPermission() {
+ *   // Este método solo se ejecutará si onlyForAdminRoutes retornó false
+ *   return this.user.hasPermission('admin');
+ * }
+ * ```
+ *
+ * Caso de uso común: Políticas especializadas que solo aplican a ciertas rutas.
+ * Por ejemplo, una AdminPolicy que solo se preocupa de rutas /admin/*, o una
+ * ApiPolicy que solo se preocupa de rutas /api/*.
+ */
+export declare function Skip(): (target: Function, context: ClassMethodDecoratorContext) => void;