@v-ibe/core 0.1.0

package/dist/router/policy-evaluator.js

@@ -0,0 +1,209 @@
+import { Service } from "../DI/decorators/service.js";
+import { getPolicyRules } from "./decorators/base-policy.js";
+import { reactiveContext } from "../reactivity/reactive-context.js";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decoratorStart = (base) => [, , , __create(null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) fns[i].call(self);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var it, done, ctx, k = flags & 7, p = false;
+  var j = 0;
+  var extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (target = target.prototype, k < 5 && (k > 3 || !p) && __getOwnPropDesc(target, name));
+  __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    it = (0, decorators[i])(target, ctx), done._ = 1;
+    __expectFn(it) && (target = it);
+  }
+  return __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var _PolicyEvaluator_decorators, _init;
+_PolicyEvaluator_decorators = [Service];
+class PolicyEvaluator {
+  /**
+   * Evalúa una instancia de política ejecutando sus reglas decoradas en orden.
+   *
+   * @param policyInstance La instancia de la política a evaluar
+   * @param signal Optional AbortSignal para cancelar la evaluación
+   * @returns Una decisión sobre qué hacer con la navegación
+   *
+   * @example
+   * ```typescript
+   * const decision = await evaluator.evaluate(authPolicyInstance);
+   *
+   * if (decision.type === 'skip') {
+   *   // Esta política no opina, intentar la siguiente
+   * } else if (decision.type === 'allow') {
+   *   // Permitir la navegación
+   * } else if (decision.type === 'block') {
+   *   // Bloquear la navegación
+   * }
+   * ```
+   */
+  async evaluate(policyInstance, signal) {
+    const rules = getPolicyRules(policyInstance.constructor);
+    if (rules.length === 0) {
+      return {
+        type: "skip",
+        matched: false
+      };
+    }
+    for (const rule of rules) {
+      if (signal?.aborted) {
+        return {
+          type: "block",
+          matched: false
+        };
+      }
+      try {
+        const result = rule.handler.call(policyInstance);
+        const resolvedResult = await Promise.resolve(result);
+        if (!resolvedResult) {
+          continue;
+        }
+        if (rule.type === "skip") {
+          return {
+            type: "skip",
+            matched: true,
+            matchedRule: rule.methodName
+          };
+        }
+        return {
+          type: rule.type,
+          matched: true,
+          matchedRule: rule.methodName
+        };
+      } catch (error) {
+        console.error(
+          `Error in policy rule '${String(rule.methodName)}':`,
+          error
+        );
+        return {
+          type: "block",
+          matched: true,
+          matchedRule: rule.methodName
+        };
+      }
+    }
+    return {
+      type: "skip",
+      matched: false
+    };
+  }
+  /**
+   * Evalúa una cadena de políticas en orden hasta que una tome una decisión.
+   *
+   * Este método implementa la composición de políticas:
+   * - Si una política retorna 'skip' (o ninguna regla coincide), pasa a la siguiente
+   * - Si una política retorna 'allow', 'block', o 'redirect', se detiene y retorna esa decisión
+   * - Si todas las políticas hacen skip, retorna la decisión por defecto
+   *
+   * @param policyInstances Array de instancias de políticas a evaluar en orden
+   * @param defaultDecision La decisión a tomar si todas las políticas hacen skip (default: allow)
+   * @param signal Optional AbortSignal para cancelar la evaluación
+   * @returns La decisión tomada por la primera política que no hizo skip
+   *
+   * @example
+   * ```typescript
+   * const decision = await evaluator.evaluateChain([
+   *   authPolicyInstance,
+   *   featureFlagPolicyInstance,
+   *   rolePolicyInstance
+   * ]);
+   * ```
+   */
+  async evaluateChain(policyInstances, defaultDecision = "allow", signal) {
+    console.log(`[PolicyEvaluator] Evaluating chain of ${policyInstances.length} policies`);
+    for (const policyInstance of policyInstances) {
+      const policyName = policyInstance.constructor.name;
+      console.log(`[PolicyEvaluator] Evaluating policy: ${policyName}`);
+      if (signal?.aborted) {
+        console.log("[PolicyEvaluator] Signal aborted, stopping chain evaluation");
+        return {
+          type: "block",
+          matched: false
+        };
+      }
+      const decision = await this.evaluate(policyInstance, signal);
+      console.log(`[PolicyEvaluator] Policy ${policyName} decision: ${decision.type}${decision.matched ? ` (matched rule: ${String(decision.matchedRule)})` : ""}`);
+      if (decision.type !== "skip") {
+        console.log(`[PolicyEvaluator] Chain stopped at policy ${policyName} with decision: ${decision.type}`);
+        return decision;
+      }
+    }
+    console.log(`[PolicyEvaluator] All policies skipped, using default decision: ${defaultDecision}`);
+    return {
+      type: defaultDecision,
+      matched: false
+    };
+  }
+  /**
+   * Evalúa una lista de candidatos y retorna el primero que pase las policies.
+   *
+   * Este método maneja:
+   * - Candidatos sin policies (permitir por defecto)
+   * - Instanciación de policies desde el DI container
+   * - Inyección de metadata
+   * - Evaluación secuencial hasta encontrar un allow
+   *
+   * @param candidates Lista de candidatos a evaluar
+   * @param signal Optional AbortSignal para cancelar
+   * @returns Decisión con el candidato ganador o block/redirect
+   */
+  async evaluateCandidates(candidates, signal) {
+    for (const candidate of candidates) {
+      if (signal?.aborted) {
+        return { type: "block", matched: false };
+      }
+      if (!candidate.policies || candidate.policies.length === 0) {
+        console.log(`[PolicyEvaluator] No policies for ${candidate.path}, allowing by default`);
+        return {
+          type: "allow",
+          matched: true,
+          candidate
+        };
+      }
+      const policyInstances = candidate.policies.map((PolicyClass) => {
+        const instance = this.__container.get(PolicyClass);
+        if (candidate.metadata) {
+          instance.__routeMetadata = candidate.metadata;
+        }
+        return instance;
+      });
+      const decision = await reactiveContext.untrack(async () => {
+        return await this.evaluateChain(policyInstances, "allow", signal);
+      });
+      if (decision.type === "allow") {
+        return {
+          ...decision,
+          candidate
+        };
+      }
+      if (decision.type === "redirect") {
+        return decision;
+      }
+    }
+    return { type: "block", matched: false };
+  }
+}
+_init = __decoratorStart();
+PolicyEvaluator = __decorateElement(_init, 0, "PolicyEvaluator", _PolicyEvaluator_decorators, PolicyEvaluator);
+__runInitializers(_init, 1, PolicyEvaluator);
+export {
+  PolicyEvaluator
+};

