@v-ibe/core 0.1.0

package/dist/behaviors/decorators.d.ts

@@ -0,0 +1,87 @@
+/**
+ * @Behavior class decorator.
+ *
+ * Marks a class as a Behavior and registers it in the BehaviorRegistry.
+ * The class should have at least one @Prop decorated field that serves as
+ * the activator (a boolean prop that enables the behavior).
+ *
+ * @example
+ * @Behavior
+ * export class Link {
+ *   @Host
+ *   el!: HTMLAnchorElement;
+ *
+ *   @Prop link: boolean = true;      // Activator
+ *   @Prop href: string = '';         // Config
+ *   @Prop activeClass?: string;      // Optional config
+ *
+ *   onInit() {
+ *     this.el.href = this.href;
+ *   }
+ * }
+ *
+ * // Usage in JSX:
+ * <a link href="/home" activeClass="active">Home</a>
+ */
+export declare function Behavior<T extends new (...args: any[]) => any>(target: T, context: ClassDecoratorContext): T;
+/**
+ * @Host field decorator.
+ *
+ * Marks a field to receive the host element. Works with both:
+ * - Behaviors: BehaviorManager injects the DOM element before calling onInit()
+ * - StyleSheets: BaseStyleSheet injects the component via setHost()
+ *
+ * @example
+ * // In a Behavior:
+ * @Behavior
+ * class Tooltip {
+ *   @Host
+ *   el!: HTMLElement;
+ *
+ *   onInit() {
+ *     console.log('Attached to:', this.el.tagName);
+ *   }
+ * }
+ *
+ * @example
+ * // In a StyleSheet:
+ * class MyStyles extends BaseStyleSheet {
+ *   @Host
+ *   host!: BaseComponent;
+ *
+ *   @Rule(':host')
+ *   get hostRule() {
+ *     return { display: 'block' };
+ *   }
+ * }
+ */
+export declare function Host<T = Element>(target: undefined, context: ClassFieldDecoratorContext<any, T>): (this: any, initialValue: T) => T;
+/**
+ * @ComponentHost field decorator.
+ *
+ * Marks a field to receive the host component that contains this behavior.
+ * Allows behaviors to access the context (@Ctx) of the component.
+ *
+ * @example
+ * @Behavior
+ * class Link {
+ *   @Host
+ *   el!: HTMLAnchorElement;  // DOM element
+ *
+ *   @ComponentHost
+ *   hostComponent?: BaseComponent;  // Component container
+ *
+ *   @Inject(Router)
+ *   router!: Router;
+ *
+ *   onInit() {
+ *     // Access component context
+ *     const basePath = (this.hostComponent as any).routeBasePath;
+ *     // Use basePath for route resolution...
+ *   }
+ * }
+ *
+ * // Usage in JSX (no changes needed):
+ * <a link href="sales" activeClass="active">Sales</a>
+ */
+export declare function ComponentHost<T = any>(target: undefined, context: ClassFieldDecoratorContext<any, T>): (this: any, initialValue: T) => T;

package/dist/behaviors/decorators.js

@@ -0,0 +1,46 @@
+import { BehaviorRegistry } from "./behavior-registry.js";
+import { BEHAVIOR_PROPS, HOST_KEY, COMPONENT_HOST_KEY } from "./constants.js";
+function Behavior(target, context) {
+  const metadata = context.metadata;
+  const props = metadata[BEHAVIOR_PROPS];
+  const hostField = metadata[HOST_KEY];
+  if (props) {
+    target[BEHAVIOR_PROPS] = props;
+  }
+  if (hostField) {
+    target[HOST_KEY] = hostField;
+  }
+  BehaviorRegistry.register(target);
+  return target;
+}
+function Host(target, context) {
+  if (context.kind !== "field") {
+    throw new Error("@Host can only be applied to class fields.");
+  }
+  const metadata = context.metadata;
+  metadata[HOST_KEY] = context.name;
+  context.addInitializer(function() {
+    this.constructor[HOST_KEY] = context.name;
+  });
+  return function(initialValue) {
+    return initialValue;
+  };
+}
+function ComponentHost(target, context) {
+  if (context.kind !== "field") {
+    throw new Error("@ComponentHost can only be applied to class fields.");
+  }
+  const metadata = context.metadata;
+  metadata[COMPONENT_HOST_KEY] = context.name;
+  context.addInitializer(function() {
+    this.constructor[COMPONENT_HOST_KEY] = context.name;
+  });
+  return function(initialValue) {
+    return initialValue;
+  };
+}
+export {
+  Behavior,
+  ComponentHost,
+  Host
+};

package/dist/behaviors/index.d.ts

@@ -0,0 +1,4 @@
+export { BEHAVIOR_PROPS, HOST_KEY, COMPONENT_HOST_KEY } from './constants';
+export { Behavior, Host, ComponentHost } from './decorators';
+export { BehaviorRegistry } from './behavior-registry';
+export { BehaviorManager } from './behavior-manager';