package/dist/router/route-view.d.ts

@@ -0,0 +1,56 @@
+import { Router } from './router';
+import { BaseComponent } from '../components/base-component';
+import { IResource } from '../reactivity/signals/resource';
+import { PolicyEvaluator } from './policy-evaluator';
+import { RouteCandidate } from './trie.types';
+export declare class RouteView extends BaseComponent {
+    router: Router;
+    policyEvaluator: PolicyEvaluator;
+    routeSlot?: string;
+    navigationLevel: number;
+    /**
+     * Contexto que mantiene el historial de slots desde la raíz hasta el nivel actual.
+     * Cada RouteView agrega su slot al array, preservando el historial de los padres.
+     *
+     * Ejemplo: ['@main', '@sidebar', '@panel']
+     *
+     * Los componentes pueden acceder a este array para saber:
+     * - En qué slot se renderizaron (último elemento)
+     * - Toda la cadena de slots desde la raíz
+     */
+    slotPath: string[];
+    /**
+     * Contexto que provee el patrón de ruta base desde la cual se renderiza este nivel.
+     * Los componentes y behaviors hijos pueden usar esta ruta base para resolver rutas relativas.
+     *
+     * Se actualiza reactivamente cuando cambian los candidatos de este nivel.
+     * Los hijos heredan este valor de forma reactiva (señal derivada).
+     *
+     * Ejemplo: Si este RouteView renderiza "/store/:storeId", los links hijos
+     * que usen "sales" se resolverán como "/store/:storeId/sales" (con params resueltos)
+     */
+    routeBasePath: string;
+    /**
+    * Computed que retorna los candidatos para este nivel de navegación,
+    * filtrados por el slot especificado en la prop routeSlot.
+    *
+    * Solo se re-ejecuta cuando cambian los candidatos de ESTE nivel específico.
+    * Esto es granularidad perfecta: cambios en otros niveles NO afectan este computed.
+    */
+    get levelCandidates(): readonly RouteCandidate[];
+    /**
+     * Effect que sincroniza routeBasePath con los candidatos actuales.
+     * Se ejecuta automáticamente cuando cambian los candidatos de este nivel.
+     *
+     * Si hay candidatos, actualiza routeBasePath con el path del primer candidato.
+     * Si no hay candidatos, mantiene el valor actual (que puede ser '/' o heredado).
+     */
+    private syncRouteBasePath;
+    /**
+    * Resource que carga el componente asociado
+    * SOLO cuando cambia el segmento de este nivel
+    * Evalúa policies de todos los candidatos y toma el primero que pase
+    */
+    componentClass: IResource<any>;
+    view(): any;
+}

package/dist/router/route-view.js

@@ -0,0 +1,156 @@
+import { Fragment } from "../jsx/types.js";
+import { Component } from "../components/decorators/component.js";
+import { Inject } from "../DI/decorators/inject.js";
+import { Router } from "./router.js";
+import { BaseComponent } from "../components/base-component.js";
+import { Ctx } from "../reactivity/decorators/ctx.js";
+import { Prop } from "../components/decorators/prop.js";
+import { Resource } from "../reactivity/decorators/resource.js";
+import { Computed } from "../reactivity/decorators/computed.js";
+import { Effect } from "../reactivity/decorators/effect.js";
+import { Show } from "../custom-components/show.js";
+import { PolicyEvaluator } from "./policy-evaluator.js";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++)
+    flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
+    return __privateGet(this, extra);
+  }, set [name](x) {
+    return __privateSet(this, extra, x);
+  } }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
+      if (k ^ 3)
+        access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2)
+        access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
+    if (k ^ 4 || it === void 0)
+      __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null)
+      __typeError("Object expected");
+    else
+      __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _componentClass_dec, _syncRouteBasePath_dec, _levelCandidates_dec, _routeBasePath_dec, _slotPath_dec, _navigationLevel_dec, _routeSlot_dec, _policyEvaluator_dec, _router_dec, _a, _RouteView_decorators, _init;
+const EMPTY_ARRAY = [];
+_RouteView_decorators = [Component()];
+class RouteView extends (_a = BaseComponent, _router_dec = [Inject(Router)], _policyEvaluator_dec = [Inject(PolicyEvaluator)], _routeSlot_dec = [Prop], _navigationLevel_dec = [Ctx((v) => v === void 0 ? 0 : v + 1)], _slotPath_dec = [Ctx((parentSlots, self) => {
+  const slots = parentSlots ? [...parentSlots] : [];
+  if (self.routeSlot) {
+    slots.push(self.routeSlot);
+  }
+  return slots;
+})], _routeBasePath_dec = [Ctx()], _levelCandidates_dec = [Computed], _syncRouteBasePath_dec = [Effect], _componentClass_dec = [Resource(async function(signal) {
+  try {
+    const candidates = this.levelCandidates;
+    if (!candidates || candidates.length === 0) {
+      return null;
+    }
+    const decision = await this.policyEvaluator.evaluateCandidates(candidates, signal);
+    if (!decision.candidate) {
+      console.log("[RouteView] No candidate passed policy evaluation");
+      return null;
+    }
+    const candidate = decision.candidate;
+    const module = await candidate.loader(signal);
+    if (module?.default) {
+      return module.default;
+    }
+  } catch (err) {
+    console.error("[RouteView] Error loading component:", err);
+  }
+  return null;
+})], _a) {
+  constructor() {
+    super(...arguments);
+    __runInitializers(_init, 5, this);
+    this.router = __runInitializers(_init, 8, this), __runInitializers(_init, 11, this);
+    this.policyEvaluator = __runInitializers(_init, 12, this), __runInitializers(_init, 15, this);
+    this.routeSlot = __runInitializers(_init, 16, this), __runInitializers(_init, 19, this);
+    this.navigationLevel = __runInitializers(_init, 20, this), __runInitializers(_init, 23, this);
+    this.slotPath = __runInitializers(_init, 24, this), __runInitializers(_init, 27, this);
+    this.routeBasePath = __runInitializers(_init, 28, this, "/"), __runInitializers(_init, 31, this);
+    this.componentClass = __runInitializers(_init, 32, this), __runInitializers(_init, 35, this);
+  }
+  get levelCandidates() {
+    const level = this.navigationLevel;
+    const candidates = this.router.$routeCandidates[level];
+    if (candidates === void 0) {
+      return EMPTY_ARRAY;
+    }
+    if (!candidates || candidates.length === 0) {
+      return EMPTY_ARRAY;
+    }
+    const filtered = candidates.filter((candidate) => {
+      if (!this.routeSlot) {
+        return !candidate.slot;
+      }
+      return candidate.slot === this.routeSlot;
+    });
+    return filtered.length > 0 ? filtered : EMPTY_ARRAY;
+  }
+  syncRouteBasePath() {
+    const candidates = this.levelCandidates;
+    if (candidates && candidates.length > 0) {
+      this.routeBasePath = candidates[0].path;
+    }
+  }
+  view() {
+    return /* @__PURE__ */ this.jsxs(Fragment, { children: [
+      /* @__PURE__ */ this.jsx(Show, { when: () => this.componentClass.state === "pending", children: () => /* @__PURE__ */ this.jsx("div", { children: "Cargando..." }) }),
+      /* @__PURE__ */ this.jsx(Show, { when: () => this.componentClass.state === "error", children: () => /* @__PURE__ */ this.jsxs("div", { children: [
+        "Error al cargar la página:",
+        " ",
+        () => this.componentClass.error
+      ] }) }),
+      /* @__PURE__ */ this.jsx(Show, { when: () => this.componentClass.state === "ready", children: () => this.jsx(this.componentClass.get() ?? null, {}) })
+    ] });
+  }
+}
+_init = __decoratorStart(_a);
+__decorateElement(_init, 2, "levelCandidates", _levelCandidates_dec, RouteView);
+__decorateElement(_init, 1, "syncRouteBasePath", _syncRouteBasePath_dec, RouteView);
+__decorateElement(_init, 5, "router", _router_dec, RouteView);
+__decorateElement(_init, 5, "policyEvaluator", _policyEvaluator_dec, RouteView);
+__decorateElement(_init, 5, "routeSlot", _routeSlot_dec, RouteView);
+__decorateElement(_init, 5, "navigationLevel", _navigationLevel_dec, RouteView);
+__decorateElement(_init, 5, "slotPath", _slotPath_dec, RouteView);
+__decorateElement(_init, 5, "routeBasePath", _routeBasePath_dec, RouteView);
+__decorateElement(_init, 5, "componentClass", _componentClass_dec, RouteView);
+RouteView = __decorateElement(_init, 0, "RouteView", _RouteView_decorators, RouteView);
+__runInitializers(_init, 1, RouteView);
+export {
+  RouteView
+};