package/dist/components/__tests__/host.test.d.ts

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

package/dist/components/app-tree.d.ts

@@ -0,0 +1,49 @@
+import { BaseComponent } from './base-component';
+import { Constructor } from '../DI/types';
+import { ComponentMetadata, INode } from './types';
+import { ISignal } from '../reactivity/signals/signal';
+import { ScopedContainer } from '../DI/scoped-container';
+export declare class AppTree {
+    private static metadataRegistry;
+    private static nodes;
+    private static root;
+    /**
+     * Registra la metadata de una clase de Componente.
+     * Se llama desde el decorador @Component.
+     */
+    static registerMetadata(metadata: ComponentMetadata): void;
+    /**
+     * Obtiene la metadata para una clase de componente específica.
+     */
+    static getMetadata(componentClass: Constructor<BaseComponent>): ComponentMetadata | undefined;
+    /**
+     * Registra una instancia de componente en el árbol jerárquico.
+     * Se llama desde connectedCallback.
+     */
+    static registerInstance(instance: BaseComponent, parent?: INode): INode;
+    /**
+     * Elimina una instancia del árbol jerárquico.
+     * Se llama desde disconnectedCallback.
+     */
+    static unregisterInstance(node: INode): void;
+    static getRoot(): INode | null;
+    static findByTag(tagName: string): INode[];
+    static findByInstance(instance: BaseComponent): INode | undefined;
+    static getParentFor(instance: BaseComponent): INode | undefined;
+    /**
+     * Busca recursivamente hacia arriba desde un nodo inicial una propiedad
+     * que represente una señal de contexto (ej: "$level").
+     * @param signalPropName El nombre de la propiedad de la señal (ej: "$level").
+     * @param startNode El nodo desde el cual comenzar la búsqueda hacia arriba.
+     * @returns La señal encontrada o undefined.
+     */
+    static findContextSignalFor(signalPropName: string, startNode: INode | undefined): ISignal<any> | undefined;
+    /**
+     * Busca recursivamente hacia arriba desde un nodo inicial el
+     * ScopedContainer más cercano en la jerarquía de componentes.
+     *
+     * Sigue el mismo patrón que findContextSignalFor:
+     * sube por el árbol buscando un nodo que tenga un container.
+     */
+    static findContainerFor(startNode: INode | undefined): ScopedContainer | undefined;
+}

package/dist/components/app-tree.js

@@ -0,0 +1,122 @@
+import { isSignal } from "../reactivity/signals/signal.js";
+const _AppTree = class _AppTree {
+  // --- MÉTODOS PARA GESTIONAR METADATA ---
+  /**
+   * Registra la metadata de una clase de Componente.
+   * Se llama desde el decorador @Component.
+   */
+  static registerMetadata(metadata) {
+    this.metadataRegistry.set(metadata.componentClass, metadata);
+  }
+  /**
+   * Obtiene la metadata para una clase de componente específica.
+   */
+  // CAMBIO: El método ahora espera una clase (Constructor) en lugar de un tagName (string).
+  static getMetadata(componentClass) {
+    return this.metadataRegistry.get(componentClass);
+  }
+  // --- MÉTODOS PARA GESTIONAR INSTANCIAS ---
+  /**
+   * Registra una instancia de componente en el árbol jerárquico.
+   * Se llama desde connectedCallback.
+   */
+  static registerInstance(instance, parent) {
+    const metadata = this.getMetadata(
+      instance.constructor
+    );
+    if (!metadata) {
+      throw new Error(
+        // El mensaje de error es más preciso ahora.
+        `Intentando instanciar <${instance.tagName}> pero sus metadatos no fueron registrados. ¿Olvidaste el decorador @Component en la clase ${instance.constructor.name}?`
+      );
+    }
+    const node = {
+      id: crypto.randomUUID(),
+      metadata,
+      instance,
+      parent,
+      children: []
+    };
+    this.nodes.set(node.id, node);
+    if (parent) {
+      parent.children.push(node);
+    } else {
+      this.root = node;
+    }
+    return node;
+  }
+  /**
+   * Elimina una instancia del árbol jerárquico.
+   * Se llama desde disconnectedCallback.
+   */
+  static unregisterInstance(node) {
+    if (node.parent) {
+      node.parent.children = node.parent.children.filter((c) => c !== node);
+    } else if (this.root === node) {
+      this.root = null;
+    }
+    this.nodes.delete(node.id);
+  }
+  // --- MÉTODOS DE BÚSQUEDA (sin cambios, siguen siendo útiles) ---
+  static getRoot() {
+    return this.root;
+  }
+  static findByTag(tagName) {
+    const lowerCaseTag = tagName.toLowerCase();
+    return [...this.nodes.values()].filter(
+      (n) => n.metadata.tagName.toLowerCase() === lowerCaseTag
+    );
+  }
+  static findByInstance(instance) {
+    return [...this.nodes.values()].find((n) => n.instance === instance);
+  }
+  static getParentFor(instance) {
+    const node = this.findByInstance(instance);
+    return node ? node.parent : void 0;
+  }
+  /**
+   * Busca recursivamente hacia arriba desde un nodo inicial una propiedad
+   * que represente una señal de contexto (ej: "$level").
+   * @param signalPropName El nombre de la propiedad de la señal (ej: "$level").
+   * @param startNode El nodo desde el cual comenzar la búsqueda hacia arriba.
+   * @returns La señal encontrada o undefined.
+   */
+  static findContextSignalFor(signalPropName, startNode) {
+    let currentNode = startNode;
+    while (currentNode) {
+      const instance = currentNode.instance;
+      if (instance && signalPropName in instance) {
+        const potentialSignal = instance[signalPropName];
+        if (isSignal(potentialSignal)) {
+          return potentialSignal;
+        }
+      }
+      currentNode = currentNode.parent;
+    }
+    return void 0;
+  }
+  /**
+   * Busca recursivamente hacia arriba desde un nodo inicial el
+   * ScopedContainer más cercano en la jerarquía de componentes.
+   *
+   * Sigue el mismo patrón que findContextSignalFor:
+   * sube por el árbol buscando un nodo que tenga un container.
+   */
+  static findContainerFor(startNode) {
+    let currentNode = startNode;
+    while (currentNode) {
+      if (currentNode.container) {
+        return currentNode.container;
+      }
+      currentNode = currentNode.parent;
+    }
+    return void 0;
+  }
+};
+_AppTree.metadataRegistry = /* @__PURE__ */ new Map();
+_AppTree.nodes = /* @__PURE__ */ new Map();
+_AppTree.root = null;
+let AppTree = _AppTree;
+export {
+  AppTree
+};