package/dist/router/router.d.ts

@@ -0,0 +1,67 @@
+import { Trie } from './trie';
+import { LifeCycle } from '../DI/lifecycle';
+import { PolicyEvaluator } from './policy-evaluator';
+import { Constructor } from '../DI/types';
+import { RouteCandidate } from './trie.types';
+/**
+ * Interfaz para rutas generadas por el plugin de Vite
+ */
+export interface GeneratedRoute {
+    id: string;
+    path: string;
+    className: string;
+    loader: (signal?: AbortSignal) => Promise<{
+        default: any;
+    }>;
+    metadata?: Record<string, any>;
+    policies?: Constructor<any>[];
+    slot?: string;
+}
+export declare class Router implements LifeCycle {
+    pathname: string;
+    search: string;
+    get currentPath(): string;
+    get activePatterns(): string[];
+    routeTrie: Trie;
+    policyEvaluator: PolicyEvaluator;
+    $params: Record<string, string>;
+    $queryParams: Record<string, string>;
+    $routeCandidates: RouteCandidate[][];
+    private hasInitialized;
+    private routesLoaded;
+    constructor();
+    onBootstrap(): Promise<void>;
+    private syncRouteParams;
+    private syncQueryParams;
+    private syncRouteCandidates;
+    /**
+     * Compara dos arrays de candidatos para determinar si son iguales
+     * Usa comparación por id para determinar identidad
+     */
+    private candidatesAreEqual;
+    /**
+     * Fuerza la re-evaluación de todos los route candidates
+     * recalculando los candidatos desde el Trie.
+     *
+     * Esto hace que todos los RouteView detecten el cambio y re-ejecuten
+     * sus Resources, incluyendo la evaluación de policies.
+     *
+     * Útil después de cambios de estado que afectan autorización (ej: OAuth login)
+     */
+    private revalidateRouteCandidates;
+    navigate(to: string, options?: {
+        revalidate?: boolean;
+        replace?: boolean;
+        external?: 'allow' | 'block' | 'native';
+    }): void;
+    /**
+     * Carga las rutas generadas por el plugin de Vite
+     * Intenta múltiples rutas posibles donde el archivo puede estar generado
+     */
+    private loadGeneratedRoutes;
+    /**
+     * Registra un array de rutas generadas en el Trie
+     * @param routes Array de rutas generadas por el plugin
+     */
+    registerGeneratedRoutes(routes: GeneratedRoute[]): void;
+}