package/dist/components/base-component.d.ts

@@ -0,0 +1,85 @@
+import { INode } from './types';
+import { BehaviorManager } from '../behaviors/behavior-manager';
+export declare class BaseComponent extends HTMLElement {
+    #private;
+    protected appNode?: INode;
+    protected _pendingContextInitializers?: (() => void)[];
+    _pendingEffects?: (() => void)[];
+    protected behaviorManager: BehaviorManager;
+    constructor();
+    /**
+     * Obtiene el root donde se renderizan los elementos.
+     * Puede ser shadowRoot o el elemento mismo si no usa shadow DOM.
+     */
+    protected get renderRoot(): HTMLElement | ShadowRoot;
+    /**
+     * Registra un efecto pendiente que se ejecutará después de la inicialización
+     * Usado por el decorador @Effect para diferir la ejecución
+     */
+    queueEffect(effectFn: () => void): void;
+    /**
+     * Ejecuta todos los efectos pendientes
+     * Se llama al final de initializeForJSX()
+     */
+    private flushPendingEffects;
+    initializeForJSX(): void;
+    connectedCallback(): void;
+    /**
+     * Bootstrap services declared in @Component({ services: [...] })
+     * for a given node. Creates a ScopedContainer with parent chain resolution.
+     * Used by both init() (DOM path) and createAndRenderComponent() (JSX path).
+     */
+    private static bootstrapServicesForNode;
+    /**
+     * Assign __container to a component instance.
+     * Uses the node's own container if it has one, otherwise walks up the tree.
+     */
+    private static assignContainer;
+    /**
+     * Proceso de inicialización asíncrona del componente
+     * Incluye renderizado progresivo
+     */
+    private init;
+    /**
+     * Renderiza un estado de error si la inicialización falla
+     */
+    private renderError;
+    /**
+    * Encuentra el nodo padre de este componente en el AppTree.
+    */
+    private findParentNode;
+    disconnectedCallback(): void;
+    /**
+    * Registra las stylesheets @Shared si este componente las declara.
+    */
+    private registerSharedStylesheetsIfNeeded;
+    /**
+     * Registra las stylesheets @ForDocument si este componente las declara.
+     */
+    private registerDocumentStylesIfNeeded;
+    /**
+    * Adopta todas las stylesheets @Shared registradas en el shadow root.
+    */
+    private adoptSharedStylesheets;
+    /**
+    * Adopta las stylesheets LOCALES de este componente específico.
+    */
+    private adoptLocalStylesheet;
+    private initializeContexts;
+    private initializeResources;
+    jsx(type: any, props: any): any;
+    jsxDEV(type: any, props: any): any;
+    jsxs(type: any, props: any): any;
+    /**
+     * Aplica className al host element del componente.
+     */
+    private applyClassNameToHost;
+    /**
+     * Establece las clases CSS en el host element.
+     */
+    private setHostClassName;
+    private createAndRenderComponent;
+    private createNativeElement;
+    private normalizeChildren;
+    private convertClassNameToTagName;
+}